var faceapi = (() => {
  var __defineProperty = Object.defineProperty;
  var __hasOwnProperty = Object.prototype.hasOwnProperty;
  var __assign = Object.assign;
  var __commonJS = (callback, module) => () => {
    if (!module) {
      module = {exports: {}};
      callback(module.exports, module);
    }
    return module.exports;
  };
  var __markAsModule = (target) => {
    return __defineProperty(target, "__esModule", {value: true});
  };
  var __export = (target, all3) => {
    __markAsModule(target);
    for (var name in all3)
      __defineProperty(target, name, {get: all3[name], enumerable: true});
  };
  var __exportStar = (target, module) => {
    __markAsModule(target);
    if (typeof module === "object" || typeof module === "function") {
      for (let key in module)
        if (!__hasOwnProperty.call(target, key) && key !== "default")
          __defineProperty(target, key, {get: () => module[key], enumerable: true});
    }
    return target;
  };
  var __toModule = (module) => {
    if (module && module.__esModule)
      return module;
    return __exportStar(__defineProperty({}, "default", {value: module, enumerable: true}), module);
  };

  // node_modules/seedrandom/lib/alea.js
  var require_alea = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function Alea(seed) {
        var me = this, mash = Mash();
        me.next = function() {
          var t = 2091639 * me.s0 + me.c * 23283064365386963e-26;
          me.s0 = me.s1;
          me.s1 = me.s2;
          return me.s2 = t - (me.c = t | 0);
        };
        me.c = 1;
        me.s0 = mash(" ");
        me.s1 = mash(" ");
        me.s2 = mash(" ");
        me.s0 -= mash(seed);
        if (me.s0 < 0) {
          me.s0 += 1;
        }
        me.s1 -= mash(seed);
        if (me.s1 < 0) {
          me.s1 += 1;
        }
        me.s2 -= mash(seed);
        if (me.s2 < 0) {
          me.s2 += 1;
        }
        mash = null;
      }
      function copy(f, t) {
        t.c = f.c;
        t.s0 = f.s0;
        t.s1 = f.s1;
        t.s2 = f.s2;
        return t;
      }
      function impl(seed, opts) {
        var xg = new Alea(seed), state = opts && opts.state, prng = xg.next;
        prng.int32 = function() {
          return xg.next() * 4294967296 | 0;
        };
        prng.double = function() {
          return prng() + (prng() * 2097152 | 0) * 11102230246251565e-32;
        };
        prng.quick = prng;
        if (state) {
          if (typeof state == "object")
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      function Mash() {
        var n = 4022871197;
        var mash = function(data) {
          data = data.toString();
          for (var i = 0; i < data.length; i++) {
            n += data.charCodeAt(i);
            var h = 0.02519603282416938 * n;
            n = h >>> 0;
            h -= n;
            h *= n;
            n = h >>> 0;
            h -= n;
            n += h * 4294967296;
          }
          return (n >>> 0) * 23283064365386963e-26;
        };
        return mash;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.alea = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // node_modules/seedrandom/lib/xor128.js
  var require_xor128 = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function XorGen(seed) {
        var me = this, strseed = "";
        me.x = 0;
        me.y = 0;
        me.z = 0;
        me.w = 0;
        me.next = function() {
          var t = me.x ^ me.x << 11;
          me.x = me.y;
          me.y = me.z;
          me.z = me.w;
          return me.w ^= me.w >>> 19 ^ t ^ t >>> 8;
        };
        if (seed === (seed | 0)) {
          me.x = seed;
        } else {
          strseed += seed;
        }
        for (var k = 0; k < strseed.length + 64; k++) {
          me.x ^= strseed.charCodeAt(k) | 0;
          me.next();
        }
      }
      function copy(f, t) {
        t.x = f.x;
        t.y = f.y;
        t.z = f.z;
        t.w = f.w;
        return t;
      }
      function impl(seed, opts) {
        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
          return (xg.next() >>> 0) / 4294967296;
        };
        prng.double = function() {
          do {
            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
          } while (result === 0);
          return result;
        };
        prng.int32 = xg.next;
        prng.quick = prng;
        if (state) {
          if (typeof state == "object")
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.xor128 = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // node_modules/seedrandom/lib/xorwow.js
  var require_xorwow = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function XorGen(seed) {
        var me = this, strseed = "";
        me.next = function() {
          var t = me.x ^ me.x >>> 2;
          me.x = me.y;
          me.y = me.z;
          me.z = me.w;
          me.w = me.v;
          return (me.d = me.d + 362437 | 0) + (me.v = me.v ^ me.v << 4 ^ (t ^ t << 1)) | 0;
        };
        me.x = 0;
        me.y = 0;
        me.z = 0;
        me.w = 0;
        me.v = 0;
        if (seed === (seed | 0)) {
          me.x = seed;
        } else {
          strseed += seed;
        }
        for (var k = 0; k < strseed.length + 64; k++) {
          me.x ^= strseed.charCodeAt(k) | 0;
          if (k == strseed.length) {
            me.d = me.x << 10 ^ me.x >>> 4;
          }
          me.next();
        }
      }
      function copy(f, t) {
        t.x = f.x;
        t.y = f.y;
        t.z = f.z;
        t.w = f.w;
        t.v = f.v;
        t.d = f.d;
        return t;
      }
      function impl(seed, opts) {
        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
          return (xg.next() >>> 0) / 4294967296;
        };
        prng.double = function() {
          do {
            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
          } while (result === 0);
          return result;
        };
        prng.int32 = xg.next;
        prng.quick = prng;
        if (state) {
          if (typeof state == "object")
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.xorwow = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // node_modules/seedrandom/lib/xorshift7.js
  var require_xorshift7 = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function XorGen(seed) {
        var me = this;
        me.next = function() {
          var X = me.x, i = me.i, t, v, w;
          t = X[i];
          t ^= t >>> 7;
          v = t ^ t << 24;
          t = X[i + 1 & 7];
          v ^= t ^ t >>> 10;
          t = X[i + 3 & 7];
          v ^= t ^ t >>> 3;
          t = X[i + 4 & 7];
          v ^= t ^ t << 7;
          t = X[i + 7 & 7];
          t = t ^ t << 13;
          v ^= t ^ t << 9;
          X[i] = v;
          me.i = i + 1 & 7;
          return v;
        };
        function init(me2, seed2) {
          var j, w, X = [];
          if (seed2 === (seed2 | 0)) {
            w = X[0] = seed2;
          } else {
            seed2 = "" + seed2;
            for (j = 0; j < seed2.length; ++j) {
              X[j & 7] = X[j & 7] << 15 ^ seed2.charCodeAt(j) + X[j + 1 & 7] << 13;
            }
          }
          while (X.length < 8)
            X.push(0);
          for (j = 0; j < 8 && X[j] === 0; ++j)
            ;
          if (j == 8)
            w = X[7] = -1;
          else
            w = X[j];
          me2.x = X;
          me2.i = 0;
          for (j = 256; j > 0; --j) {
            me2.next();
          }
        }
        init(me, seed);
      }
      function copy(f, t) {
        t.x = f.x.slice();
        t.i = f.i;
        return t;
      }
      function impl(seed, opts) {
        if (seed == null)
          seed = +new Date();
        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
          return (xg.next() >>> 0) / 4294967296;
        };
        prng.double = function() {
          do {
            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
          } while (result === 0);
          return result;
        };
        prng.int32 = xg.next;
        prng.quick = prng;
        if (state) {
          if (state.x)
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.xorshift7 = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // node_modules/seedrandom/lib/xor4096.js
  var require_xor4096 = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function XorGen(seed) {
        var me = this;
        me.next = function() {
          var w = me.w, X = me.X, i = me.i, t, v;
          me.w = w = w + 1640531527 | 0;
          v = X[i + 34 & 127];
          t = X[i = i + 1 & 127];
          v ^= v << 13;
          t ^= t << 17;
          v ^= v >>> 15;
          t ^= t >>> 12;
          v = X[i] = v ^ t;
          me.i = i;
          return v + (w ^ w >>> 16) | 0;
        };
        function init(me2, seed2) {
          var t, v, i, j, w, X = [], limit = 128;
          if (seed2 === (seed2 | 0)) {
            v = seed2;
            seed2 = null;
          } else {
            seed2 = seed2 + "\0";
            v = 0;
            limit = Math.max(limit, seed2.length);
          }
          for (i = 0, j = -32; j < limit; ++j) {
            if (seed2)
              v ^= seed2.charCodeAt((j + 32) % seed2.length);
            if (j === 0)
              w = v;
            v ^= v << 10;
            v ^= v >>> 15;
            v ^= v << 4;
            v ^= v >>> 13;
            if (j >= 0) {
              w = w + 1640531527 | 0;
              t = X[j & 127] ^= v + w;
              i = t == 0 ? i + 1 : 0;
            }
          }
          if (i >= 128) {
            X[(seed2 && seed2.length || 0) & 127] = -1;
          }
          i = 127;
          for (j = 4 * 128; j > 0; --j) {
            v = X[i + 34 & 127];
            t = X[i = i + 1 & 127];
            v ^= v << 13;
            t ^= t << 17;
            v ^= v >>> 15;
            t ^= t >>> 12;
            X[i] = v ^ t;
          }
          me2.w = w;
          me2.X = X;
          me2.i = i;
        }
        init(me, seed);
      }
      function copy(f, t) {
        t.i = f.i;
        t.w = f.w;
        t.X = f.X.slice();
        return t;
      }
      ;
      function impl(seed, opts) {
        if (seed == null)
          seed = +new Date();
        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
          return (xg.next() >>> 0) / 4294967296;
        };
        prng.double = function() {
          do {
            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
          } while (result === 0);
          return result;
        };
        prng.int32 = xg.next;
        prng.quick = prng;
        if (state) {
          if (state.X)
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.xor4096 = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // node_modules/seedrandom/lib/tychei.js
  var require_tychei = __commonJS((exports, module) => {
    (function(global2, module2, define2) {
      function XorGen(seed) {
        var me = this, strseed = "";
        me.next = function() {
          var b = me.b, c = me.c, d = me.d, a = me.a;
          b = b << 25 ^ b >>> 7 ^ c;
          c = c - d | 0;
          d = d << 24 ^ d >>> 8 ^ a;
          a = a - b | 0;
          me.b = b = b << 20 ^ b >>> 12 ^ c;
          me.c = c = c - d | 0;
          me.d = d << 16 ^ c >>> 16 ^ a;
          return me.a = a - b | 0;
        };
        me.a = 0;
        me.b = 0;
        me.c = 2654435769 | 0;
        me.d = 1367130551;
        if (seed === Math.floor(seed)) {
          me.a = seed / 4294967296 | 0;
          me.b = seed | 0;
        } else {
          strseed += seed;
        }
        for (var k = 0; k < strseed.length + 20; k++) {
          me.b ^= strseed.charCodeAt(k) | 0;
          me.next();
        }
      }
      function copy(f, t) {
        t.a = f.a;
        t.b = f.b;
        t.c = f.c;
        t.d = f.d;
        return t;
      }
      ;
      function impl(seed, opts) {
        var xg = new XorGen(seed), state = opts && opts.state, prng = function() {
          return (xg.next() >>> 0) / 4294967296;
        };
        prng.double = function() {
          do {
            var top = xg.next() >>> 11, bot = (xg.next() >>> 0) / 4294967296, result = (top + bot) / (1 << 21);
          } while (result === 0);
          return result;
        };
        prng.int32 = xg.next;
        prng.quick = prng;
        if (state) {
          if (typeof state == "object")
            copy(state, xg);
          prng.state = function() {
            return copy(xg, {});
          };
        }
        return prng;
      }
      if (module2 && module2.exports) {
        module2.exports = impl;
      } else if (define2 && define2.amd) {
        define2(function() {
          return impl;
        });
      } else {
        this.tychei = impl;
      }
    })(exports, typeof module == "object" && module, typeof define == "function" && define);
  });

  // disabled:crypto
  var require_disabled_crypto = __commonJS(() => {
  });

  // node_modules/seedrandom/seedrandom.js
  var require_seedrandom = __commonJS((exports, module) => {
    (function(pool3, math) {
      var global2 = this, width = 256, chunks = 6, digits = 52, rngname = "random", startdenom = math.pow(width, chunks), significance = math.pow(2, digits), overflow = significance * 2, mask = width - 1, nodecrypto;
      function seedrandom2(seed, options, callback) {
        var key = [];
        options = options == true ? {entropy: true} : options || {};
        var shortseed = mixkey(flatten2(options.entropy ? [seed, tostring(pool3)] : seed == null ? autoseed() : seed, 3), key);
        var arc4 = new ARC4(key);
        var prng = function() {
          var n = arc4.g(chunks), d = startdenom, x = 0;
          while (n < significance) {
            n = (n + x) * width;
            d *= width;
            x = arc4.g(1);
          }
          while (n >= overflow) {
            n /= 2;
            d /= 2;
            x >>>= 1;
          }
          return (n + x) / d;
        };
        prng.int32 = function() {
          return arc4.g(4) | 0;
        };
        prng.quick = function() {
          return arc4.g(4) / 4294967296;
        };
        prng.double = prng;
        mixkey(tostring(arc4.S), pool3);
        return (options.pass || callback || function(prng2, seed2, is_math_call, state) {
          if (state) {
            if (state.S) {
              copy(state, arc4);
            }
            prng2.state = function() {
              return copy(arc4, {});
            };
          }
          if (is_math_call) {
            math[rngname] = prng2;
            return seed2;
          } else
            return prng2;
        })(prng, shortseed, "global" in options ? options.global : this == math, options.state);
      }
      math["seed" + rngname] = seedrandom2;
      function ARC4(key) {
        var t, keylen = key.length, me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];
        if (!keylen) {
          key = [keylen++];
        }
        while (i < width) {
          s[i] = i++;
        }
        for (i = 0; i < width; i++) {
          s[i] = s[j = mask & j + key[i % keylen] + (t = s[i])];
          s[j] = t;
        }
        (me.g = function(count) {
          var t2, r = 0, i2 = me.i, j2 = me.j, s2 = me.S;
          while (count--) {
            t2 = s2[i2 = mask & i2 + 1];
            r = r * width + s2[mask & (s2[i2] = s2[j2 = mask & j2 + t2]) + (s2[j2] = t2)];
          }
          me.i = i2;
          me.j = j2;
          return r;
        })(width);
      }
      function copy(f, t) {
        t.i = f.i;
        t.j = f.j;
        t.S = f.S.slice();
        return t;
      }
      ;
      function flatten2(obj, depth) {
        var result = [], typ = typeof obj, prop;
        if (depth && typ == "object") {
          for (prop in obj) {
            try {
              result.push(flatten2(obj[prop], depth - 1));
            } catch (e) {
            }
          }
        }
        return result.length ? result : typ == "string" ? obj : obj + "\0";
      }
      function mixkey(seed, key) {
        var stringseed = seed + "", smear, j = 0;
        while (j < stringseed.length) {
          key[mask & j] = mask & (smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++);
        }
        return tostring(key);
      }
      function autoseed() {
        try {
          var out;
          if (nodecrypto && (out = nodecrypto.randomBytes)) {
            out = out(width);
          } else {
            out = new Uint8Array(width);
            (global2.crypto || global2.msCrypto).getRandomValues(out);
          }
          return tostring(out);
        } catch (e) {
          var browser = global2.navigator, plugins = browser && browser.plugins;
          return [+new Date(), global2, plugins, global2.screen, tostring(pool3)];
        }
      }
      function tostring(a) {
        return String.fromCharCode.apply(0, a);
      }
      mixkey(math.random(), pool3);
      if (typeof module == "object" && module.exports) {
        module.exports = seedrandom2;
        try {
          nodecrypto = require_disabled_crypto();
        } catch (ex) {
        }
      } else if (typeof define == "function" && define.amd) {
        define(function() {
          return seedrandom2;
        });
      }
    })([], Math);
  });

  // node_modules/seedrandom/index.js
  var require_seedrandom2 = __commonJS((exports, module) => {
    var alea2 = require_alea();
    var xor128 = require_xor128();
    var xorwow = require_xorwow();
    var xorshift7 = require_xorshift7();
    var xor4096 = require_xor4096();
    var tychei = require_tychei();
    var sr = require_seedrandom();
    sr.alea = alea2;
    sr.xor128 = xor128;
    sr.xorwow = xorwow;
    sr.xorshift7 = xorshift7;
    sr.xor4096 = xor4096;
    sr.tychei = tychei;
    module.exports = sr;
  });

  // build/src/env/isNodejs.js
  var require_isNodejs = __commonJS((exports, module) => {
    __export(exports, {
      isNodejs: () => isNodejs3
    });
    function isNodejs3() {
      return typeof global === "object" && true && typeof module !== "undefined" && typeof process !== "undefined" && !!process.version;
    }
  });

  // build/src/index.js
  var require_src = __commonJS((exports) => {
    __export(exports, {
      AgeGenderNet: () => AgeGenderNet,
      BoundingBox: () => BoundingBox,
      Box: () => Box,
      ComposableTask: () => ComposableTask,
      ComputeAllFaceDescriptorsTask: () => ComputeAllFaceDescriptorsTask,
      ComputeFaceDescriptorsTaskBase: () => ComputeFaceDescriptorsTaskBase,
      ComputeSingleFaceDescriptorTask: () => ComputeSingleFaceDescriptorTask,
      DetectAllFaceLandmarksTask: () => DetectAllFaceLandmarksTask,
      DetectAllFacesTask: () => DetectAllFacesTask,
      DetectFaceLandmarksTaskBase: () => DetectFaceLandmarksTaskBase,
      DetectFacesTaskBase: () => DetectFacesTaskBase,
      DetectSingleFaceLandmarksTask: () => DetectSingleFaceLandmarksTask,
      DetectSingleFaceTask: () => DetectSingleFaceTask,
      Dimensions: () => Dimensions,
      FACE_EXPRESSION_LABELS: () => FACE_EXPRESSION_LABELS,
      FaceDetection: () => FaceDetection,
      FaceDetectionNet: () => FaceDetectionNet,
      FaceExpressionNet: () => FaceExpressionNet,
      FaceExpressions: () => FaceExpressions,
      FaceLandmark68Net: () => FaceLandmark68Net,
      FaceLandmark68TinyNet: () => FaceLandmark68TinyNet,
      FaceLandmarkNet: () => FaceLandmarkNet,
      FaceLandmarks: () => FaceLandmarks,
      FaceLandmarks5: () => FaceLandmarks5,
      FaceLandmarks68: () => FaceLandmarks68,
      FaceMatch: () => FaceMatch,
      FaceMatcher: () => FaceMatcher,
      FaceRecognitionNet: () => FaceRecognitionNet,
      Gender: () => Gender,
      LabeledBox: () => LabeledBox,
      LabeledFaceDescriptors: () => LabeledFaceDescriptors,
      NetInput: () => NetInput,
      NeuralNetwork: () => NeuralNetwork,
      ObjectDetection: () => ObjectDetection,
      Point: () => Point,
      PredictedBox: () => PredictedBox,
      Rect: () => Rect,
      SsdMobilenetv1: () => SsdMobilenetv1,
      SsdMobilenetv1Options: () => SsdMobilenetv1Options,
      TinyFaceDetector: () => TinyFaceDetector,
      TinyFaceDetectorOptions: () => TinyFaceDetectorOptions,
      TinyYolov2: () => TinyYolov2,
      TinyYolov2Options: () => TinyYolov2Options,
      TinyYolov2SizeType: () => TinyYolov2SizeType,
      allFaces: () => allFaces,
      allFacesSsdMobilenetv1: () => allFacesSsdMobilenetv1,
      allFacesTinyYolov2: () => allFacesTinyYolov2,
      awaitMediaLoaded: () => awaitMediaLoaded,
      bufferToImage: () => bufferToImage,
      computeFaceDescriptor: () => computeFaceDescriptor,
      createCanvas: () => createCanvas,
      createCanvasFromMedia: () => createCanvasFromMedia,
      createFaceDetectionNet: () => createFaceDetectionNet,
      createFaceRecognitionNet: () => createFaceRecognitionNet,
      createSsdMobilenetv1: () => createSsdMobilenetv1,
      createTinyFaceDetector: () => createTinyFaceDetector,
      createTinyYolov2: () => createTinyYolov2,
      detectAllFaces: () => detectAllFaces,
      detectFaceLandmarks: () => detectFaceLandmarks,
      detectFaceLandmarksTiny: () => detectFaceLandmarksTiny,
      detectLandmarks: () => detectLandmarks,
      detectSingleFace: () => detectSingleFace,
      draw: () => draw_exports,
      env: () => env2,
      euclideanDistance: () => euclideanDistance,
      extendWithAge: () => extendWithAge,
      extendWithFaceDescriptor: () => extendWithFaceDescriptor,
      extendWithFaceDetection: () => extendWithFaceDetection,
      extendWithFaceExpressions: () => extendWithFaceExpressions,
      extendWithFaceLandmarks: () => extendWithFaceLandmarks,
      extendWithGender: () => extendWithGender,
      extractFaceTensors: () => extractFaceTensors,
      extractFaces: () => extractFaces,
      fetchImage: () => fetchImage,
      fetchJson: () => fetchJson,
      fetchNetWeights: () => fetchNetWeights,
      fetchOrThrow: () => fetchOrThrow,
      getContext2dOrThrow: () => getContext2dOrThrow,
      getMediaDimensions: () => getMediaDimensions,
      imageTensorToCanvas: () => imageTensorToCanvas,
      imageToSquare: () => imageToSquare,
      inverseSigmoid: () => inverseSigmoid,
      iou: () => iou,
      isMediaElement: () => isMediaElement,
      isMediaLoaded: () => isMediaLoaded,
      isWithAge: () => isWithAge,
      isWithFaceDetection: () => isWithFaceDetection,
      isWithFaceExpressions: () => isWithFaceExpressions,
      isWithFaceLandmarks: () => isWithFaceLandmarks,
      isWithGender: () => isWithGender,
      loadAgeGenderModel: () => loadAgeGenderModel,
      loadFaceDetectionModel: () => loadFaceDetectionModel,
      loadFaceExpressionModel: () => loadFaceExpressionModel,
      loadFaceLandmarkModel: () => loadFaceLandmarkModel,
      loadFaceLandmarkTinyModel: () => loadFaceLandmarkTinyModel,
      loadFaceRecognitionModel: () => loadFaceRecognitionModel,
      loadSsdMobilenetv1Model: () => loadSsdMobilenetv1Model,
      loadTinyFaceDetectorModel: () => loadTinyFaceDetectorModel,
      loadTinyYolov2Model: () => loadTinyYolov2Model,
      loadWeightMap: () => loadWeightMap,
      locateFaces: () => locateFaces,
      matchDimensions: () => matchDimensions,
      minBbox: () => minBbox,
      nets: () => nets,
      nonMaxSuppression: () => nonMaxSuppression2,
      normalize: () => normalize,
      padToSquare: () => padToSquare,
      predictAgeAndGender: () => predictAgeAndGender,
      recognizeFaceExpressions: () => recognizeFaceExpressions,
      resizeResults: () => resizeResults,
      resolveInput: () => resolveInput,
      shuffleArray: () => shuffleArray,
      sigmoid: () => sigmoid6,
      ssdMobilenetv1: () => ssdMobilenetv1,
      tf: () => dist_exports,
      tinyFaceDetector: () => tinyFaceDetector,
      tinyYolov2: () => tinyYolov23,
      toNetInput: () => toNetInput,
      utils: () => utils_exports,
      validateConfig: () => validateConfig,
      version: () => version3
    });
    const node = typeof process !== "undefined" ? process.version : false;
    const browser = typeof navigator !== "undefined" ? navigator.userAgent : false;
    const version3 = {faceapi: version2, node, browser, tfjs: version, backend: getBackend()};
  });

  // node_modules/@tensorflow/tfjs-core/dist/environment.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const TENSORFLOWJS_FLAGS_PREFIX = "tfjsflags";
  class Environment {
    constructor(global2) {
      this.global = global2;
      this.flags = {};
      this.flagRegistry = {};
      this.urlFlags = {};
      this.populateURLFlags();
    }
    setPlatform(platformName, platform) {
      if (this.platform != null) {
        console.warn(`Platform ${this.platformName} has already been set. Overwriting the platform with ${platform}.`);
      }
      this.platformName = platformName;
      this.platform = platform;
    }
    registerFlag(flagName, evaluationFn, setHook) {
      this.flagRegistry[flagName] = {evaluationFn, setHook};
      if (this.urlFlags[flagName] != null) {
        const flagValue = this.urlFlags[flagName];
        console.warn(`Setting feature override from URL ${flagName}: ${flagValue}.`);
        this.set(flagName, flagValue);
      }
    }
    async getAsync(flagName) {
      if (flagName in this.flags) {
        return this.flags[flagName];
      }
      this.flags[flagName] = await this.evaluateFlag(flagName);
      return this.flags[flagName];
    }
    get(flagName) {
      if (flagName in this.flags) {
        return this.flags[flagName];
      }
      const flagValue = this.evaluateFlag(flagName);
      if (flagValue instanceof Promise) {
        throw new Error(`Flag ${flagName} cannot be synchronously evaluated. Please use getAsync() instead.`);
      }
      this.flags[flagName] = flagValue;
      return this.flags[flagName];
    }
    getNumber(flagName) {
      return this.get(flagName);
    }
    getBool(flagName) {
      return this.get(flagName);
    }
    getFlags() {
      return this.flags;
    }
    get features() {
      return this.flags;
    }
    set(flagName, value) {
      if (this.flagRegistry[flagName] == null) {
        throw new Error(`Cannot set flag ${flagName} as it has not been registered.`);
      }
      this.flags[flagName] = value;
      if (this.flagRegistry[flagName].setHook != null) {
        this.flagRegistry[flagName].setHook(value);
      }
    }
    evaluateFlag(flagName) {
      if (this.flagRegistry[flagName] == null) {
        throw new Error(`Cannot evaluate flag '${flagName}': no evaluation function found.`);
      }
      return this.flagRegistry[flagName].evaluationFn();
    }
    setFlags(flags3) {
      this.flags = Object.assign({}, flags3);
    }
    reset() {
      this.flags = {};
      this.urlFlags = {};
      this.populateURLFlags();
    }
    populateURLFlags() {
      if (typeof this.global === "undefined" || typeof this.global.location === "undefined" || typeof this.global.location.search === "undefined") {
        return;
      }
      const urlParams = getQueryParams(this.global.location.search);
      if (TENSORFLOWJS_FLAGS_PREFIX in urlParams) {
        const keyValues = urlParams[TENSORFLOWJS_FLAGS_PREFIX].split(",");
        keyValues.forEach((keyValue) => {
          const [key, value] = keyValue.split(":");
          this.urlFlags[key] = parseValue(key, value);
        });
      }
    }
  }
  function getQueryParams(queryString) {
    const params = {};
    queryString.replace(/[?&]([^=?&]+)(?:=([^&]*))?/g, (s, ...t) => {
      decodeParam(params, t[0], t[1]);
      return t.join("=");
    });
    return params;
  }
  function decodeParam(params, name, value) {
    params[decodeURIComponent(name)] = decodeURIComponent(value || "");
  }
  function parseValue(flagName, value) {
    value = value.toLowerCase();
    if (value === "true" || value === "false") {
      return value === "true";
    } else if (`${+value}` === value) {
      return +value;
    }
    throw new Error(`Could not parse value flag value ${value} for flag ${flagName}.`);
  }
  function env() {
    return ENV;
  }
  let ENV = null;
  function setEnvironmentGlobal(environment12) {
    ENV = environment12;
  }

  // node_modules/@tensorflow/tfjs-core/dist/global_util.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  let globalNameSpace;
  function getGlobalNamespace() {
    if (globalNameSpace == null) {
      let ns;
      if (typeof window !== "undefined") {
        ns = window;
      } else if (typeof global !== "undefined") {
        ns = global;
      } else if (typeof process !== "undefined") {
        ns = process;
      } else if (typeof self !== "undefined") {
        ns = self;
      } else {
        throw new Error("Could not find a global object");
      }
      globalNameSpace = ns;
    }
    return globalNameSpace;
  }
  function getGlobalMap() {
    const ns = getGlobalNamespace();
    if (ns._tfGlobals == null) {
      ns._tfGlobals = new Map();
    }
    return ns._tfGlobals;
  }
  function getGlobal(key, init) {
    const globalMap = getGlobalMap();
    if (globalMap.has(key)) {
      return globalMap.get(key);
    } else {
      const singleton = init();
      globalMap.set(key, singleton);
      return globalMap.get(key);
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/kernel_names.js
  const Abs = "Abs";
  const Acos = "Acos";
  const Acosh = "Acosh";
  const Add = "Add";
  const AddN = "AddN";
  const All = "All";
  const Any = "Any";
  const ArgMax = "ArgMax";
  const ArgMin = "ArgMin";
  const Asin = "Asin";
  const Asinh = "Asinh";
  const Atan = "Atan";
  const Atanh = "Atanh";
  const Atan2 = "Atan2";
  const AvgPool = "AvgPool";
  const AvgPoolBackprop = "AvgPoolBackprop";
  const AvgPool3D = "AvgPool3D";
  const AvgPool3DBackprop = "AvgPool3DBackprop";
  const BatchMatMul = "BatchMatMul";
  const BatchToSpaceND = "BatchToSpaceND";
  const BroadcastTo = "BroadcastTo";
  const Cast = "Cast";
  const Ceil = "Ceil";
  const ClipByValue = "ClipByValue";
  const Complex = "Complex";
  const Concat = "Concat";
  const Conv2D = "Conv2D";
  const Conv2DBackpropFilter = "Conv2DBackpropFilter";
  const Conv2DBackpropInput = "Conv2DBackpropInput";
  const Conv3D = "Conv3D";
  const Conv3DBackpropFilterV2 = "Conv3DBackpropFilterV2";
  const Conv3DBackpropInputV2 = "Conv3DBackpropInputV2";
  const Cos = "Cos";
  const Cosh = "Cosh";
  const Cumsum = "Cumsum";
  const CropAndResize = "CropAndResize";
  const DepthToSpace = "DepthToSpace";
  const DepthwiseConv2dNative = "DepthwiseConv2dNative";
  const DepthwiseConv2dNativeBackpropFilter = "DepthwiseConv2dNativeBackpropFilter";
  const DepthwiseConv2dNativeBackpropInput = "DepthwiseConv2dNativeBackpropInput";
  const Diag = "Diag";
  const Dilation2D = "Dilation2D";
  const Dilation2DBackpropInput = "Dilation2DBackpropInput";
  const Dilation2DBackpropFilter = "Dilation2DBackpropFilter";
  const Div = "Div";
  const Elu = "Elu";
  const EluGrad = "EluGrad";
  const Erf = "Erf";
  const Equal = "Equal";
  const Exp = "Exp";
  const Expm1 = "Expm1";
  const FFT = "FFT";
  const Fill = "Fill";
  const FlipLeftRight = "FlipLeftRight";
  const Floor = "Floor";
  const FloorDiv = "FloorDiv";
  const FusedBatchNorm = "FusedBatchNorm";
  const GatherV2 = "GatherV2";
  const GatherNd = "GatherNd";
  const Greater = "Greater";
  const GreaterEqual = "GreaterEqual";
  const Identity = "Identity";
  const IFFT = "IFFT";
  const Imag = "Imag";
  const IsFinite = "IsFinite";
  const IsInf = "IsInf";
  const IsNan = "IsNan";
  const Less = "Less";
  const LessEqual = "LessEqual";
  const LinSpace = "LinSpace";
  const Log = "Log";
  const Log1p = "Log1p";
  const LogicalAnd = "LogicalAnd";
  const LogicalNot = "LogicalNot";
  const LogicalOr = "LogicalOr";
  const LogSoftmax = "LogSoftmax";
  const LRN = "LRN";
  const LRNBackprop = "LRNBackprop";
  const Max = "Max";
  const Maximum = "Maximum";
  const MaxPool = "MaxPool";
  const MaxPoolBackprop = "MaxPoolBackprop";
  const MaxPool3D = "MaxPool3D";
  const MaxPool3DBackprop = "MaxPool3DBackprop";
  const MaxPoolWithArgmax = "MaxPoolWithArgmax";
  const Mean = "Mean";
  const Min = "Min";
  const Minimum = "Minimum";
  const Mod = "Mod";
  const Multiply = "Multiply";
  const Negate = "Negate";
  const NotEqual = "NotEqual";
  const NonMaxSuppressionV3 = "NonMaxSuppressionV3";
  const NonMaxSuppressionV4 = "NonMaxSuppressionV4";
  const NonMaxSuppressionV5 = "NonMaxSuppressionV5";
  const OnesLike = "OnesLike";
  const OneHot = "OneHot";
  const PadV2 = "PadV2";
  const Pool = "Pool";
  const Pow = "Pow";
  const Prelu = "Prelu";
  const Prod = "Prod";
  const Range = "Range";
  const Real = "Real";
  const Reciprocal = "Reciprocal";
  const Relu = "Relu";
  const Reshape = "Reshape";
  const ResizeNearestNeighbor = "ResizeNearestNeighbor";
  const ResizeNearestNeighborGrad = "ResizeNearestNeighborGrad";
  const ResizeBilinear = "ResizeBilinear";
  const ResizeBilinearGrad = "ResizeBilinearGrad";
  const Relu6 = "Relu6";
  const Reverse = "Reverse";
  const Round = "Round";
  const Rsqrt = "Rsqrt";
  const ScatterNd = "ScatterNd";
  const SelectV2 = "SelectV2";
  const Selu = "Selu";
  const Slice = "Slice";
  const Sin = "Sin";
  const Sinh = "Sinh";
  const Sign = "Sign";
  const Sigmoid = "Sigmoid";
  const Softplus = "Softplus";
  const Sqrt = "Sqrt";
  const Sum = "Sum";
  const SpaceToBatchND = "SpaceToBatchND";
  const SplitV = "SplitV";
  const Softmax = "Softmax";
  const SquaredDifference = "SquaredDifference";
  const Square = "Square";
  const Sub = "Sub";
  const SparseToDense = "SparseToDense";
  const StridedSlice = "StridedSlice";
  const Tan = "Tan";
  const Tanh = "Tanh";
  const Tile = "Tile";
  const TopK = "TopK";
  const Transpose = "Transpose";
  const Unpack = "Unpack";
  const UnsortedSegmentSum = "UnsortedSegmentSum";
  const ZerosLike = "ZerosLike";
  const Step = "Step";
  const FromPixels = "FromPixels";
  const RotateWithOffset = "RotateWithOffset";
  const _FusedMatMul = "_FusedMatMul";
  const FusedConv2D = "FusedConv2D";
  const FusedDepthwiseConv2D = "FusedDepthwiseConv2D";

  // node_modules/@tensorflow/tfjs-core/dist/kernel_registry.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const kernelRegistry = getGlobal("kernelRegistry", () => new Map());
  const gradRegistry = getGlobal("gradRegistry", () => new Map());
  function getKernel(kernelName, backendName) {
    const key = makeKey(kernelName, backendName);
    return kernelRegistry.get(key);
  }
  function getGradient(kernelName) {
    return gradRegistry.get(kernelName);
  }
  function getKernelsForBackend(backendName) {
    const it = kernelRegistry.entries();
    const result = [];
    while (true) {
      const {done, value} = it.next();
      if (done) {
        break;
      }
      const [key, config2] = value;
      const [backend2] = key.split("_");
      if (backend2 === backendName) {
        result.push(config2);
      }
    }
    return result;
  }
  function registerKernel(config2) {
    const {kernelName, backendName} = config2;
    const key = makeKey(kernelName, backendName);
    if (kernelRegistry.has(key)) {
      console.warn(`The kernel '${kernelName}' for backend '${backendName}' is already registered`);
    }
    kernelRegistry.set(key, config2);
  }
  function registerGradient(config2) {
    const {kernelName} = config2;
    if (gradRegistry.has(kernelName)) {
      if (env().getBool("DEBUG")) {
        console.warn(`Overriding the gradient for '${kernelName}'`);
      }
    }
    gradRegistry.set(kernelName, config2);
  }
  function unregisterKernel(kernelName, backendName) {
    const key = makeKey(kernelName, backendName);
    if (!kernelRegistry.has(key)) {
      throw new Error(`The kernel '${kernelName}' for backend '${backendName}' is not registered`);
    }
    kernelRegistry.delete(key);
  }
  function unregisterGradient(kernelName) {
    if (!gradRegistry.has(kernelName)) {
      throw new Error(`The gradient '${kernelName}' for backend is not registered`);
    }
    gradRegistry.delete(kernelName);
  }
  function makeKey(kernelName, backendName) {
    return `${backendName}_${kernelName}`;
  }

  // node_modules/@tensorflow/tfjs-core/dist/util.js
  const util_exports = {};
  __export(util_exports, {
    arraysEqual: () => arraysEqual,
    assert: () => assert,
    assertNonNegativeIntegerDimensions: () => assertNonNegativeIntegerDimensions,
    assertNonNull: () => assertNonNull,
    assertShapesMatch: () => assertShapesMatch,
    bytesFromStringArray: () => bytesFromStringArray,
    bytesPerElement: () => bytesPerElement,
    checkConversionForErrors: () => checkConversionForErrors,
    clamp: () => clamp,
    computeStrides: () => computeStrides,
    createShuffledIndices: () => createShuffledIndices,
    decodeString: () => decodeString,
    distSquared: () => distSquared,
    encodeString: () => encodeString,
    fetch: () => fetch2,
    flatten: () => flatten,
    getArrayFromDType: () => getArrayFromDType,
    getTypedArrayFromDType: () => getTypedArrayFromDType,
    hasEncodingLoss: () => hasEncodingLoss,
    indexToLoc: () => indexToLoc,
    inferDtype: () => inferDtype,
    inferFromImplicitShape: () => inferFromImplicitShape,
    isBoolean: () => isBoolean,
    isFunction: () => isFunction,
    isInt: () => isInt,
    isNumber: () => isNumber,
    isScalarShape: () => isScalarShape,
    isString: () => isString,
    isTypedArray: () => isTypedArray,
    isValidDtype: () => isValidDtype,
    locToIndex: () => locToIndex,
    makeOnesTypedArray: () => makeOnesTypedArray,
    makeZerosNestedTypedArray: () => makeZerosNestedTypedArray,
    makeZerosTypedArray: () => makeZerosTypedArray,
    nearestDivisor: () => nearestDivisor,
    nearestLargerEven: () => nearestLargerEven,
    now: () => now,
    parseAxisParam: () => parseAxisParam,
    randUniform: () => randUniform,
    repeatedTry: () => repeatedTry,
    rightPad: () => rightPad,
    shuffle: () => shuffle,
    sizeFromShape: () => sizeFromShape,
    sizeToSquarishShape: () => sizeToSquarishShape,
    squeezeShape: () => squeezeShape,
    sum: () => sum,
    tanh: () => tanh,
    toNestedArray: () => toNestedArray,
    toTypedArray: () => toTypedArray
  });
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function shuffle(array) {
    let counter = array.length;
    let temp = 0;
    let index = 0;
    while (counter > 0) {
      index = Math.random() * counter | 0;
      counter--;
      temp = array[counter];
      array[counter] = array[index];
      array[index] = temp;
    }
  }
  function clamp(min4, x, max6) {
    return Math.max(min4, Math.min(x, max6));
  }
  function nearestLargerEven(val) {
    return val % 2 === 0 ? val : val + 1;
  }
  function sum(arr) {
    let sum26 = 0;
    for (let i = 0; i < arr.length; i++) {
      sum26 += arr[i];
    }
    return sum26;
  }
  function randUniform(a, b) {
    const r = Math.random();
    return b * r + (1 - r) * a;
  }
  function distSquared(a, b) {
    let result = 0;
    for (let i = 0; i < a.length; i++) {
      const diff = Number(a[i]) - Number(b[i]);
      result += diff * diff;
    }
    return result;
  }
  function assert(expr, msg) {
    if (!expr) {
      throw new Error(typeof msg === "string" ? msg : msg());
    }
  }
  function assertShapesMatch(shapeA, shapeB, errorMessagePrefix = "") {
    assert(arraysEqual(shapeA, shapeB), () => errorMessagePrefix + ` Shapes ${shapeA} and ${shapeB} must match`);
  }
  function assertNonNull(a) {
    assert(a != null, () => `The input to the tensor constructor must be a non-null value.`);
  }
  function flatten(arr, result = [], skipTypedArray = false) {
    if (result == null) {
      result = [];
    }
    if (Array.isArray(arr) || isTypedArray(arr) && !skipTypedArray) {
      for (let i = 0; i < arr.length; ++i) {
        flatten(arr[i], result, skipTypedArray);
      }
    } else {
      result.push(arr);
    }
    return result;
  }
  function sizeFromShape(shape) {
    if (shape.length === 0) {
      return 1;
    }
    let size = shape[0];
    for (let i = 1; i < shape.length; i++) {
      size *= shape[i];
    }
    return size;
  }
  function isScalarShape(shape) {
    return shape.length === 0;
  }
  function arraysEqual(n1, n2) {
    if (n1 === n2) {
      return true;
    }
    if (n1 == null || n2 == null) {
      return false;
    }
    if (n1.length !== n2.length) {
      return false;
    }
    for (let i = 0; i < n1.length; i++) {
      if (n1[i] !== n2[i]) {
        return false;
      }
    }
    return true;
  }
  function isInt(a) {
    return a % 1 === 0;
  }
  function tanh(x) {
    if (Math.tanh != null) {
      return Math.tanh(x);
    }
    if (x === Infinity) {
      return 1;
    } else if (x === -Infinity) {
      return -1;
    } else {
      const e2x = Math.exp(2 * x);
      return (e2x - 1) / (e2x + 1);
    }
  }
  function sizeToSquarishShape(size) {
    const width = Math.ceil(Math.sqrt(size));
    return [width, Math.ceil(size / width)];
  }
  function createShuffledIndices(n) {
    const shuffledIndices = new Uint32Array(n);
    for (let i = 0; i < n; ++i) {
      shuffledIndices[i] = i;
    }
    shuffle(shuffledIndices);
    return shuffledIndices;
  }
  function rightPad(a, size) {
    if (size <= a.length) {
      return a;
    }
    return a + " ".repeat(size - a.length);
  }
  function repeatedTry(checkFn, delayFn = (counter) => 0, maxCounter) {
    return new Promise((resolve, reject) => {
      let tryCount = 0;
      const tryFn = () => {
        if (checkFn()) {
          resolve();
          return;
        }
        tryCount++;
        const nextBackoff = delayFn(tryCount);
        if (maxCounter != null && tryCount >= maxCounter) {
          reject();
          return;
        }
        setTimeout(tryFn, nextBackoff);
      };
      tryFn();
    });
  }
  function inferFromImplicitShape(shape, size) {
    let shapeProd = 1;
    let implicitIdx = -1;
    for (let i = 0; i < shape.length; ++i) {
      if (shape[i] >= 0) {
        shapeProd *= shape[i];
      } else if (shape[i] === -1) {
        if (implicitIdx !== -1) {
          throw Error(`Shapes can only have 1 implicit size. Found -1 at dim ${implicitIdx} and dim ${i}`);
        }
        implicitIdx = i;
      } else if (shape[i] < 0) {
        throw Error(`Shapes can not be < 0. Found ${shape[i]} at dim ${i}`);
      }
    }
    if (implicitIdx === -1) {
      if (size > 0 && size !== shapeProd) {
        throw Error(`Size(${size}) must match the product of shape ${shape}`);
      }
      return shape;
    }
    if (shapeProd === 0) {
      throw Error(`Cannot infer the missing size in [${shape}] when there are 0 elements`);
    }
    if (size % shapeProd !== 0) {
      throw Error(`The implicit shape can't be a fractional number. Got ${size} / ${shapeProd}`);
    }
    const newShape = shape.slice();
    newShape[implicitIdx] = size / shapeProd;
    return newShape;
  }
  function parseAxisParam(axis, shape) {
    const rank = shape.length;
    axis = axis == null ? shape.map((s, i) => i) : [].concat(axis);
    assert(axis.every((ax) => ax >= -rank && ax < rank), () => `All values in axis param must be in range [-${rank}, ${rank}) but got axis ${axis}`);
    assert(axis.every((ax) => isInt(ax)), () => `All values in axis param must be integers but got axis ${axis}`);
    return axis.map((a) => a < 0 ? rank + a : a);
  }
  function squeezeShape(shape, axis) {
    const newShape = [];
    const keptDims = [];
    const isEmptyArray = axis != null && Array.isArray(axis) && axis.length === 0;
    const axes = axis == null || isEmptyArray ? null : parseAxisParam(axis, shape).sort();
    let j = 0;
    for (let i = 0; i < shape.length; ++i) {
      if (axes != null) {
        if (axes[j] === i && shape[i] !== 1) {
          throw new Error(`Can't squeeze axis ${i} since its dim '${shape[i]}' is not 1`);
        }
        if ((axes[j] == null || axes[j] > i) && shape[i] === 1) {
          newShape.push(shape[i]);
          keptDims.push(i);
        }
        if (axes[j] <= i) {
          j++;
        }
      }
      if (shape[i] !== 1) {
        newShape.push(shape[i]);
        keptDims.push(i);
      }
    }
    return {newShape, keptDims};
  }
  function getTypedArrayFromDType(dtype, size) {
    let values = null;
    if (dtype == null || dtype === "float32") {
      values = new Float32Array(size);
    } else if (dtype === "int32") {
      values = new Int32Array(size);
    } else if (dtype === "bool") {
      values = new Uint8Array(size);
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
    return values;
  }
  function getArrayFromDType(dtype, size) {
    let values = null;
    if (dtype == null || dtype === "float32") {
      values = new Float32Array(size);
    } else if (dtype === "int32") {
      values = new Int32Array(size);
    } else if (dtype === "bool") {
      values = new Uint8Array(size);
    } else if (dtype === "string") {
      values = new Array(size);
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
    return values;
  }
  function checkConversionForErrors(vals, dtype) {
    for (let i = 0; i < vals.length; i++) {
      const num = vals[i];
      if (isNaN(num) || !isFinite(num)) {
        throw Error(`A tensor of type ${dtype} being uploaded contains ${num}.`);
      }
    }
  }
  function isValidDtype(dtype) {
    return dtype === "bool" || dtype === "complex64" || dtype === "float32" || dtype === "int32" || dtype === "string";
  }
  function hasEncodingLoss(oldType, newType) {
    if (newType === "complex64") {
      return false;
    }
    if (newType === "float32" && oldType !== "complex64") {
      return false;
    }
    if (newType === "int32" && oldType !== "float32" && oldType !== "complex64") {
      return false;
    }
    if (newType === "bool" && oldType === "bool") {
      return false;
    }
    return true;
  }
  function isTypedArray(a) {
    return a instanceof Float32Array || a instanceof Int32Array || a instanceof Uint8Array;
  }
  function bytesPerElement(dtype) {
    if (dtype === "float32" || dtype === "int32") {
      return 4;
    } else if (dtype === "complex64") {
      return 8;
    } else if (dtype === "bool") {
      return 1;
    } else {
      throw new Error(`Unknown dtype ${dtype}`);
    }
  }
  function bytesFromStringArray(arr) {
    if (arr == null) {
      return 0;
    }
    let bytes = 0;
    arr.forEach((x) => bytes += x.length);
    return bytes;
  }
  function isString(value) {
    return typeof value === "string" || value instanceof String;
  }
  function isBoolean(value) {
    return typeof value === "boolean";
  }
  function isNumber(value) {
    return typeof value === "number";
  }
  function inferDtype(values) {
    if (Array.isArray(values)) {
      return inferDtype(values[0]);
    }
    if (values instanceof Float32Array) {
      return "float32";
    } else if (values instanceof Int32Array || values instanceof Uint8Array) {
      return "int32";
    } else if (isNumber(values)) {
      return "float32";
    } else if (isString(values)) {
      return "string";
    } else if (isBoolean(values)) {
      return "bool";
    }
    return "float32";
  }
  function isFunction(f) {
    return !!(f && f.constructor && f.call && f.apply);
  }
  function nearestDivisor(size, start) {
    for (let i = start; i < size; ++i) {
      if (size % i === 0) {
        return i;
      }
    }
    return size;
  }
  function computeStrides(shape) {
    const rank = shape.length;
    if (rank < 2) {
      return [];
    }
    const strides = new Array(rank - 1);
    strides[rank - 2] = shape[rank - 1];
    for (let i = rank - 3; i >= 0; --i) {
      strides[i] = strides[i + 1] * shape[i + 1];
    }
    return strides;
  }
  function toTypedArray(a, dtype) {
    if (dtype === "string") {
      throw new Error("Cannot convert a string[] to a TypedArray");
    }
    if (Array.isArray(a)) {
      a = flatten(a);
    }
    if (env().getBool("DEBUG")) {
      checkConversionForErrors(a, dtype);
    }
    if (noConversionNeeded(a, dtype)) {
      return a;
    }
    if (dtype == null || dtype === "float32" || dtype === "complex64") {
      return new Float32Array(a);
    } else if (dtype === "int32") {
      return new Int32Array(a);
    } else if (dtype === "bool") {
      const bool = new Uint8Array(a.length);
      for (let i = 0; i < bool.length; ++i) {
        if (Math.round(a[i]) !== 0) {
          bool[i] = 1;
        }
      }
      return bool;
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
  }
  function createNestedArray(offset, shape, a) {
    const ret = new Array();
    if (shape.length === 1) {
      const d = shape[0];
      for (let i = 0; i < d; i++) {
        ret[i] = a[offset + i];
      }
    } else {
      const d = shape[0];
      const rest = shape.slice(1);
      const len = rest.reduce((acc, c) => acc * c);
      for (let i = 0; i < d; i++) {
        ret[i] = createNestedArray(offset + i * len, rest, a);
      }
    }
    return ret;
  }
  function toNestedArray(shape, a) {
    if (shape.length === 0) {
      return a[0];
    }
    const size = shape.reduce((acc, c) => acc * c);
    if (size === 0) {
      return [];
    }
    if (size !== a.length) {
      throw new Error(`[${shape}] does not match the input size ${a.length}.`);
    }
    return createNestedArray(0, shape, a);
  }
  function noConversionNeeded(a, dtype) {
    return a instanceof Float32Array && dtype === "float32" || a instanceof Int32Array && dtype === "int32" || a instanceof Uint8Array && dtype === "bool";
  }
  function makeOnesTypedArray(size, dtype) {
    const array = makeZerosTypedArray(size, dtype);
    for (let i = 0; i < array.length; i++) {
      array[i] = 1;
    }
    return array;
  }
  function makeZerosTypedArray(size, dtype) {
    if (dtype == null || dtype === "float32" || dtype === "complex64") {
      return new Float32Array(size);
    } else if (dtype === "int32") {
      return new Int32Array(size);
    } else if (dtype === "bool") {
      return new Uint8Array(size);
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
  }
  function makeZerosNestedTypedArray(shape, dtype) {
    const size = shape.reduce((prev, curr) => prev * curr, 1);
    if (dtype == null || dtype === "float32") {
      return toNestedArray(shape, new Float32Array(size));
    } else if (dtype === "int32") {
      return toNestedArray(shape, new Int32Array(size));
    } else if (dtype === "bool") {
      return toNestedArray(shape, new Uint8Array(size));
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
  }
  function now() {
    return env().platform.now();
  }
  function assertNonNegativeIntegerDimensions(shape) {
    shape.forEach((dimSize) => {
      assert(Number.isInteger(dimSize) && dimSize >= 0, () => `Tensor must have a shape comprised of positive integers but got shape [${shape}].`);
    });
  }
  function fetch2(path, requestInits) {
    return env().platform.fetch(path, requestInits);
  }
  function encodeString(s, encoding = "utf-8") {
    encoding = encoding || "utf-8";
    return env().platform.encode(s, encoding);
  }
  function decodeString(bytes, encoding = "utf-8") {
    encoding = encoding || "utf-8";
    return env().platform.decode(bytes, encoding);
  }
  function locToIndex(locs, rank, strides) {
    if (rank === 0) {
      return 0;
    } else if (rank === 1) {
      return locs[0];
    }
    let index = locs[locs.length - 1];
    for (let i = 0; i < locs.length - 1; ++i) {
      index += strides[i] * locs[i];
    }
    return index;
  }
  function indexToLoc(index, rank, strides) {
    if (rank === 0) {
      return [];
    } else if (rank === 1) {
      return [index];
    }
    const locs = new Array(rank);
    for (let i = 0; i < locs.length - 1; ++i) {
      locs[i] = Math.floor(index / strides[i]);
      index -= locs[i] * strides[i];
    }
    locs[locs.length - 1] = index;
    return locs;
  }

  // node_modules/@tensorflow/tfjs-core/dist/profiler.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class Profiler {
    constructor(backendTimer, logger) {
      this.backendTimer = backendTimer;
      this.logger = logger;
      if (logger == null) {
        this.logger = new Logger();
      }
    }
    profileKernel(kernelName, inputs, f) {
      let outputs;
      const holdResultWrapperFn = () => {
        outputs = f();
      };
      const timer = this.backendTimer.time(holdResultWrapperFn);
      for (let i = 0; i < outputs.length; i++) {
        const output = outputs[i];
        output.data().then((tensorVals) => {
          checkComputationForErrors(tensorVals, output.dtype, kernelName);
        });
      }
      const kernelProfile = {
        kernelName,
        outputs,
        inputs,
        timeMs: timer.then((timing) => timing.kernelMs),
        extraInfo: timer.then((timing) => timing.getExtraProfileInfo != null ? timing.getExtraProfileInfo() : "")
      };
      return kernelProfile;
    }
    logKernelProfile(kernelProfile) {
      const {kernelName, outputs, timeMs, inputs, extraInfo} = kernelProfile;
      outputs.forEach((result) => {
        Promise.all([result.data(), timeMs, extraInfo]).then((valueContainer) => {
          this.logger.logKernelProfile(kernelName, result, valueContainer[0], valueContainer[1], inputs, valueContainer[2]);
        });
      });
    }
  }
  function checkComputationForErrors(vals, dtype, kernelName) {
    if (dtype !== "float32") {
      return false;
    }
    for (let i = 0; i < vals.length; i++) {
      const num = vals[i];
      if (isNaN(num) || !isFinite(num)) {
        console.warn(`Found ${num} in the result of '${kernelName}'`);
        return true;
      }
    }
    return false;
  }
  class Logger {
    logKernelProfile(name, result, vals, timeMs, inputs, extraInfo) {
      const time2 = typeof timeMs === "number" ? rightPad(`${timeMs}ms`, 9) : timeMs["error"];
      const paddedName = rightPad(name, 25);
      const rank = result.rank;
      const size = result.size;
      const shape = rightPad(result.shape.toString(), 14);
      let inputShapesDescription = "";
      for (const name2 in inputs) {
        const input = inputs[name2];
        if (input != null) {
          const inputShape = input.shape || result.shape;
          const inputRank = inputShape.length;
          inputShapesDescription += `${name2}: ${inputRank}D ${inputRank > 0 ? inputShape : ""} `;
        }
      }
      console.log(`%c${paddedName}	%c${time2}	%c${rank}D ${shape}	%c${size}	%c${inputShapesDescription}	%c${extraInfo}`, "font-weight:bold", "color:red", "color:blue", "color: orange", "color: green", "color: steelblue");
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/tape.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getFilteredNodesXToY(tape2, xs, y) {
    const tensorsFromX = {};
    const nodesFromX = {};
    for (let i = 0; i < xs.length; i++) {
      tensorsFromX[xs[i].id] = true;
    }
    for (let i = 0; i < tape2.length; i++) {
      const node = tape2[i];
      const nodeInputs = node.inputs;
      for (const inputName in nodeInputs) {
        const input = nodeInputs[inputName];
        let anyInputFromX = false;
        for (let j = 0; j < xs.length; j++) {
          if (tensorsFromX[input.id]) {
            node.outputs.forEach((output) => tensorsFromX[output.id] = true);
            anyInputFromX = true;
            nodesFromX[node.id] = true;
            break;
          }
        }
        if (anyInputFromX) {
          break;
        }
      }
    }
    const tensorsLeadToY = {};
    tensorsLeadToY[y.id] = true;
    const nodesToY = {};
    for (let i = tape2.length - 1; i >= 0; i--) {
      const node = tape2[i];
      const nodeInputs = node.inputs;
      for (let j = 0; j < node.outputs.length; j++) {
        if (tensorsLeadToY[node.outputs[j].id]) {
          for (const inputName in nodeInputs) {
            tensorsLeadToY[nodeInputs[inputName].id] = true;
            nodesToY[node.id] = true;
          }
          break;
        }
      }
    }
    const filteredTape = [];
    for (let i = 0; i < tape2.length; i++) {
      const node = tape2[i];
      if (nodesFromX[node.id] && nodesToY[node.id]) {
        const prunedInputs = {};
        for (const inputName in node.inputs) {
          const nodeInput = node.inputs[inputName];
          if (tensorsFromX[nodeInput.id]) {
            prunedInputs[inputName] = nodeInput;
          }
        }
        const prunedNode = Object.assign({}, node);
        prunedNode.inputs = prunedInputs;
        prunedNode.outputs = node.outputs;
        filteredTape.push(prunedNode);
      }
    }
    return filteredTape;
  }
  function backpropagateGradients(tensorAccumulatedGradientMap, filteredTape, tidy2, add29) {
    for (let i = filteredTape.length - 1; i >= 0; i--) {
      const node = filteredTape[i];
      const dys = [];
      node.outputs.forEach((o) => {
        const gradTensor = tensorAccumulatedGradientMap[o.id];
        if (gradTensor != null) {
          dys.push(gradTensor);
        } else {
          dys.push(null);
        }
      });
      if (node.gradient == null) {
        throw new Error(`Cannot compute gradient: gradient function not found for ${node.kernelName}.`);
      }
      const inputGradients = node.gradient(dys);
      for (const inputName in node.inputs) {
        if (!(inputName in inputGradients)) {
          throw new Error(`Cannot backprop through input ${inputName}. Available gradients found: ${Object.keys(inputGradients)}.`);
        }
        const dx = tidy2(() => inputGradients[inputName]());
        if (dx.dtype !== "float32") {
          throw new Error(`Error in gradient for op ${node.kernelName}. The gradient of input ${inputName} must have 'float32' dtype, but has '${dx.dtype}'`);
        }
        const x = node.inputs[inputName];
        if (!arraysEqual(dx.shape, x.shape)) {
          throw new Error(`Error in gradient for op ${node.kernelName}. The gradient of input '${inputName}' has shape '${dx.shape}', which does not match the shape of the input '${x.shape}'`);
        }
        if (tensorAccumulatedGradientMap[x.id] == null) {
          tensorAccumulatedGradientMap[x.id] = dx;
        } else {
          const curGradient = tensorAccumulatedGradientMap[x.id];
          tensorAccumulatedGradientMap[x.id] = add29(curGradient, dx);
          curGradient.dispose();
        }
      }
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/tensor_format.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const FORMAT_LIMIT_NUM_VALS = 20;
  const FORMAT_NUM_FIRST_LAST_VALS = 3;
  const FORMAT_NUM_SIG_DIGITS = 7;
  function tensorToString(vals, shape, dtype, verbose) {
    const strides = computeStrides(shape);
    const padPerCol = computeMaxSizePerColumn(vals, shape, dtype, strides);
    const rank = shape.length;
    const valsLines = subTensorToString(vals, shape, dtype, strides, padPerCol);
    const lines = ["Tensor"];
    if (verbose) {
      lines.push(`  dtype: ${dtype}`);
      lines.push(`  rank: ${rank}`);
      lines.push(`  shape: [${shape}]`);
      lines.push(`  values:`);
    }
    lines.push(valsLines.map((l) => "    " + l).join("\n"));
    return lines.join("\n");
  }
  function computeMaxSizePerColumn(vals, shape, dtype, strides) {
    const n = sizeFromShape(shape);
    const numCols = strides[strides.length - 1];
    const padPerCol = new Array(numCols).fill(0);
    const rank = shape.length;
    const valuesOrTuples = dtype === "complex64" ? createComplexTuples(vals) : vals;
    if (rank > 1) {
      for (let row = 0; row < n / numCols; row++) {
        const offset = row * numCols;
        for (let j = 0; j < numCols; j++) {
          padPerCol[j] = Math.max(padPerCol[j], valToString(valuesOrTuples[offset + j], 0, dtype).length);
        }
      }
    }
    return padPerCol;
  }
  function valToString(val, pad8, dtype) {
    let valStr;
    if (Array.isArray(val)) {
      valStr = `${parseFloat(val[0].toFixed(FORMAT_NUM_SIG_DIGITS))} + ${parseFloat(val[1].toFixed(FORMAT_NUM_SIG_DIGITS))}j`;
    } else if (isString(val)) {
      valStr = `'${val}'`;
    } else if (dtype === "bool") {
      valStr = boolNumToString(val);
    } else {
      valStr = parseFloat(val.toFixed(FORMAT_NUM_SIG_DIGITS)).toString();
    }
    return rightPad(valStr, pad8);
  }
  function boolNumToString(v) {
    return v === 0 ? "false" : "true";
  }
  function subTensorToString(vals, shape, dtype, strides, padPerCol, isLast = true) {
    const storagePerElement = dtype === "complex64" ? 2 : 1;
    const size = shape[0];
    const rank = shape.length;
    if (rank === 0) {
      if (dtype === "complex64") {
        const complexTuple = createComplexTuples(vals);
        return [valToString(complexTuple[0], 0, dtype)];
      }
      if (dtype === "bool") {
        return [boolNumToString(vals[0])];
      }
      return [vals[0].toString()];
    }
    if (rank === 1) {
      if (size > FORMAT_LIMIT_NUM_VALS) {
        const firstValsSize = FORMAT_NUM_FIRST_LAST_VALS * storagePerElement;
        let firstVals = Array.from(vals.slice(0, firstValsSize));
        let lastVals = Array.from(vals.slice((size - FORMAT_NUM_FIRST_LAST_VALS) * storagePerElement, size * storagePerElement));
        if (dtype === "complex64") {
          firstVals = createComplexTuples(firstVals);
          lastVals = createComplexTuples(lastVals);
        }
        return [
          "[" + firstVals.map((x, i) => valToString(x, padPerCol[i], dtype)).join(", ") + ", ..., " + lastVals.map((x, i) => valToString(x, padPerCol[size - FORMAT_NUM_FIRST_LAST_VALS + i], dtype)).join(", ") + "]"
        ];
      }
      const displayVals = dtype === "complex64" ? createComplexTuples(vals) : Array.from(vals);
      return [
        "[" + displayVals.map((x, i) => valToString(x, padPerCol[i], dtype)).join(", ") + "]"
      ];
    }
    const subshape = shape.slice(1);
    const substrides = strides.slice(1);
    const stride = strides[0] * storagePerElement;
    const lines = [];
    if (size > FORMAT_LIMIT_NUM_VALS) {
      for (let i = 0; i < FORMAT_NUM_FIRST_LAST_VALS; i++) {
        const start = i * stride;
        const end = start + stride;
        lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, false));
      }
      lines.push("...");
      for (let i = size - FORMAT_NUM_FIRST_LAST_VALS; i < size; i++) {
        const start = i * stride;
        const end = start + stride;
        lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, i === size - 1));
      }
    } else {
      for (let i = 0; i < size; i++) {
        const start = i * stride;
        const end = start + stride;
        lines.push(...subTensorToString(vals.slice(start, end), subshape, dtype, substrides, padPerCol, i === size - 1));
      }
    }
    const sep = rank === 2 ? "," : "";
    lines[0] = "[" + lines[0] + sep;
    for (let i = 1; i < lines.length - 1; i++) {
      lines[i] = " " + lines[i] + sep;
    }
    let newLineSep = ",\n";
    for (let i = 2; i < rank; i++) {
      newLineSep += "\n";
    }
    lines[lines.length - 1] = " " + lines[lines.length - 1] + "]" + (isLast ? "" : newLineSep);
    return lines;
  }
  function createComplexTuples(vals) {
    const complexTuples = [];
    for (let i = 0; i < vals.length; i += 2) {
      complexTuples.push([vals[i], vals[i + 1]]);
    }
    return complexTuples;
  }

  // node_modules/@tensorflow/tfjs-core/dist/tensor.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class TensorBuffer {
    constructor(shape, dtype, values) {
      this.dtype = dtype;
      this.shape = shape.slice();
      this.size = sizeFromShape(shape);
      if (values != null) {
        const n = values.length;
        assert(n === this.size, () => `Length of values '${n}' does not match the size inferred by the shape '${this.size}'.`);
      }
      if (dtype === "complex64") {
        throw new Error(`complex64 dtype TensorBuffers are not supported. Please create a TensorBuffer for the real and imaginary parts separately and call tf.complex(real, imag).`);
      }
      this.values = values || getArrayFromDType(dtype, this.size);
      this.strides = computeStrides(shape);
    }
    set(value, ...locs) {
      if (locs.length === 0) {
        locs = [0];
      }
      assert(locs.length === this.rank, () => `The number of provided coordinates (${locs.length}) must match the rank (${this.rank})`);
      const index = this.locToIndex(locs);
      this.values[index] = value;
    }
    get(...locs) {
      if (locs.length === 0) {
        locs = [0];
      }
      let i = 0;
      for (const loc of locs) {
        if (loc < 0 || loc >= this.shape[i]) {
          const msg = `Requested out of range element at ${locs}.   Buffer shape=${this.shape}`;
          throw new Error(msg);
        }
        i++;
      }
      let index = locs[locs.length - 1];
      for (let i2 = 0; i2 < locs.length - 1; ++i2) {
        index += this.strides[i2] * locs[i2];
      }
      return this.values[index];
    }
    locToIndex(locs) {
      if (this.rank === 0) {
        return 0;
      } else if (this.rank === 1) {
        return locs[0];
      }
      let index = locs[locs.length - 1];
      for (let i = 0; i < locs.length - 1; ++i) {
        index += this.strides[i] * locs[i];
      }
      return index;
    }
    indexToLoc(index) {
      if (this.rank === 0) {
        return [];
      } else if (this.rank === 1) {
        return [index];
      }
      const locs = new Array(this.shape.length);
      for (let i = 0; i < locs.length - 1; ++i) {
        locs[i] = Math.floor(index / this.strides[i]);
        index -= locs[i] * this.strides[i];
      }
      locs[locs.length - 1] = index;
      return locs;
    }
    get rank() {
      return this.shape.length;
    }
    toTensor() {
      return trackerFn().makeTensor(this.values, this.shape, this.dtype);
    }
  }
  let trackerFn = null;
  let opHandler = null;
  let deprecationWarningFn = null;
  function setTensorTracker(fn) {
    trackerFn = fn;
  }
  function setOpHandler(handler) {
    opHandler = handler;
  }
  function setDeprecationWarningFn(fn) {
    deprecationWarningFn = fn;
  }
  class Tensor {
    constructor(shape, dtype, dataId, id) {
      this.kept = false;
      this.isDisposedInternal = false;
      this.shape = shape.slice();
      this.dtype = dtype || "float32";
      this.size = sizeFromShape(shape);
      this.strides = computeStrides(shape);
      this.dataId = dataId;
      this.id = id;
      this.rankType = this.rank < 5 ? this.rank.toString() : "higher";
    }
    get rank() {
      return this.shape.length;
    }
    async buffer() {
      const vals = await this.data();
      return opHandler.buffer(this.shape, this.dtype, vals);
    }
    bufferSync() {
      return opHandler.buffer(this.shape, this.dtype, this.dataSync());
    }
    async array() {
      const vals = await this.data();
      return toNestedArray(this.shape, vals);
    }
    arraySync() {
      return toNestedArray(this.shape, this.dataSync());
    }
    async data() {
      this.throwIfDisposed();
      const data = trackerFn().read(this.dataId);
      if (this.dtype === "string") {
        const bytes = await data;
        try {
          return bytes.map((b) => decodeString(b));
        } catch (_a) {
          throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().");
        }
      }
      return data;
    }
    dataSync() {
      this.throwIfDisposed();
      const data = trackerFn().readSync(this.dataId);
      if (this.dtype === "string") {
        try {
          return data.map((b) => decodeString(b));
        } catch (_a) {
          throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().");
        }
      }
      return data;
    }
    async bytes() {
      this.throwIfDisposed();
      const data = await trackerFn().read(this.dataId);
      if (this.dtype === "string") {
        return data;
      } else {
        return new Uint8Array(data.buffer);
      }
    }
    dispose() {
      if (this.isDisposed) {
        return;
      }
      trackerFn().disposeTensor(this);
      this.isDisposedInternal = true;
    }
    get isDisposed() {
      return this.isDisposedInternal;
    }
    throwIfDisposed() {
      if (this.isDisposed) {
        throw new Error(`Tensor is disposed.`);
      }
    }
    print(verbose = false) {
      return opHandler.print(this, verbose);
    }
    clone() {
      this.throwIfDisposed();
      return opHandler.clone(this);
    }
    toString(verbose = false) {
      const vals = this.dataSync();
      return tensorToString(vals, this.shape, this.dtype, verbose);
    }
    cast(dtype) {
      this.throwIfDisposed();
      return opHandler.cast(this, dtype);
    }
    variable(trainable = true, name, dtype) {
      this.throwIfDisposed();
      return trackerFn().makeVariable(this, trainable, name, dtype);
    }
  }
  Object.defineProperty(Tensor, Symbol.hasInstance, {
    value: (instance) => {
      return !!instance && instance.data != null && instance.dataSync != null && instance.throwIfDisposed != null;
    }
  });
  class Variable extends Tensor {
    constructor(initialValue, trainable, name, tensorId) {
      super(initialValue.shape, initialValue.dtype, initialValue.dataId, tensorId);
      this.trainable = trainable;
      this.name = name;
    }
    assign(newValue) {
      if (newValue.dtype !== this.dtype) {
        throw new Error(`dtype of the new value (${newValue.dtype}) and previous value (${this.dtype}) must match`);
      }
      if (!arraysEqual(newValue.shape, this.shape)) {
        throw new Error(`shape of the new value (${newValue.shape}) and previous value (${this.shape}) must match`);
      }
      trackerFn().disposeTensor(this);
      this.dataId = newValue.dataId;
      trackerFn().incRef(this, null);
    }
    dispose() {
      trackerFn().disposeVariable(this);
      this.isDisposedInternal = true;
    }
  }
  Object.defineProperty(Variable, Symbol.hasInstance, {
    value: (instance) => {
      return instance instanceof Tensor && instance.assign != null && instance.assign instanceof Function;
    }
  });

  // node_modules/@tensorflow/tfjs-core/dist/types.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  var Rank;
  (function(Rank2) {
    Rank2["R0"] = "R0";
    Rank2["R1"] = "R1";
    Rank2["R2"] = "R2";
    Rank2["R3"] = "R3";
    Rank2["R4"] = "R4";
    Rank2["R5"] = "R5";
    Rank2["R6"] = "R6";
  })(Rank || (Rank = {}));
  var UpcastInt32AndMap;
  (function(UpcastInt32AndMap2) {
    UpcastInt32AndMap2["float32"] = "float32";
    UpcastInt32AndMap2["int32"] = "int32";
    UpcastInt32AndMap2["bool"] = "int32";
    UpcastInt32AndMap2["complex64"] = "complex64";
  })(UpcastInt32AndMap || (UpcastInt32AndMap = {}));
  var UpcastBoolAndMap;
  (function(UpcastBoolAndMap2) {
    UpcastBoolAndMap2["float32"] = "float32";
    UpcastBoolAndMap2["int32"] = "int32";
    UpcastBoolAndMap2["bool"] = "bool";
    UpcastBoolAndMap2["complex64"] = "complex64";
  })(UpcastBoolAndMap || (UpcastBoolAndMap = {}));
  var UpcastFloat32AndMap;
  (function(UpcastFloat32AndMap2) {
    UpcastFloat32AndMap2["float32"] = "float32";
    UpcastFloat32AndMap2["int32"] = "float32";
    UpcastFloat32AndMap2["bool"] = "float32";
    UpcastFloat32AndMap2["complex64"] = "complex64";
  })(UpcastFloat32AndMap || (UpcastFloat32AndMap = {}));
  var UpcastComplex64AndMap;
  (function(UpcastComplex64AndMap2) {
    UpcastComplex64AndMap2["float32"] = "complex64";
    UpcastComplex64AndMap2["int32"] = "complex64";
    UpcastComplex64AndMap2["bool"] = "complex64";
    UpcastComplex64AndMap2["complex64"] = "complex64";
  })(UpcastComplex64AndMap || (UpcastComplex64AndMap = {}));
  const upcastTypeMap = {
    float32: UpcastFloat32AndMap,
    int32: UpcastInt32AndMap,
    bool: UpcastBoolAndMap,
    complex64: UpcastComplex64AndMap
  };
  function upcastType(typeA, typeB) {
    if (typeA === "string" || typeB === "string") {
      if (typeA === "string" && typeB === "string") {
        return "string";
      }
      throw new Error(`Can not upcast ${typeA} with ${typeB}`);
    }
    return upcastTypeMap[typeA][typeB];
  }
  function sumOutType(type) {
    return upcastType(type, "int32");
  }

  // node_modules/@tensorflow/tfjs-core/dist/tensor_util.js
  const tensor_util_exports = {};
  __export(tensor_util_exports, {
    assertTypesMatch: () => assertTypesMatch,
    getTensorsInContainer: () => getTensorsInContainer,
    isTensorInList: () => isTensorInList,
    makeTypesMatch: () => makeTypesMatch
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function makeTypesMatch(a, b) {
    if (a.dtype === b.dtype) {
      return [a, b];
    }
    const dtype = upcastType(a.dtype, b.dtype);
    return [a.cast(dtype), b.cast(dtype)];
  }
  function assertTypesMatch(a, b) {
    assert(a.dtype === b.dtype, () => `The dtypes of the first(${a.dtype}) and second(${b.dtype}) input must match`);
  }
  function isTensorInList(tensor17, tensorList) {
    return tensorList.some((x) => x.id === tensor17.id);
  }
  function getTensorsInContainer(result) {
    const list = [];
    const seen = new Set();
    walkTensorContainer(result, list, seen);
    return list;
  }
  function walkTensorContainer(container, list, seen) {
    if (container == null) {
      return;
    }
    if (container instanceof Tensor) {
      list.push(container);
      return;
    }
    if (!isIterable(container)) {
      return;
    }
    const iterable = container;
    for (const k in iterable) {
      const val = iterable[k];
      if (!seen.has(val)) {
        seen.add(val);
        walkTensorContainer(val, list, seen);
      }
    }
  }
  function isIterable(obj) {
    return Array.isArray(obj) || typeof obj === "object";
  }

  // node_modules/@tensorflow/tfjs-core/dist/engine.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class EngineState {
    constructor() {
      this.registeredVariables = {};
      this.nextTapeNodeId = 0;
      this.numBytes = 0;
      this.numTensors = 0;
      this.numStringTensors = 0;
      this.numDataBuffers = 0;
      this.gradientDepth = 0;
      this.kernelDepth = 0;
      this.scopeStack = [];
      this.numDataMovesStack = [];
      this.nextScopeId = 0;
      this.tensorInfo = new WeakMap();
      this.profiling = false;
      this.activeProfile = {newBytes: 0, newTensors: 0, peakBytes: 0, kernels: [], result: null};
    }
    dispose() {
      for (const variableName in this.registeredVariables) {
        this.registeredVariables[variableName].dispose();
      }
    }
  }
  class Engine {
    constructor(ENV3) {
      this.ENV = ENV3;
      this.registry = {};
      this.registryFactory = {};
      this.pendingBackendInitId = 0;
      this.state = new EngineState();
    }
    async ready() {
      if (this.pendingBackendInit != null) {
        return this.pendingBackendInit.then(() => {
        });
      }
      if (this.backendInstance != null) {
        return;
      }
      const sortedBackends = this.getSortedBackends();
      for (let i = 0; i < sortedBackends.length; i++) {
        const backendName = sortedBackends[i];
        const success = await this.initializeBackend(backendName).success;
        if (success) {
          await this.setBackend(backendName);
          return;
        }
      }
      throw new Error(`Could not initialize any backends, all backend initializations failed.`);
    }
    get backend() {
      if (this.pendingBackendInit != null) {
        throw new Error(`Backend '${this.backendName}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
      }
      if (this.backendInstance == null) {
        const {name, asyncInit} = this.initializeBackendsAndReturnBest();
        if (asyncInit) {
          throw new Error(`The highest priority backend '${name}' has not yet been initialized. Make sure to await tf.ready() or await tf.setBackend() before calling other methods`);
        }
        this.setBackend(name);
      }
      return this.backendInstance;
    }
    backendNames() {
      return Object.keys(this.registryFactory);
    }
    findBackend(backendName) {
      if (!(backendName in this.registry)) {
        if (backendName in this.registryFactory) {
          const {asyncInit} = this.initializeBackend(backendName);
          if (asyncInit) {
            return null;
          }
        } else {
          return null;
        }
      }
      return this.registry[backendName];
    }
    findBackendFactory(backendName) {
      if (!(backendName in this.registryFactory)) {
        return null;
      }
      return this.registryFactory[backendName].factory;
    }
    registerBackend(backendName, factory, priority = 1) {
      if (backendName in this.registryFactory) {
        console.warn(`${backendName} backend was already registered. Reusing existing backend factory.`);
        return false;
      }
      this.registryFactory[backendName] = {factory, priority};
      return true;
    }
    async setBackend(backendName) {
      if (this.registryFactory[backendName] == null) {
        throw new Error(`Backend name '${backendName}' not found in registry`);
      }
      this.backendName = backendName;
      if (this.registry[backendName] == null) {
        this.backendInstance = null;
        const {success, asyncInit} = this.initializeBackend(backendName);
        const result = asyncInit ? await success : success;
        if (!result) {
          return false;
        }
      }
      this.backendInstance = this.registry[backendName];
      this.setupRegisteredKernels();
      this.profiler = new Profiler(this.backendInstance);
      return true;
    }
    setupRegisteredKernels() {
      const kernels = getKernelsForBackend(this.backendName);
      kernels.forEach((kernel) => {
        if (kernel.setupFunc != null) {
          kernel.setupFunc(this.backendInstance);
        }
      });
    }
    disposeRegisteredKernels(backendName) {
      const kernels = getKernelsForBackend(backendName);
      kernels.forEach((kernel) => {
        if (kernel.disposeFunc != null) {
          kernel.disposeFunc(this.registry[backendName]);
        }
      });
    }
    initializeBackend(backendName) {
      const registryFactoryEntry = this.registryFactory[backendName];
      if (registryFactoryEntry == null) {
        throw new Error(`Cannot initialize backend ${backendName}, no registration found.`);
      }
      try {
        const backend2 = registryFactoryEntry.factory();
        if (Promise.resolve(backend2) === backend2) {
          const promiseId = ++this.pendingBackendInitId;
          const success = backend2.then((backendInstance) => {
            if (promiseId < this.pendingBackendInitId) {
              return false;
            }
            this.registry[backendName] = backendInstance;
            this.pendingBackendInit = null;
            return true;
          }).catch((err) => {
            if (promiseId < this.pendingBackendInitId) {
              return false;
            }
            this.pendingBackendInit = null;
            console.warn(`Initialization of backend ${backendName} failed`);
            console.warn(err.stack || err.message);
            return false;
          });
          this.pendingBackendInit = success;
          return {success, asyncInit: true};
        } else {
          this.registry[backendName] = backend2;
          return {success: true, asyncInit: false};
        }
      } catch (err) {
        console.warn(`Initialization of backend ${backendName} failed`);
        console.warn(err.stack || err.message);
        return {success: false, asyncInit: false};
      }
    }
    removeBackend(backendName) {
      if (!(backendName in this.registryFactory)) {
        throw new Error(`${backendName} backend not found in registry`);
      }
      if (this.backendName === backendName && this.pendingBackendInit != null) {
        this.pendingBackendInitId++;
      }
      if (backendName in this.registry) {
        this.disposeRegisteredKernels(backendName);
        this.registry[backendName].dispose();
        delete this.registry[backendName];
      }
      delete this.registryFactory[backendName];
      if (this.backendName === backendName) {
        this.pendingBackendInit = null;
        this.backendName = null;
        this.backendInstance = null;
      }
    }
    getSortedBackends() {
      if (Object.keys(this.registryFactory).length === 0) {
        throw new Error("No backend found in registry.");
      }
      return Object.keys(this.registryFactory).sort((a, b) => {
        return this.registryFactory[b].priority - this.registryFactory[a].priority;
      });
    }
    initializeBackendsAndReturnBest() {
      const sortedBackends = this.getSortedBackends();
      for (let i = 0; i < sortedBackends.length; i++) {
        const backendName = sortedBackends[i];
        const {success, asyncInit} = this.initializeBackend(backendName);
        if (asyncInit || success) {
          return {name: backendName, asyncInit};
        }
      }
      throw new Error(`Could not initialize any backends, all backend initializations failed.`);
    }
    moveData(backend2, dataId) {
      const info = this.state.tensorInfo.get(dataId);
      const srcBackend = info.backend;
      const values = this.readSync(dataId);
      srcBackend.disposeData(dataId);
      info.backend = backend2;
      backend2.move(dataId, values, info.shape, info.dtype);
      if (this.shouldCheckForMemLeaks()) {
        this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1]++;
      }
    }
    tidy(nameOrFn, fn) {
      let name = null;
      if (fn == null) {
        if (typeof nameOrFn !== "function") {
          throw new Error("Please provide a function to tidy()");
        }
        fn = nameOrFn;
      } else {
        if (typeof nameOrFn !== "string" && !(nameOrFn instanceof String)) {
          throw new Error("When calling with two arguments, the first argument to tidy() must be a string");
        }
        if (typeof fn !== "function") {
          throw new Error("When calling with two arguments, the 2nd argument to tidy() must be a function");
        }
        name = nameOrFn;
      }
      let result;
      return this.scopedRun(() => this.startScope(name), () => this.endScope(result), () => {
        result = fn();
        if (result instanceof Promise) {
          console.error("Cannot return a Promise inside of tidy.");
        }
        return result;
      });
    }
    scopedRun(start, end, f) {
      start();
      try {
        const res = f();
        end();
        return res;
      } catch (ex) {
        end();
        throw ex;
      }
    }
    nextTensorId() {
      return Engine.nextTensorId++;
    }
    nextVariableId() {
      return Engine.nextVariableId++;
    }
    clone(x) {
      const y = this.makeTensorFromDataId(x.dataId, x.shape, x.dtype);
      const inputs = {x};
      const grad2 = (dy) => ({
        x: () => {
          const dtype = "float32";
          const gradInputs = {x: dy};
          const attrs = {dtype};
          return ENGINE.runKernelFunc((backend2) => backend2.cast(dy, dtype), gradInputs, null, Cast, attrs);
        }
      });
      const saved = [];
      this.addTapeNode(this.state.activeScope.name, inputs, [y], grad2, saved, {});
      return y;
    }
    runKernel(kernelName, inputs, attrs, inputsToSave, outputsToSave) {
      const forwardFunc = null;
      const backwardsFunc = null;
      return this.runKernelFunc(forwardFunc, inputs, backwardsFunc, kernelName, attrs, inputsToSave, outputsToSave);
    }
    shouldCheckForMemLeaks() {
      return this.ENV.getBool("IS_TEST");
    }
    checkKernelForMemLeak(kernelName, numDataIdsBefore, outInfos) {
      const numDataIdsAfter = this.backend.numDataIds();
      let numOutputDataIds = 0;
      outInfos.forEach((info) => {
        numOutputDataIds += info.dtype === "complex64" ? 3 : 1;
      });
      const numMoves = this.state.numDataMovesStack[this.state.numDataMovesStack.length - 1];
      const dataIdsLeaked = numDataIdsAfter - numDataIdsBefore - numOutputDataIds - numMoves;
      if (dataIdsLeaked > 0) {
        throw new Error(`Backend '${this.backendName}' has an internal memory leak (${dataIdsLeaked} data ids) after running '${kernelName}'`);
      }
    }
    runKernelFunc(forwardFunc, inputs, backwardsFunc, kernelName, attrs, inputsToSave, outputsToSave) {
      let outputs;
      let saved = [];
      const isTapeOn = this.isTapeOn();
      if (kernelName == null) {
        kernelName = this.state.activeScope != null ? this.state.activeScope.name : "";
      }
      const startingBytecount = this.state.numBytes;
      const startingNumTensors = this.state.numTensors;
      if (this.shouldCheckForMemLeaks()) {
        this.state.numDataMovesStack.push(0);
      }
      let kernelFunc;
      const kernel = getKernel(kernelName, this.backendName);
      let out;
      if (kernel != null) {
        kernelFunc = () => {
          const numDataIdsBefore = this.backend.numDataIds();
          out = kernel.kernelFunc({inputs, attrs, backend: this.backend});
          const outInfos = Array.isArray(out) ? out : [out];
          if (this.shouldCheckForMemLeaks()) {
            this.checkKernelForMemLeak(kernelName, numDataIdsBefore, outInfos);
          }
          const outTensors = outInfos.map(({dataId, shape, dtype}) => this.makeTensorFromDataId(dataId, shape, dtype));
          if (isTapeOn) {
            let tensorsToSave = this.getTensorsForGradient(kernelName, inputs, outTensors);
            if (tensorsToSave == null) {
              if (outputsToSave == null) {
                outputsToSave = [];
              }
              const outsToSave = outTensors.filter((_, i) => outputsToSave[i]);
              tensorsToSave = (inputsToSave || []).slice().concat(outsToSave);
            }
            saved = this.saveTensorsForBackwardMode(tensorsToSave);
          }
          return outTensors;
        };
      } else {
        const saveFunc = (tensors) => {
          if (!isTapeOn) {
            return;
          }
          saved = tensors.map((tensor17) => this.keep(this.clone(tensor17)));
        };
        kernelFunc = () => {
          const numDataIdsBefore = this.backend.numDataIds();
          out = this.tidy(() => forwardFunc(this.backend, saveFunc));
          const outs = Array.isArray(out) ? out : [out];
          if (this.shouldCheckForMemLeaks()) {
            this.checkKernelForMemLeak(kernelName, numDataIdsBefore, outs);
          }
          return outs;
        };
      }
      let kernelProfile;
      this.scopedRun(() => this.state.kernelDepth++, () => this.state.kernelDepth--, () => {
        if (!this.ENV.getBool("DEBUG") && !this.state.profiling) {
          outputs = kernelFunc();
        } else {
          kernelProfile = this.profiler.profileKernel(kernelName, inputs, () => kernelFunc());
          if (this.ENV.getBool("DEBUG")) {
            this.profiler.logKernelProfile(kernelProfile);
          }
          outputs = kernelProfile.outputs;
        }
      });
      if (isTapeOn) {
        this.addTapeNode(kernelName, inputs, outputs, backwardsFunc, saved, attrs);
      }
      if (this.state.profiling) {
        this.state.activeProfile.kernels.push({
          name: kernelName,
          bytesAdded: this.state.numBytes - startingBytecount,
          totalBytesSnapshot: this.state.numBytes,
          tensorsAdded: this.state.numTensors - startingNumTensors,
          totalTensorsSnapshot: this.state.numTensors,
          inputShapes: Object.keys(inputs).map((key) => inputs[key] != null ? inputs[key].shape : null),
          outputShapes: outputs.map((item) => item.shape),
          kernelTimeMs: kernelProfile.timeMs,
          extraInfo: kernelProfile.extraInfo
        });
      }
      return Array.isArray(out) ? outputs : outputs[0];
    }
    saveTensorsForBackwardMode(tensors) {
      const saved = tensors.map((tensor17) => this.keep(this.clone(tensor17)));
      return saved;
    }
    getTensorsForGradient(kernelName, inputs, outputs) {
      const gradConfig = getGradient(kernelName);
      if (gradConfig != null) {
        const inputsToSave = gradConfig.inputsToSave || [];
        const outputsToSave = gradConfig.outputsToSave || [];
        let inputTensorsToSave;
        if (gradConfig.saveAllInputs) {
          assert(Array.isArray(inputs), () => "saveAllInputs is true, expected inputs to be an array.");
          inputTensorsToSave = Object.keys(inputs).map((key) => inputs[key]);
        } else {
          inputTensorsToSave = inputsToSave.map((inputName) => inputs[inputName]);
        }
        const outputTensorsToSave = outputs.filter((_, i) => outputsToSave[i]);
        return inputTensorsToSave.concat(outputTensorsToSave);
      }
      return null;
    }
    makeTensor(values, shape, dtype, backend2) {
      if (values == null) {
        throw new Error("Values passed to engine.makeTensor() are null");
      }
      dtype = dtype || "float32";
      backend2 = backend2 || this.backend;
      let backendVals = values;
      if (dtype === "string" && isString(values[0])) {
        backendVals = values.map((d) => encodeString(d));
      }
      const dataId = backend2.write(backendVals, shape, dtype);
      const t = new Tensor(shape, dtype, dataId, this.nextTensorId());
      this.incRef(t, backend2);
      if (dtype === "string") {
        const info = this.state.tensorInfo.get(dataId);
        const newBytes = bytesFromStringArray(backendVals);
        this.state.numBytes += newBytes - info.bytes;
        info.bytes = newBytes;
      }
      return t;
    }
    makeTensorFromDataId(dataId, shape, dtype, backend2) {
      dtype = dtype || "float32";
      const t = new Tensor(shape, dtype, dataId, this.nextTensorId());
      this.incRef(t, backend2);
      return t;
    }
    makeVariable(initialValue, trainable = true, name, dtype) {
      name = name || this.nextVariableId().toString();
      if (dtype != null && dtype !== initialValue.dtype) {
        initialValue = initialValue.cast(dtype);
      }
      const v = new Variable(initialValue, trainable, name, this.nextTensorId());
      if (this.state.registeredVariables[v.name] != null) {
        throw new Error(`Variable with name ${v.name} was already registered`);
      }
      this.state.registeredVariables[v.name] = v;
      this.incRef(v, this.backend);
      return v;
    }
    incRef(a, backend2) {
      const refCount = this.state.tensorInfo.has(a.dataId) ? this.state.tensorInfo.get(a.dataId).refCount : 0;
      this.state.numTensors++;
      if (a.dtype === "string") {
        this.state.numStringTensors++;
      }
      if (refCount === 0) {
        this.state.numDataBuffers++;
        let bytes = 0;
        if (a.dtype !== "complex64" && a.dtype !== "string") {
          bytes = a.size * bytesPerElement(a.dtype);
        }
        this.state.tensorInfo.set(a.dataId, {
          backend: backend2 || this.backend,
          dtype: a.dtype,
          shape: a.shape,
          bytes,
          refCount: 0
        });
        this.state.numBytes += bytes;
      }
      this.state.tensorInfo.get(a.dataId).refCount++;
      if (!(a instanceof Variable)) {
        this.track(a);
      }
    }
    disposeTensor(a) {
      if (!this.state.tensorInfo.has(a.dataId)) {
        return;
      }
      this.state.numTensors--;
      if (a.dtype === "string") {
        this.state.numStringTensors--;
      }
      const info = this.state.tensorInfo.get(a.dataId);
      const refCount = info.refCount;
      if (refCount <= 1) {
        if (a.dtype !== "complex64") {
          this.state.numBytes -= info.bytes;
        }
        this.state.numDataBuffers--;
        info.backend.disposeData(a.dataId);
        this.state.tensorInfo.delete(a.dataId);
      } else {
        this.state.tensorInfo.get(a.dataId).refCount--;
      }
    }
    disposeVariables() {
      for (const varName in this.state.registeredVariables) {
        const v = this.state.registeredVariables[varName];
        this.disposeVariable(v);
      }
    }
    disposeVariable(v) {
      this.disposeTensor(v);
      if (this.state.registeredVariables[v.name] != null) {
        delete this.state.registeredVariables[v.name];
      }
    }
    memory() {
      const info = this.backend.memory();
      info.numTensors = this.state.numTensors;
      info.numDataBuffers = this.state.numDataBuffers;
      info.numBytes = this.state.numBytes;
      if (this.state.numStringTensors > 0) {
        info.unreliable = true;
        if (info.reasons == null) {
          info.reasons = [];
        }
        info.reasons.push("Memory usage by string tensors is approximate (2 bytes per character)");
      }
      return info;
    }
    async profile(query) {
      this.state.profiling = true;
      const startBytes = this.state.numBytes;
      const startNumTensors = this.state.numTensors;
      this.state.activeProfile.kernels = [];
      this.state.activeProfile.result = await query();
      this.state.profiling = false;
      this.state.activeProfile.peakBytes = Math.max(...this.state.activeProfile.kernels.map((d) => d.totalBytesSnapshot));
      this.state.activeProfile.newBytes = this.state.numBytes - startBytes;
      this.state.activeProfile.newTensors = this.state.numTensors - startNumTensors;
      for (const kernel of this.state.activeProfile.kernels) {
        kernel.kernelTimeMs = await kernel.kernelTimeMs;
        kernel.extraInfo = await kernel.extraInfo;
      }
      return this.state.activeProfile;
    }
    isTapeOn() {
      return this.state.gradientDepth > 0 && this.state.kernelDepth === 0;
    }
    addTapeNode(kernelName, inputs, outputs, gradientsFunc, saved, attrs) {
      const tapeNode = {id: this.state.nextTapeNodeId++, kernelName, inputs, outputs, saved};
      const gradConfig = getGradient(kernelName);
      if (gradConfig != null) {
        gradientsFunc = gradConfig.gradFunc;
      }
      if (gradientsFunc != null) {
        tapeNode.gradient = (dys) => {
          dys = dys.map((dy, i) => {
            if (dy == null) {
              const output = outputs[i];
              const vals = makeZerosTypedArray(output.size, output.dtype);
              return this.makeTensor(vals, output.shape, output.dtype);
            }
            return dy;
          });
          return gradientsFunc(dys.length > 1 ? dys : dys[0], saved, attrs);
        };
      }
      this.state.activeTape.push(tapeNode);
    }
    keep(result) {
      result.kept = true;
      return result;
    }
    startTape() {
      if (this.state.gradientDepth === 0) {
        this.state.activeTape = [];
      }
      this.state.gradientDepth++;
    }
    endTape() {
      this.state.gradientDepth--;
    }
    startScope(name) {
      const scopeInfo = {
        track: [],
        name: "unnamed scope",
        id: this.state.nextScopeId++
      };
      if (name) {
        scopeInfo.name = name;
      }
      this.state.scopeStack.push(scopeInfo);
      this.state.activeScope = scopeInfo;
    }
    endScope(result) {
      const tensorsToTrackInParent = getTensorsInContainer(result);
      const tensorsToTrackInParentSet = new Set(tensorsToTrackInParent.map((t) => t.id));
      for (let i = 0; i < this.state.activeScope.track.length; i++) {
        const tensor17 = this.state.activeScope.track[i];
        if (!tensor17.kept && !tensorsToTrackInParentSet.has(tensor17.id)) {
          tensor17.dispose();
        }
      }
      const oldScope = this.state.scopeStack.pop();
      this.state.activeScope = this.state.scopeStack.length === 0 ? null : this.state.scopeStack[this.state.scopeStack.length - 1];
      tensorsToTrackInParent.forEach((tensor17) => {
        if (!tensor17.kept && tensor17.scopeId === oldScope.id) {
          this.track(tensor17);
        }
      });
    }
    gradients(f, xs, dy, allowNoGradients = false) {
      assert(xs.length > 0, () => "gradients() received an empty list of xs.");
      if (dy != null && dy.dtype !== "float32") {
        throw new Error(`dy must have 'float32' dtype, but has '${dy.dtype}'`);
      }
      const y = this.scopedRun(() => this.startTape(), () => this.endTape(), () => this.tidy("forward", f));
      assert(y instanceof Tensor, () => "The result y returned by f() must be a tensor.");
      const filteredTape = getFilteredNodesXToY(this.state.activeTape, xs, y);
      if (!allowNoGradients && filteredTape.length === 0 && xs.length > 0) {
        throw new Error("Cannot compute gradient of y=f(x) with respect to x. Make sure that the f you passed encloses all operations that lead from x to y.");
      }
      return this.tidy("backward", () => {
        const accumulatedGradientMap = {};
        accumulatedGradientMap[y.id] = dy == null ? ones(y.shape) : dy;
        backpropagateGradients(accumulatedGradientMap, filteredTape, (f2) => this.tidy(f2), add);
        const grads2 = xs.map((x) => accumulatedGradientMap[x.id]);
        if (this.state.gradientDepth === 0) {
          this.state.activeTape.forEach((node) => {
            for (const tensor17 of node.saved) {
              tensor17.dispose();
            }
          });
          this.state.activeTape = null;
        }
        return {value: y, grads: grads2};
      });
    }
    customGrad(f) {
      assert(isFunction(f), () => "The f passed in customGrad(f) must be a function.");
      return (...inputs) => {
        assert(inputs.every((t) => t instanceof Tensor), () => "The args passed in customGrad(f)(x1, x2,...) must all be tensors");
        let res;
        const inputMap = {};
        inputs.forEach((input, i) => {
          inputMap[i] = input;
        });
        return this.runKernelFunc((_, save) => {
          res = f(...[...inputs, save]);
          assert(res.value instanceof Tensor, () => "The function f passed in customGrad(f) must return an object where `obj.value` is a tensor");
          assert(isFunction(res.gradFunc), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function.");
          return res.value;
        }, inputMap, (dy, saved) => {
          const gradRes = res.gradFunc(dy, saved);
          const grads2 = Array.isArray(gradRes) ? gradRes : [gradRes];
          assert(grads2.length === inputs.length, () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns the same number of tensors as inputs passed to f(...).");
          assert(grads2.every((t) => t instanceof Tensor), () => "The function f passed in customGrad(f) must return an object where `obj.gradFunc` is a function that returns a list of only tensors.");
          const gradMap = {};
          grads2.forEach((grad2, i) => {
            gradMap[i] = () => grad2;
          });
          return gradMap;
        });
      };
    }
    readSync(dataId) {
      const info = this.state.tensorInfo.get(dataId);
      return info.backend.readSync(dataId);
    }
    read(dataId) {
      const info = this.state.tensorInfo.get(dataId);
      return info.backend.read(dataId);
    }
    async time(query) {
      const start = now();
      const timingInfo = await this.backend.time(query);
      timingInfo.wallMs = now() - start;
      return timingInfo;
    }
    track(result) {
      if (this.state.activeScope != null) {
        result.scopeId = this.state.activeScope.id;
        this.state.activeScope.track.push(result);
      }
      return result;
    }
    get registeredVariables() {
      return this.state.registeredVariables;
    }
    reset() {
      this.pendingBackendInitId++;
      this.state.dispose();
      this.ENV.reset();
      this.state = new EngineState();
      for (const backendName in this.registry) {
        this.disposeRegisteredKernels(backendName);
        this.registry[backendName].dispose();
        delete this.registry[backendName];
      }
      this.backendName = null;
      this.backendInstance = null;
      this.pendingBackendInit = null;
    }
  }
  Engine.nextTensorId = 0;
  Engine.nextVariableId = 0;
  function ones(shape) {
    const values = makeOnesTypedArray(sizeFromShape(shape), "float32");
    return ENGINE.makeTensor(values, shape, "float32");
  }
  function getOrMakeEngine() {
    const ns = getGlobalNamespace();
    if (ns._tfengine == null) {
      const environment12 = new Environment(ns);
      ns._tfengine = new Engine(environment12);
    }
    setEnvironmentGlobal(ns._tfengine.ENV);
    setTensorTracker(() => ns._tfengine);
    return ns._tfengine;
  }
  const ENGINE = getOrMakeEngine();
  function add(a, b) {
    const inputs = {a, b};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.add(a, b);
      save([a, b]);
      return res;
    }, inputs, null, Add);
  }

  // node_modules/@tensorflow/tfjs-core/dist/device_util.js
  const device_util_exports = {};
  __export(device_util_exports, {
    isBrowser: () => isBrowser,
    isMobile: () => isMobile
  });
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function _isNavigatorDefined() {
    return typeof navigator !== "undefined" && navigator != null;
  }
  function isMobile() {
    if (_isNavigatorDefined()) {
      const a = navigator.userAgent || navigator.vendor || window.opera;
      return /(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4));
    }
    return false;
  }
  function isBrowser() {
    return typeof window !== "undefined" && window.document != null || typeof WorkerGlobalScope !== "undefined";
  }

  // node_modules/@tensorflow/tfjs-core/dist/flags.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const ENV2 = env();
  ENV2.registerFlag("DEBUG", () => false, (debugValue) => {
    if (debugValue) {
      console.warn("Debugging mode is ON. The output of every math call will be downloaded to CPU and checked for NaNs. This significantly impacts performance.");
    }
  });
  ENV2.registerFlag("IS_BROWSER", () => isBrowser());
  ENV2.registerFlag("IS_NODE", () => typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined");
  ENV2.registerFlag("IS_CHROME", () => typeof navigator !== "undefined" && navigator != null && navigator.userAgent != null && /Chrome/.test(navigator.userAgent) && /Google Inc/.test(navigator.vendor));
  ENV2.registerFlag("PROD", () => false);
  ENV2.registerFlag("TENSORLIKE_CHECK_SHAPE_CONSISTENCY", () => ENV2.getBool("DEBUG"));
  ENV2.registerFlag("DEPRECATION_WARNINGS_ENABLED", () => true);
  ENV2.registerFlag("IS_TEST", () => false);

  // node_modules/@tensorflow/tfjs-core/dist/tensor_util_env.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function inferShape(val, dtype) {
    let firstElem = val;
    if (isTypedArray(val)) {
      return dtype === "string" ? [] : [val.length];
    }
    if (!Array.isArray(val)) {
      return [];
    }
    const shape = [];
    while (Array.isArray(firstElem) || isTypedArray(firstElem) && dtype !== "string") {
      shape.push(firstElem.length);
      firstElem = firstElem[0];
    }
    if (Array.isArray(val) && env().getBool("TENSORLIKE_CHECK_SHAPE_CONSISTENCY")) {
      deepAssertShapeConsistency(val, shape, []);
    }
    return shape;
  }
  function deepAssertShapeConsistency(val, shape, indices) {
    indices = indices || [];
    if (!Array.isArray(val) && !isTypedArray(val)) {
      assert(shape.length === 0, () => `Element arr[${indices.join("][")}] is a primitive, but should be an array/TypedArray of ${shape[0]} elements`);
      return;
    }
    assert(shape.length > 0, () => `Element arr[${indices.join("][")}] should be a primitive, but is an array of ${val.length} elements`);
    assert(val.length === shape[0], () => `Element arr[${indices.join("][")}] should have ${shape[0]} elements, but has ${val.length} elements`);
    const subShape = shape.slice(1);
    for (let i = 0; i < val.length; ++i) {
      deepAssertShapeConsistency(val[i], subShape, indices.concat(i));
    }
  }
  function assertDtype(expectedDtype, actualDType, argName, functionName) {
    if (expectedDtype == null) {
      return;
    }
    if (expectedDtype !== "numeric" && expectedDtype !== actualDType || expectedDtype === "numeric" && actualDType === "string") {
      throw new Error(`Argument '${argName}' passed to '${functionName}' must be ${expectedDtype} tensor, but got ${actualDType} tensor`);
    }
  }
  function convertToTensor(x, argName, functionName, parseAsDtype = "numeric") {
    if (x instanceof Tensor) {
      assertDtype(parseAsDtype, x.dtype, argName, functionName);
      return x;
    }
    let inferredDtype = inferDtype(x);
    if (inferredDtype !== "string" && ["bool", "int32", "float32"].indexOf(parseAsDtype) >= 0) {
      inferredDtype = parseAsDtype;
    }
    assertDtype(parseAsDtype, inferredDtype, argName, functionName);
    if (x == null || !isTypedArray(x) && !Array.isArray(x) && typeof x !== "number" && typeof x !== "boolean" && typeof x !== "string") {
      const type = x == null ? "null" : x.constructor.name;
      throw new Error(`Argument '${argName}' passed to '${functionName}' must be a Tensor or TensorLike, but got '${type}'`);
    }
    const inferredShape = inferShape(x, inferredDtype);
    if (!isTypedArray(x) && !Array.isArray(x)) {
      x = [x];
    }
    const skipTypedArray = true;
    const values = inferredDtype !== "string" ? toTypedArray(x, inferredDtype) : flatten(x, [], skipTypedArray);
    return ENGINE.makeTensor(values, inferredShape, inferredDtype);
  }
  function convertToTensorArray(arg, argName, functionName, parseAsDtype = "numeric") {
    if (!Array.isArray(arg)) {
      throw new Error(`Argument ${argName} passed to ${functionName} must be a \`Tensor[]\` or \`TensorLike[]\``);
    }
    const tensors = arg;
    return tensors.map((t, i) => convertToTensor(t, `${argName}[${i}]`, functionName), parseAsDtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/operation.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const OP_SCOPE_SUFFIX = "__op";
  function op(f) {
    const keys = Object.keys(f);
    if (keys.length !== 1) {
      throw new Error(`Please provide an object with a single key (operation name) mapping to a function. Got an object with ${keys.length} keys.`);
    }
    let opName = keys[0];
    const fn = f[opName];
    if (opName.endsWith("_")) {
      opName = opName.substring(0, opName.length - 1);
    }
    opName = opName + OP_SCOPE_SUFFIX;
    const f2 = (...args) => {
      ENGINE.startScope(opName);
      try {
        const result = fn(...args);
        if (result instanceof Promise) {
          console.error("Cannot return a Promise inside of tidy.");
        }
        ENGINE.endScope(result);
        return result;
      } catch (ex) {
        ENGINE.endScope(null);
        throw ex;
      }
    };
    Object.defineProperty(f2, "name", {value: opName, configurable: true});
    return f2;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/complex.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function complex_(real6, imag6) {
    const $real = convertToTensor(real6, "real", "complex");
    const $imag = convertToTensor(imag6, "imag", "complex");
    assertShapesMatch($real.shape, $imag.shape, `real and imag shapes, ${$real.shape} and ${$imag.shape}, must match in call to tf.complex().`);
    const forward = (backend2) => {
      return backend2.complex($real, $imag);
    };
    const inputs = {real: $real, imag: $imag};
    return ENGINE.runKernelFunc(forward, inputs, null, Complex);
  }
  const complex = op({complex_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor_ops_util.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function makeTensor(values, shape, inferredShape, dtype) {
    if (dtype == null) {
      dtype = inferDtype(values);
    }
    if (dtype === "complex64") {
      throw new Error(`Cannot construct a complex64 tensor directly. Please use tf.complex(real, imag).`);
    }
    if (!isTypedArray(values) && !Array.isArray(values) && typeof values !== "number" && typeof values !== "boolean" && typeof values !== "string") {
      throw new Error("values passed to tensor(values) must be a number/boolean/string or an array of numbers/booleans/strings, or a TypedArray");
    }
    if (shape != null) {
      assertNonNegativeIntegerDimensions(shape);
      const providedSize = sizeFromShape(shape);
      const inferredSize = sizeFromShape(inferredShape);
      assert(providedSize === inferredSize, () => `Based on the provided shape, [${shape}], the tensor should have ${providedSize} values but has ${inferredSize}`);
      for (let i = 0; i < inferredShape.length; ++i) {
        const inferred = inferredShape[i];
        const flatDimsDontMatch = i === inferredShape.length - 1 ? inferred !== sizeFromShape(shape.slice(i)) : true;
        assert(inferredShape[i] === shape[i] || !flatDimsDontMatch, () => `Error creating a new Tensor. Inferred shape (${inferredShape}) does not match the provided shape (${shape}). `);
      }
    }
    if (!isTypedArray(values) && !Array.isArray(values)) {
      values = [values];
    }
    shape = shape || inferredShape;
    values = dtype !== "string" ? toTypedArray(values, dtype) : flatten(values, [], true);
    return ENGINE.makeTensor(values, shape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor4(values, shape, dtype) {
    const inferredShape = inferShape(values, dtype);
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/types.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const DTYPE_VALUE_SIZE_MAP = {
    float32: 4,
    float16: 2,
    int32: 4,
    uint16: 2,
    uint8: 1,
    bool: 1,
    complex64: 8
  };

  // node_modules/@tensorflow/tfjs-core/dist/io/io_utils.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const NUM_BYTES_STRING_LENGTH = 4;
  async function encodeWeights(tensors, group) {
    const specs = [];
    const dataPromises = [];
    const names = Array.isArray(tensors) ? tensors.map((tensor17) => tensor17.name) : Object.keys(tensors);
    for (let i = 0; i < names.length; ++i) {
      const name = names[i];
      const t = Array.isArray(tensors) ? tensors[i].tensor : tensors[name];
      if (t.dtype !== "float32" && t.dtype !== "int32" && t.dtype !== "bool" && t.dtype !== "string" && t.dtype !== "complex64") {
        throw new Error(`Unsupported dtype in weight '${name}': ${t.dtype}`);
      }
      const spec = {name, shape: t.shape, dtype: t.dtype};
      if (t.dtype === "string") {
        const utf8bytes = new Promise(async (resolve) => {
          const vals = await t.bytes();
          const totalNumBytes = vals.reduce((p, c) => p + c.length, 0) + NUM_BYTES_STRING_LENGTH * vals.length;
          const bytes = new Uint8Array(totalNumBytes);
          let offset = 0;
          for (let i2 = 0; i2 < vals.length; i2++) {
            const val = vals[i2];
            const bytesOfLength = new Uint8Array(new Uint32Array([val.length]).buffer);
            bytes.set(bytesOfLength, offset);
            offset += NUM_BYTES_STRING_LENGTH;
            bytes.set(val, offset);
            offset += val.length;
          }
          resolve(bytes);
        });
        dataPromises.push(utf8bytes);
      } else {
        dataPromises.push(t.data());
      }
      if (group != null) {
        spec.group = group;
      }
      specs.push(spec);
    }
    const tensorValues = await Promise.all(dataPromises);
    return {data: concatenateTypedArrays(tensorValues), specs};
  }
  function decodeWeights(buffer11, specs) {
    const out = {};
    let float16Decode;
    let offset = 0;
    for (const spec of specs) {
      const name = spec.name;
      const dtype = spec.dtype;
      const shape = spec.shape;
      const size = sizeFromShape(shape);
      let values;
      if ("quantization" in spec) {
        const quantization = spec.quantization;
        if (quantization.dtype === "uint8" || quantization.dtype === "uint16") {
          if (!("min" in quantization && "scale" in quantization)) {
            throw new Error(`Weight ${spec.name} with quantization ${quantization.dtype} doesn't have corresponding metadata min and scale.`);
          }
        } else if (quantization.dtype === "float16") {
          if (dtype !== "float32") {
            throw new Error(`Weight ${spec.name} is quantized with ${quantization.dtype} which only supports weights of type float32 not ${dtype}.`);
          }
        } else {
          throw new Error(`Weight ${spec.name} has unknown quantization dtype ${quantization.dtype}. Supported quantization dtypes are: 'uint8', 'uint16', and 'float16'.`);
        }
        const quantizationSizeFactor = DTYPE_VALUE_SIZE_MAP[quantization.dtype];
        const byteBuffer = buffer11.slice(offset, offset + size * quantizationSizeFactor);
        const quantizedArray = quantization.dtype === "uint8" ? new Uint8Array(byteBuffer) : new Uint16Array(byteBuffer);
        if (dtype === "float32") {
          if (quantization.dtype === "uint8" || quantization.dtype === "uint16") {
            values = new Float32Array(quantizedArray.length);
            for (let i = 0; i < quantizedArray.length; i++) {
              const v = quantizedArray[i];
              values[i] = v * quantization.scale + quantization.min;
            }
          } else if (quantization.dtype === "float16") {
            if (float16Decode === void 0) {
              float16Decode = getFloat16Decoder();
            }
            values = float16Decode(quantizedArray);
          } else {
            throw new Error(`Unsupported quantization type ${quantization.dtype} for weight type float32.`);
          }
        } else if (dtype === "int32") {
          if (quantization.dtype !== "uint8" && quantization.dtype !== "uint16") {
            throw new Error(`Unsupported quantization type ${quantization.dtype} for weight type int32.`);
          }
          values = new Int32Array(quantizedArray.length);
          for (let i = 0; i < quantizedArray.length; i++) {
            const v = quantizedArray[i];
            values[i] = Math.round(v * quantization.scale + quantization.min);
          }
        } else {
          throw new Error(`Unsupported dtype in weight '${name}': ${dtype}`);
        }
        offset += size * quantizationSizeFactor;
      } else if (dtype === "string") {
        const size2 = sizeFromShape(spec.shape);
        values = [];
        for (let i = 0; i < size2; i++) {
          const byteLength = new Uint32Array(buffer11.slice(offset, offset + NUM_BYTES_STRING_LENGTH))[0];
          offset += NUM_BYTES_STRING_LENGTH;
          const bytes = new Uint8Array(buffer11.slice(offset, offset + byteLength));
          values.push(bytes);
          offset += byteLength;
        }
      } else {
        const dtypeFactor = DTYPE_VALUE_SIZE_MAP[dtype];
        const byteBuffer = buffer11.slice(offset, offset + size * dtypeFactor);
        if (dtype === "float32") {
          values = new Float32Array(byteBuffer);
        } else if (dtype === "int32") {
          values = new Int32Array(byteBuffer);
        } else if (dtype === "bool") {
          values = new Uint8Array(byteBuffer);
        } else if (dtype === "complex64") {
          values = new Float32Array(byteBuffer);
          const real6 = new Float32Array(values.length / 2);
          const image2 = new Float32Array(values.length / 2);
          for (let i = 0; i < real6.length; i++) {
            real6[i] = values[i * 2];
            image2[i] = values[i * 2 + 1];
          }
          const realTensor = tensor4(real6, shape, "float32");
          const imageTensor = tensor4(image2, shape, "float32");
          out[name] = complex(realTensor, imageTensor);
        } else {
          throw new Error(`Unsupported dtype in weight '${name}': ${dtype}`);
        }
        offset += size * dtypeFactor;
      }
      if (dtype !== "complex64") {
        out[name] = tensor4(values, shape, dtype);
      }
    }
    return out;
  }
  function concatenateTypedArrays(xs) {
    if (xs === null) {
      throw new Error(`Invalid input value: ${JSON.stringify(xs)}`);
    }
    let totalByteLength = 0;
    const normalizedXs = [];
    xs.forEach((x) => {
      totalByteLength += x.byteLength;
      normalizedXs.push(x.byteLength === x.buffer.byteLength ? x : new x.constructor(x));
      if (!(x instanceof Float32Array || x instanceof Int32Array || x instanceof Uint8Array)) {
        throw new Error(`Unsupported TypedArray subtype: ${x.constructor.name}`);
      }
    });
    const y = new Uint8Array(totalByteLength);
    let offset = 0;
    normalizedXs.forEach((x) => {
      y.set(new Uint8Array(x.buffer), offset);
      offset += x.byteLength;
    });
    return y.buffer;
  }
  const useNodeBuffer = typeof Buffer !== "undefined" && (typeof Blob === "undefined" || typeof atob === "undefined" || typeof btoa === "undefined");
  function stringByteLength(str) {
    if (useNodeBuffer) {
      return Buffer.byteLength(str);
    }
    return new Blob([str]).size;
  }
  function concatenateArrayBuffers(buffers) {
    if (buffers.length === 1) {
      return buffers[0];
    }
    let totalByteLength = 0;
    buffers.forEach((buffer11) => {
      totalByteLength += buffer11.byteLength;
    });
    const temp = new Uint8Array(totalByteLength);
    let offset = 0;
    buffers.forEach((buffer11) => {
      temp.set(new Uint8Array(buffer11), offset);
      offset += buffer11.byteLength;
    });
    return temp.buffer;
  }
  function basename(path) {
    const SEPARATOR = "/";
    path = path.trim();
    while (path.endsWith(SEPARATOR)) {
      path = path.slice(0, path.length - 1);
    }
    const items = path.split(SEPARATOR);
    return items[items.length - 1];
  }
  function getModelArtifactsInfoForJSON(modelArtifacts) {
    if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
      throw new Error("Expected JSON model topology, received ArrayBuffer.");
    }
    return {
      dateSaved: new Date(),
      modelTopologyType: "JSON",
      modelTopologyBytes: modelArtifacts.modelTopology == null ? 0 : stringByteLength(JSON.stringify(modelArtifacts.modelTopology)),
      weightSpecsBytes: modelArtifacts.weightSpecs == null ? 0 : stringByteLength(JSON.stringify(modelArtifacts.weightSpecs)),
      weightDataBytes: modelArtifacts.weightData == null ? 0 : modelArtifacts.weightData.byteLength
    };
  }
  function computeFloat16MantisaTable() {
    const convertMantissa = (i) => {
      let m = i << 13;
      let e = 0;
      while ((m & 8388608) === 0) {
        e -= 8388608;
        m <<= 1;
      }
      m &= ~8388608;
      e += 947912704;
      return m | e;
    };
    const mantisaTable = new Uint32Array(2048);
    mantisaTable[0] = 0;
    for (let i = 1; i < 1024; i++) {
      mantisaTable[i] = convertMantissa(i);
    }
    for (let i = 1024; i < 2048; i++) {
      mantisaTable[i] = 939524096 + (i - 1024 << 13);
    }
    return mantisaTable;
  }
  function computeFloat16ExponentTable() {
    const exponentTable = new Uint32Array(64);
    exponentTable[0] = 0;
    exponentTable[31] = 1199570944;
    exponentTable[32] = 2147483648;
    exponentTable[63] = 3347054592;
    for (let i = 1; i < 31; i++) {
      exponentTable[i] = i << 23;
    }
    for (let i = 33; i < 63; i++) {
      exponentTable[i] = 2147483648 + (i - 32 << 23);
    }
    return exponentTable;
  }
  function computeFloat16OffsetTable() {
    const offsetTable = new Uint32Array(64);
    for (let i = 0; i < 64; i++) {
      offsetTable[i] = 1024;
    }
    offsetTable[0] = offsetTable[32] = 0;
    return offsetTable;
  }
  function getFloat16Decoder() {
    const mantisaTable = computeFloat16MantisaTable();
    const exponentTable = computeFloat16ExponentTable();
    const offsetTable = computeFloat16OffsetTable();
    return (quantizedArray) => {
      const buffer11 = new ArrayBuffer(4 * quantizedArray.length);
      const bufferUint32View = new Uint32Array(buffer11);
      for (let index = 0; index < quantizedArray.length; index++) {
        const float16Bits = quantizedArray[index];
        const float32Bits = mantisaTable[offsetTable[float16Bits >> 10] + (float16Bits & 1023)] + exponentTable[float16Bits >> 10];
        bufferUint32View[index] = float32Bits;
      }
      return new Float32Array(buffer11);
    };
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/router_registry.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class IORouterRegistry {
    constructor() {
      this.saveRouters = [];
      this.loadRouters = [];
    }
    static getInstance() {
      if (IORouterRegistry.instance == null) {
        IORouterRegistry.instance = new IORouterRegistry();
      }
      return IORouterRegistry.instance;
    }
    static registerSaveRouter(saveRouter) {
      IORouterRegistry.getInstance().saveRouters.push(saveRouter);
    }
    static registerLoadRouter(loadRouter) {
      IORouterRegistry.getInstance().loadRouters.push(loadRouter);
    }
    static getSaveHandlers(url) {
      return IORouterRegistry.getHandlers(url, "save");
    }
    static getLoadHandlers(url, loadOptions) {
      return IORouterRegistry.getHandlers(url, "load", loadOptions);
    }
    static getHandlers(url, handlerType, loadOptions) {
      const validHandlers = [];
      const routers = handlerType === "load" ? IORouterRegistry.getInstance().loadRouters : IORouterRegistry.getInstance().saveRouters;
      routers.forEach((router) => {
        const handler = router(url, loadOptions);
        if (handler !== null) {
          validHandlers.push(handler);
        }
      });
      return validHandlers;
    }
  }
  const registerSaveRouter = (loudRouter) => IORouterRegistry.registerSaveRouter(loudRouter);
  const registerLoadRouter = (loudRouter) => IORouterRegistry.registerLoadRouter(loudRouter);
  const getSaveHandlers = (url) => IORouterRegistry.getSaveHandlers(url);
  const getLoadHandlers = (url, loadOptions) => IORouterRegistry.getLoadHandlers(url, loadOptions);

  // node_modules/@tensorflow/tfjs-core/dist/io/model_management.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const URL_SCHEME_SUFFIX = "://";
  class ModelStoreManagerRegistry {
    constructor() {
      this.managers = {};
    }
    static getInstance() {
      if (ModelStoreManagerRegistry.instance == null) {
        ModelStoreManagerRegistry.instance = new ModelStoreManagerRegistry();
      }
      return ModelStoreManagerRegistry.instance;
    }
    static registerManager(scheme, manager) {
      assert(scheme != null, () => "scheme must not be undefined or null.");
      if (scheme.endsWith(URL_SCHEME_SUFFIX)) {
        scheme = scheme.slice(0, scheme.indexOf(URL_SCHEME_SUFFIX));
      }
      assert(scheme.length > 0, () => "scheme must not be an empty string.");
      const registry = ModelStoreManagerRegistry.getInstance();
      assert(registry.managers[scheme] == null, () => `A model store manager is already registered for scheme '${scheme}'.`);
      registry.managers[scheme] = manager;
    }
    static getManager(scheme) {
      const manager = this.getInstance().managers[scheme];
      if (manager == null) {
        throw new Error(`Cannot find model manager for scheme '${scheme}'`);
      }
      return manager;
    }
    static getSchemes() {
      return Object.keys(this.getInstance().managers);
    }
  }
  function parseURL(url) {
    if (url.indexOf(URL_SCHEME_SUFFIX) === -1) {
      throw new Error(`The url string provided does not contain a scheme. Supported schemes are: ${ModelStoreManagerRegistry.getSchemes().join(",")}`);
    }
    return {
      scheme: url.split(URL_SCHEME_SUFFIX)[0],
      path: url.split(URL_SCHEME_SUFFIX)[1]
    };
  }
  async function cloneModelInternal(sourceURL, destURL, deleteSource = false) {
    assert(sourceURL !== destURL, () => `Old path and new path are the same: '${sourceURL}'`);
    const loadHandlers = IORouterRegistry.getLoadHandlers(sourceURL);
    assert(loadHandlers.length > 0, () => `Copying failed because no load handler is found for source URL ${sourceURL}.`);
    assert(loadHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) load handlers for source URL ${sourceURL}.`);
    const loadHandler = loadHandlers[0];
    const saveHandlers = IORouterRegistry.getSaveHandlers(destURL);
    assert(saveHandlers.length > 0, () => `Copying failed because no save handler is found for destination URL ${destURL}.`);
    assert(saveHandlers.length < 2, () => `Copying failed because more than one (${loadHandlers.length}) save handlers for destination URL ${destURL}.`);
    const saveHandler = saveHandlers[0];
    const sourceScheme = parseURL(sourceURL).scheme;
    const sourcePath = parseURL(sourceURL).path;
    const sameMedium = sourceScheme === parseURL(sourceURL).scheme;
    const modelArtifacts = await loadHandler.load();
    if (deleteSource && sameMedium) {
      await ModelStoreManagerRegistry.getManager(sourceScheme).removeModel(sourcePath);
    }
    const saveResult = await saveHandler.save(modelArtifacts);
    if (deleteSource && !sameMedium) {
      await ModelStoreManagerRegistry.getManager(sourceScheme).removeModel(sourcePath);
    }
    return saveResult.modelArtifactsInfo;
  }
  async function listModels() {
    const schemes = ModelStoreManagerRegistry.getSchemes();
    const out = {};
    for (const scheme of schemes) {
      const schemeOut = await ModelStoreManagerRegistry.getManager(scheme).listModels();
      for (const path in schemeOut) {
        const url = scheme + URL_SCHEME_SUFFIX + path;
        out[url] = schemeOut[path];
      }
    }
    return out;
  }
  async function removeModel(url) {
    const schemeAndPath = parseURL(url);
    const manager = ModelStoreManagerRegistry.getManager(schemeAndPath.scheme);
    return manager.removeModel(schemeAndPath.path);
  }
  async function copyModel(sourceURL, destURL) {
    const deleteSource = false;
    return cloneModelInternal(sourceURL, destURL, deleteSource);
  }
  async function moveModel(sourceURL, destURL) {
    const deleteSource = true;
    return cloneModelInternal(sourceURL, destURL, deleteSource);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/buffer.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function buffer(shape, dtype = "float32", values) {
    dtype = dtype || "float32";
    assertNonNegativeIntegerDimensions(shape);
    return new TensorBuffer(shape, dtype, values);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/cast.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function cast_(x, dtype) {
    const $x = convertToTensor(x, "x", "cast");
    if (!isValidDtype(dtype)) {
      throw new Error(`Failed to cast to unknown dtype ${dtype}`);
    }
    if (dtype === "string" && $x.dtype !== "string" || dtype !== "string" && $x.dtype === "string") {
      throw new Error("Only strings can be casted to strings");
    }
    const inputs = {x: $x};
    const attrs = {dtype};
    return ENGINE.runKernelFunc((backend2) => backend2.cast($x, dtype), inputs, null, Cast, attrs);
  }
  const cast = op({cast_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/clone.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function clone_(x) {
    const $x = convertToTensor(x, "x", "clone", null);
    const forward = () => ENGINE.makeTensorFromDataId($x.dataId, $x.shape, $x.dtype);
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Identity);
  }
  const clone = op({clone_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/print.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function print(x, verbose = false) {
    console.log(x.toString(verbose));
  }

  // node_modules/@tensorflow/tfjs-core/dist/base_side_effects.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  getOrMakeEngine();
  const opHandler2 = {
    buffer,
    cast,
    clone,
    print
  };
  setOpHandler(opHandler2);

  // node_modules/@tensorflow/tfjs-core/dist/io/browser_files.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const DEFAULT_FILE_NAME_PREFIX = "model";
  const DEFAULT_JSON_EXTENSION_NAME = ".json";
  const DEFAULT_WEIGHT_DATA_EXTENSION_NAME = ".weights.bin";
  function defer(f) {
    return new Promise((resolve) => setTimeout(resolve)).then(f);
  }
  class BrowserDownloads {
    constructor(fileNamePrefix) {
      if (!env().getBool("IS_BROWSER")) {
        throw new Error("browserDownloads() cannot proceed because the current environment is not a browser.");
      }
      if (fileNamePrefix.startsWith(BrowserDownloads.URL_SCHEME)) {
        fileNamePrefix = fileNamePrefix.slice(BrowserDownloads.URL_SCHEME.length);
      }
      if (fileNamePrefix == null || fileNamePrefix.length === 0) {
        fileNamePrefix = DEFAULT_FILE_NAME_PREFIX;
      }
      this.modelTopologyFileName = fileNamePrefix + DEFAULT_JSON_EXTENSION_NAME;
      this.weightDataFileName = fileNamePrefix + DEFAULT_WEIGHT_DATA_EXTENSION_NAME;
    }
    async save(modelArtifacts) {
      if (typeof document === "undefined") {
        throw new Error("Browser downloads are not supported in this environment since `document` is not present");
      }
      const weightsURL = window.URL.createObjectURL(new Blob([modelArtifacts.weightData], {type: "application/octet-stream"}));
      if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
        throw new Error("BrowserDownloads.save() does not support saving model topology in binary formats yet.");
      } else {
        const weightsManifest = [{
          paths: ["./" + this.weightDataFileName],
          weights: modelArtifacts.weightSpecs
        }];
        const modelTopologyAndWeightManifest = {
          modelTopology: modelArtifacts.modelTopology,
          format: modelArtifacts.format,
          generatedBy: modelArtifacts.generatedBy,
          convertedBy: modelArtifacts.convertedBy,
          weightsManifest
        };
        const modelTopologyAndWeightManifestURL = window.URL.createObjectURL(new Blob([JSON.stringify(modelTopologyAndWeightManifest)], {type: "application/json"}));
        const jsonAnchor = this.jsonAnchor == null ? document.createElement("a") : this.jsonAnchor;
        jsonAnchor.download = this.modelTopologyFileName;
        jsonAnchor.href = modelTopologyAndWeightManifestURL;
        await defer(() => jsonAnchor.dispatchEvent(new MouseEvent("click")));
        if (modelArtifacts.weightData != null) {
          const weightDataAnchor = this.weightDataAnchor == null ? document.createElement("a") : this.weightDataAnchor;
          weightDataAnchor.download = this.weightDataFileName;
          weightDataAnchor.href = weightsURL;
          await defer(() => weightDataAnchor.dispatchEvent(new MouseEvent("click")));
        }
        return {modelArtifactsInfo: getModelArtifactsInfoForJSON(modelArtifacts)};
      }
    }
  }
  BrowserDownloads.URL_SCHEME = "downloads://";
  class BrowserFiles {
    constructor(files) {
      if (files == null || files.length < 1) {
        throw new Error(`When calling browserFiles, at least 1 file is required, but received ${files}`);
      }
      this.files = files;
    }
    async load() {
      const jsonFile = this.files[0];
      const weightFiles = this.files.slice(1);
      return new Promise((resolve, reject) => {
        const jsonReader = new FileReader();
        jsonReader.onload = (event) => {
          const modelJSON = JSON.parse(event.target.result);
          const modelTopology = modelJSON.modelTopology;
          if (modelTopology == null) {
            reject(new Error(`modelTopology field is missing from file ${jsonFile.name}`));
            return;
          }
          if (weightFiles.length === 0) {
            resolve({modelTopology});
          }
          const weightsManifest = modelJSON.weightsManifest;
          if (weightsManifest == null) {
            reject(new Error(`weightManifest field is missing from file ${jsonFile.name}`));
            return;
          }
          let pathToFile;
          try {
            pathToFile = this.checkManifestAndWeightFiles(weightsManifest, weightFiles);
          } catch (err) {
            reject(err);
            return;
          }
          const weightSpecs = [];
          const paths = [];
          const perFileBuffers = [];
          weightsManifest.forEach((weightsGroup) => {
            weightsGroup.paths.forEach((path) => {
              paths.push(path);
              perFileBuffers.push(null);
            });
            weightSpecs.push(...weightsGroup.weights);
          });
          weightsManifest.forEach((weightsGroup) => {
            weightsGroup.paths.forEach((path) => {
              const weightFileReader = new FileReader();
              weightFileReader.onload = (event2) => {
                const weightData = event2.target.result;
                const index = paths.indexOf(path);
                perFileBuffers[index] = weightData;
                if (perFileBuffers.indexOf(null) === -1) {
                  resolve({
                    modelTopology,
                    weightSpecs,
                    weightData: concatenateArrayBuffers(perFileBuffers),
                    format: modelJSON.format,
                    generatedBy: modelJSON.generatedBy,
                    convertedBy: modelJSON.convertedBy,
                    userDefinedMetadata: modelJSON.userDefinedMetadata
                  });
                }
              };
              weightFileReader.onerror = (error) => reject(`Failed to weights data from file of path '${path}'.`);
              weightFileReader.readAsArrayBuffer(pathToFile[path]);
            });
          });
        };
        jsonReader.onerror = (error) => reject(`Failed to read model topology and weights manifest JSON from file '${jsonFile.name}'. BrowserFiles supports loading Keras-style tf.Model artifacts only.`);
        jsonReader.readAsText(jsonFile);
      });
    }
    checkManifestAndWeightFiles(manifest, files) {
      const basenames = [];
      const fileNames = files.map((file) => basename(file.name));
      const pathToFile = {};
      for (const group of manifest) {
        group.paths.forEach((path) => {
          const pathBasename = basename(path);
          if (basenames.indexOf(pathBasename) !== -1) {
            throw new Error(`Duplicate file basename found in weights manifest: '${pathBasename}'`);
          }
          basenames.push(pathBasename);
          if (fileNames.indexOf(pathBasename) === -1) {
            throw new Error(`Weight file with basename '${pathBasename}' is not provided.`);
          } else {
            pathToFile[path] = files[fileNames.indexOf(pathBasename)];
          }
        });
      }
      if (basenames.length !== files.length) {
        throw new Error(`Mismatch in the number of files in weights manifest (${basenames.length}) and the number of weight files provided (${files.length}).`);
      }
      return pathToFile;
    }
  }
  const browserDownloadsRouter = (url) => {
    if (!env().getBool("IS_BROWSER")) {
      return null;
    } else {
      if (!Array.isArray(url) && url.startsWith(BrowserDownloads.URL_SCHEME)) {
        return browserDownloads(url.slice(BrowserDownloads.URL_SCHEME.length));
      } else {
        return null;
      }
    }
  };
  IORouterRegistry.registerSaveRouter(browserDownloadsRouter);
  function browserDownloads(fileNamePrefix = "model") {
    return new BrowserDownloads(fileNamePrefix);
  }
  function browserFiles(files) {
    return new BrowserFiles(files);
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/progress.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function monitorPromisesProgress(promises, onProgress, startFraction, endFraction) {
    checkPromises(promises);
    startFraction = startFraction == null ? 0 : startFraction;
    endFraction = endFraction == null ? 1 : endFraction;
    checkFraction(startFraction, endFraction);
    let resolvedPromise = 0;
    const registerMonitor = (promise) => {
      promise.then((value) => {
        const fraction = startFraction + ++resolvedPromise / promises.length * (endFraction - startFraction);
        onProgress(fraction);
        return value;
      });
      return promise;
    };
    function checkPromises(promises2) {
      assert(promises2 != null && Array.isArray(promises2) && promises2.length > 0, () => "promises must be a none empty array");
    }
    function checkFraction(startFraction2, endFraction2) {
      assert(startFraction2 >= 0 && startFraction2 <= 1, () => `Progress fraction must be in range [0, 1], but got startFraction ${startFraction2}`);
      assert(endFraction2 >= 0 && endFraction2 <= 1, () => `Progress fraction must be in range [0, 1], but got endFraction ${endFraction2}`);
      assert(endFraction2 >= startFraction2, () => `startFraction must be no more than endFraction, but got startFraction ${startFraction2} and endFraction ${endFraction2}`);
    }
    return Promise.all(promises.map(registerMonitor));
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/weights_loader.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function loadWeightsAsArrayBuffer(fetchURLs, loadOptions) {
    if (loadOptions == null) {
      loadOptions = {};
    }
    const fetchFunc = loadOptions.fetchFunc == null ? env().platform.fetch : loadOptions.fetchFunc;
    const requests = fetchURLs.map((fetchURL) => fetchFunc(fetchURL, loadOptions.requestInit, {isBinary: true}));
    const fetchStartFraction = 0;
    const fetchEndFraction = 0.5;
    const responses = loadOptions.onProgress == null ? await Promise.all(requests) : await monitorPromisesProgress(requests, loadOptions.onProgress, fetchStartFraction, fetchEndFraction);
    const bufferPromises = responses.map((response) => response.arrayBuffer());
    const bufferStartFraction = 0.5;
    const bufferEndFraction = 1;
    const buffers = loadOptions.onProgress == null ? await Promise.all(bufferPromises) : await monitorPromisesProgress(bufferPromises, loadOptions.onProgress, bufferStartFraction, bufferEndFraction);
    return buffers;
  }
  async function loadWeights(manifest, filePathPrefix = "", weightNames, requestInit) {
    const fetchWeights = (fetchUrls) => loadWeightsAsArrayBuffer(fetchUrls, {requestInit});
    const loadWeights2 = weightsLoaderFactory(fetchWeights);
    return loadWeights2(manifest, filePathPrefix, weightNames);
  }
  function weightsLoaderFactory(fetchWeightsFunction) {
    return async (manifest, filePathPrefix = "", weightNames) => {
      const groupIndicesToFetchMap = manifest.map(() => false);
      const groupWeightsToFetch = {};
      const weightsFound = weightNames != null ? weightNames.map(() => false) : [];
      const allManifestWeightNames = [];
      manifest.forEach((manifestGroupConfig, groupIndex) => {
        let groupOffset = 0;
        manifestGroupConfig.weights.forEach((weightsEntry) => {
          const rawDtype = "quantization" in weightsEntry ? weightsEntry.quantization.dtype : weightsEntry.dtype;
          const weightsBytes = DTYPE_VALUE_SIZE_MAP[rawDtype] * sizeFromShape(weightsEntry.shape);
          const enqueueWeightsForFetchingFn = () => {
            groupIndicesToFetchMap[groupIndex] = true;
            if (groupWeightsToFetch[groupIndex] == null) {
              groupWeightsToFetch[groupIndex] = [];
            }
            groupWeightsToFetch[groupIndex].push({
              manifestEntry: weightsEntry,
              groupOffset,
              sizeBytes: weightsBytes
            });
          };
          if (weightNames != null) {
            weightNames.forEach((weightName, weightIndex) => {
              if (weightName === weightsEntry.name) {
                enqueueWeightsForFetchingFn();
                weightsFound[weightIndex] = true;
              }
            });
          } else {
            enqueueWeightsForFetchingFn();
          }
          allManifestWeightNames.push(weightsEntry.name);
          groupOffset += weightsBytes;
        });
      });
      if (!weightsFound.every((found) => found)) {
        const weightsNotFound = weightNames.filter((_, i) => !weightsFound[i]);
        throw new Error(`Could not find weights in manifest with names: ${weightsNotFound.join(", ")}. 
Manifest JSON has weights with names: ${allManifestWeightNames.join(", ")}.`);
      }
      const groupIndicesToFetch = groupIndicesToFetchMap.reduce((accumulator, shouldFetch, i) => {
        if (shouldFetch) {
          accumulator.push(i);
        }
        return accumulator;
      }, []);
      const fetchUrls = [];
      groupIndicesToFetch.forEach((i) => {
        manifest[i].paths.forEach((filepath) => {
          const fetchUrl = filePathPrefix + (!filePathPrefix.endsWith("/") ? "/" : "") + filepath;
          fetchUrls.push(fetchUrl);
        });
      });
      const buffers = await fetchWeightsFunction(fetchUrls);
      const weightsTensorMap = {};
      let bufferIndexOffset = 0;
      groupIndicesToFetch.forEach((i) => {
        const numBuffers = manifest[i].paths.length;
        let groupBytes = 0;
        for (let i2 = 0; i2 < numBuffers; i2++) {
          groupBytes += buffers[bufferIndexOffset + i2].byteLength;
        }
        const groupBuffer = new ArrayBuffer(groupBytes);
        const groupByteBuffer = new Uint8Array(groupBuffer);
        let groupBufferOffset = 0;
        for (let i2 = 0; i2 < numBuffers; i2++) {
          const buffer11 = new Uint8Array(buffers[bufferIndexOffset + i2]);
          groupByteBuffer.set(buffer11, groupBufferOffset);
          groupBufferOffset += buffer11.byteLength;
        }
        const weightsEntries = groupWeightsToFetch[i];
        weightsEntries.forEach((weightsEntry) => {
          const byteBuffer = groupBuffer.slice(weightsEntry.groupOffset, weightsEntry.groupOffset + weightsEntry.sizeBytes);
          const nameToTensorMap = decodeWeights(byteBuffer, [weightsEntry.manifestEntry]);
          for (const name in nameToTensorMap) {
            weightsTensorMap[name] = nameToTensorMap[name];
          }
        });
        bufferIndexOffset += numBuffers;
      });
      return weightsTensorMap;
    };
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/http.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const OCTET_STREAM_MIME_TYPE = "application/octet-stream";
  const JSON_TYPE = "application/json";
  class HTTPRequest {
    constructor(path, loadOptions) {
      this.DEFAULT_METHOD = "POST";
      if (loadOptions == null) {
        loadOptions = {};
      }
      this.weightPathPrefix = loadOptions.weightPathPrefix;
      this.onProgress = loadOptions.onProgress;
      this.weightUrlConverter = loadOptions.weightUrlConverter;
      if (loadOptions.fetchFunc != null) {
        assert(typeof loadOptions.fetchFunc === "function", () => "Must pass a function that matches the signature of `fetch` (see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)");
        this.fetch = loadOptions.fetchFunc;
      } else {
        this.fetch = env().platform.fetch;
      }
      assert(path != null && path.length > 0, () => "URL path for http must not be null, undefined or empty.");
      if (Array.isArray(path)) {
        assert(path.length === 2, () => `URL paths for http must have a length of 2, (actual length is ${path.length}).`);
      }
      this.path = path;
      if (loadOptions.requestInit != null && loadOptions.requestInit.body != null) {
        throw new Error("requestInit is expected to have no pre-existing body, but has one.");
      }
      this.requestInit = loadOptions.requestInit || {};
    }
    async save(modelArtifacts) {
      if (modelArtifacts.modelTopology instanceof ArrayBuffer) {
        throw new Error("BrowserHTTPRequest.save() does not support saving model topology in binary formats yet.");
      }
      const init = Object.assign({method: this.DEFAULT_METHOD}, this.requestInit);
      init.body = new FormData();
      const weightsManifest = [{
        paths: ["./model.weights.bin"],
        weights: modelArtifacts.weightSpecs
      }];
      const modelTopologyAndWeightManifest = {
        modelTopology: modelArtifacts.modelTopology,
        format: modelArtifacts.format,
        generatedBy: modelArtifacts.generatedBy,
        convertedBy: modelArtifacts.convertedBy,
        userDefinedMetadata: modelArtifacts.userDefinedMetadata,
        weightsManifest
      };
      init.body.append("model.json", new Blob([JSON.stringify(modelTopologyAndWeightManifest)], {type: JSON_TYPE}), "model.json");
      if (modelArtifacts.weightData != null) {
        init.body.append("model.weights.bin", new Blob([modelArtifacts.weightData], {type: OCTET_STREAM_MIME_TYPE}), "model.weights.bin");
      }
      const response = await this.fetch(this.path, init);
      if (response.ok) {
        return {
          modelArtifactsInfo: getModelArtifactsInfoForJSON(modelArtifacts),
          responses: [response]
        };
      } else {
        throw new Error(`BrowserHTTPRequest.save() failed due to HTTP response status ${response.status}.`);
      }
    }
    async load() {
      const modelConfigRequest = await this.fetch(this.path, this.requestInit);
      if (!modelConfigRequest.ok) {
        throw new Error(`Request to ${this.path} failed with status code ${modelConfigRequest.status}. Please verify this URL points to the model JSON of the model to load.`);
      }
      let modelConfig;
      try {
        modelConfig = await modelConfigRequest.json();
      } catch (e) {
        let message = `Failed to parse model JSON of response from ${this.path}.`;
        if (this.path.endsWith(".pb")) {
          message += " Your path contains a .pb file extension. Support for .pb models have been removed in TensorFlow.js 1.0 in favor of .json models. You can re-convert your Python TensorFlow model using the TensorFlow.js 1.0 conversion scripts or you can convert your.pb models with the 'pb2json'NPM script in the tensorflow/tfjs-converter repository.";
        } else {
          message += " Please make sure the server is serving valid JSON for this request.";
        }
        throw new Error(message);
      }
      const modelTopology = modelConfig.modelTopology;
      const weightsManifest = modelConfig.weightsManifest;
      const generatedBy = modelConfig.generatedBy;
      const convertedBy = modelConfig.convertedBy;
      const format = modelConfig.format;
      const userDefinedMetadata = modelConfig.userDefinedMetadata;
      if (modelTopology == null && weightsManifest == null) {
        throw new Error(`The JSON from HTTP path ${this.path} contains neither model topology or manifest for weights.`);
      }
      let weightSpecs;
      let weightData;
      if (weightsManifest != null) {
        const results = await this.loadWeights(weightsManifest);
        [weightSpecs, weightData] = results;
      }
      return {
        modelTopology,
        weightSpecs,
        weightData,
        userDefinedMetadata,
        generatedBy,
        convertedBy,
        format
      };
    }
    async loadWeights(weightsManifest) {
      const weightPath = Array.isArray(this.path) ? this.path[1] : this.path;
      const [prefix, suffix] = parseUrl(weightPath);
      const pathPrefix = this.weightPathPrefix || prefix;
      const weightSpecs = [];
      for (const entry of weightsManifest) {
        weightSpecs.push(...entry.weights);
      }
      const fetchURLs = [];
      const urlPromises = [];
      for (const weightsGroup of weightsManifest) {
        for (const path of weightsGroup.paths) {
          if (this.weightUrlConverter != null) {
            urlPromises.push(this.weightUrlConverter(path));
          } else {
            fetchURLs.push(pathPrefix + path + suffix);
          }
        }
      }
      if (this.weightUrlConverter) {
        fetchURLs.push(...await Promise.all(urlPromises));
      }
      const buffers = await loadWeightsAsArrayBuffer(fetchURLs, {
        requestInit: this.requestInit,
        fetchFunc: this.fetch,
        onProgress: this.onProgress
      });
      return [weightSpecs, concatenateArrayBuffers(buffers)];
    }
  }
  HTTPRequest.URL_SCHEME_REGEX = /^https?:\/\//;
  function parseUrl(url) {
    const lastSlash = url.lastIndexOf("/");
    const lastSearchParam = url.lastIndexOf("?");
    const prefix = url.substring(0, lastSlash);
    const suffix = lastSearchParam > lastSlash ? url.substring(lastSearchParam) : "";
    return [prefix + "/", suffix];
  }
  function isHTTPScheme(url) {
    return url.match(HTTPRequest.URL_SCHEME_REGEX) != null;
  }
  const httpRouter = (url, loadOptions) => {
    if (typeof fetch === "undefined" && (loadOptions == null || loadOptions.fetchFunc == null)) {
      return null;
    } else {
      let isHTTP = true;
      if (Array.isArray(url)) {
        isHTTP = url.every((urlItem) => isHTTPScheme(urlItem));
      } else {
        isHTTP = isHTTPScheme(url);
      }
      if (isHTTP) {
        return http(url, loadOptions);
      }
    }
    return null;
  };
  IORouterRegistry.registerSaveRouter(httpRouter);
  IORouterRegistry.registerLoadRouter(httpRouter);
  function http(path, loadOptions) {
    return new HTTPRequest(path, loadOptions);
  }
  function browserHTTPRequest(path, loadOptions) {
    return http(path, loadOptions);
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/passthrough.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class PassthroughLoader {
    constructor(modelArtifacts) {
      this.modelArtifacts = modelArtifacts;
    }
    async load() {
      return this.modelArtifacts;
    }
  }
  class PassthroughSaver {
    constructor(saveHandler) {
      this.saveHandler = saveHandler;
    }
    async save(modelArtifacts) {
      return this.saveHandler(modelArtifacts);
    }
  }
  function fromMemory(modelArtifacts, weightSpecs, weightData, trainingConfig) {
    if (arguments.length === 1) {
      const isModelArtifacts = modelArtifacts.modelTopology != null || modelArtifacts.weightSpecs != null;
      if (isModelArtifacts) {
        return new PassthroughLoader(modelArtifacts);
      } else {
        console.warn("Please call tf.io.fromMemory() with only one argument. The argument should be of type ModelArtifacts. The multi-argument signature of tf.io.fromMemory() has been deprecated and will be removed in a future release.");
        return new PassthroughLoader({modelTopology: modelArtifacts});
      }
    } else {
      console.warn("Please call tf.io.fromMemory() with only one argument. The argument should be of type ModelArtifacts. The multi-argument signature of tf.io.fromMemory() has been deprecated and will be removed in a future release.");
      return new PassthroughLoader({
        modelTopology: modelArtifacts,
        weightSpecs,
        weightData,
        trainingConfig
      });
    }
  }
  function withSaveHandler(saveHandler) {
    return new PassthroughSaver(saveHandler);
  }

  // node_modules/@tensorflow/tfjs-core/dist/io/io.js
  const io_exports = {};
  __export(io_exports, {
    browserFiles: () => browserFiles,
    browserHTTPRequest: () => browserHTTPRequest,
    concatenateArrayBuffers: () => concatenateArrayBuffers,
    copyModel: () => copyModel,
    decodeWeights: () => decodeWeights,
    encodeWeights: () => encodeWeights,
    fromMemory: () => fromMemory,
    getLoadHandlers: () => getLoadHandlers,
    getModelArtifactsInfoForJSON: () => getModelArtifactsInfoForJSON,
    getSaveHandlers: () => getSaveHandlers,
    http: () => http,
    isHTTPScheme: () => isHTTPScheme,
    listModels: () => listModels,
    loadWeights: () => loadWeights,
    moveModel: () => moveModel,
    registerLoadRouter: () => registerLoadRouter,
    registerSaveRouter: () => registerSaveRouter,
    removeModel: () => removeModel,
    weightsLoaderFactory: () => weightsLoaderFactory,
    withSaveHandler: () => withSaveHandler
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */

  // node_modules/@tensorflow/tfjs-core/dist/ops/reshape.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reshape_(x, shape) {
    const $x = convertToTensor(x, "x", "reshape", null);
    shape = inferFromImplicitShape(shape, $x.size);
    assert($x.size === sizeFromShape(shape), () => "new shape and old shape must have the same number of elements.");
    const inputs = {x: $x};
    const attrs = {shape};
    const forward = (backend2, save) => {
      save([$x]);
      return backend2.reshape($x, shape);
    };
    return ENGINE.runKernelFunc(forward, inputs, null, Reshape, attrs);
  }
  const reshape = op({reshape_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/mat_mul.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function matMul_(a, b, transposeA = false, transposeB = false) {
    let $a = convertToTensor(a, "a", "matMul");
    let $b = convertToTensor(b, "b", "matMul");
    [$a, $b] = makeTypesMatch($a, $b);
    assert($a.rank >= 2 && $b.rank >= 2 && $a.rank === $b.rank, () => `Error in matMul: inputs must have the same rank of at least 2, got ranks ${$a.rank} and ${$b.rank}.`);
    const innerShapeA = transposeA ? $a.shape[$a.rank - 2] : $a.shape[$a.rank - 1];
    const innerShapeB = transposeB ? $b.shape[$b.rank - 1] : $b.shape[$b.rank - 2];
    const outerShapeA = transposeA ? $a.shape[$a.rank - 1] : $a.shape[$a.rank - 2];
    const outerShapeB = transposeB ? $b.shape[$b.rank - 2] : $b.shape[$b.rank - 1];
    const outerDimsA = $a.shape.slice(0, -2);
    const outerDimsB = $b.shape.slice(0, -2);
    const batchDimA = sizeFromShape(outerDimsA);
    const batchDimB = sizeFromShape(outerDimsB);
    assert(arraysEqual(outerDimsA, outerDimsB), () => `Error in matMul: outer dimensions (${outerDimsA}) and (${outerDimsB}) of Tensors with shapes ${$a.shape} and ${$b.shape} must match.`);
    assert(innerShapeA === innerShapeB, () => `Error in matMul: inner shapes (${innerShapeA}) and (${innerShapeB}) of Tensors with shapes ${$a.shape} and ${$b.shape} and transposeA=${transposeA} and transposeB=${transposeB} must match.`);
    const outShape = $a.shape.slice(0, -2).concat([outerShapeA, outerShapeB]);
    const a3D = transposeA ? reshape($a, [batchDimA, innerShapeA, outerShapeA]) : reshape($a, [batchDimA, outerShapeA, innerShapeA]);
    const b3D = transposeB ? reshape($b, [batchDimB, outerShapeB, innerShapeB]) : reshape($b, [batchDimB, innerShapeB, outerShapeB]);
    const forward = (backend2, save) => {
      save([a3D, b3D]);
      return backend2.batchMatMul(a3D, b3D, transposeA, transposeB);
    };
    const inputs = {a: a3D, b: b3D};
    const attrs = {transposeA, transposeB};
    const res = ENGINE.runKernelFunc(forward, inputs, null, BatchMatMul, attrs);
    return reshape(res, outShape);
  }
  const matMul = op({matMul_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/one_hot.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function oneHot_(indices, depth, onValue = 1, offValue = 0) {
    if (depth < 2) {
      throw new Error(`Error in oneHot: depth must be >=2, but it is ${depth}`);
    }
    const $indices = convertToTensor(indices, "indices", "oneHot", "int32");
    const outShape = [...$indices.shape, depth];
    const forward = (backend2, save) => {
      save([$indices]);
      return reshape(backend2.oneHot(reshape($indices, [$indices.size]), depth, onValue, offValue), outShape);
    };
    const inputs = {indices: $indices};
    const attrs = {depth, onValue, offValue};
    return ENGINE.runKernelFunc(forward, inputs, null, OneHot, attrs);
  }
  const oneHot = op({oneHot_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/transpose.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function transpose_(x, perm) {
    const $x = convertToTensor(x, "x", "transpose");
    if (perm == null) {
      perm = $x.shape.map((s, i) => i).reverse();
    }
    assert($x.rank === perm.length, () => `Error in transpose: rank of input ${$x.rank} must match length of perm ${perm}.`);
    perm.forEach((axis) => {
      assert(axis >= 0 && axis < $x.rank, () => `All entries in 'perm' must be between 0 and ${$x.rank - 1} but got ${perm}`);
    });
    if ($x.rank <= 1) {
      return $x.clone();
    }
    const inputs = {x: $x};
    const attrs = {perm};
    return ENGINE.runKernelFunc((backend2) => backend2.transpose($x, perm), inputs, null, Transpose, attrs);
  }
  const transpose = op({transpose_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/confusion_matrix.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function confusionMatrix_(labels, predictions, numClasses) {
    const $labels = convertToTensor(labels, "labels", "confusionMatrix");
    const $predictions = convertToTensor(predictions, "predictions", "confusionMatrix");
    assert(numClasses == null || numClasses > 0 && Number.isInteger(numClasses), () => `If provided, numClasses must be a positive integer, but got ${numClasses}`);
    assert($labels.rank === 1, () => `Expected the rank of labels to be 1, but got ${$labels.rank}`);
    assert($predictions.rank === 1, () => `Expected the rank of predictions to be 1, but got ${$predictions.rank}`);
    assert($labels.shape[0] === $predictions.shape[0], () => `Mismatch in the number of examples: ${$labels.shape[0]} vs. ${$predictions.shape[0]}. Labels and predictions should have the same number of elements.`);
    assert(numClasses > 0 && Number.isInteger(numClasses), () => `numClasses is required to be a positive integer, but got ${numClasses}`);
    const oneHotLabels = oneHot(cast($labels, "int32"), numClasses);
    const oneHotPredictions = oneHot(cast($predictions, "int32"), numClasses);
    const oneHotLabelsT = transpose(oneHotLabels);
    return cast(matMul(oneHotLabelsT, oneHotPredictions), "int32");
  }
  const confusionMatrix = op({confusionMatrix_});

  // node_modules/@tensorflow/tfjs-core/dist/math.js
  const math_exports = {};
  __export(math_exports, {
    confusionMatrix: () => confusionMatrix
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor3d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor3d(values, shape, dtype) {
    assertNonNull(values);
    if (shape != null && shape.length !== 3) {
      throw new Error("tensor3d() requires shape to have three numbers");
    }
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 3 && inferredShape.length !== 1) {
      throw new Error("tensor3d() requires values to be number[][][] or flat/TypedArray");
    }
    if (inferredShape.length === 1 && shape == null) {
      throw new Error("tensor3d() requires shape to be provided when `values` are a flat array");
    }
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/browser.js
  const browser_exports = {};
  __export(browser_exports, {
    fromPixels: () => fromPixels,
    toPixels: () => toPixels
  });
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  let fromPixels2DContext;
  function fromPixels_(pixels, numChannels = 3) {
    if (numChannels > 4) {
      throw new Error("Cannot construct Tensor with more than 4 channels from pixels.");
    }
    if (pixels == null) {
      throw new Error("pixels passed to tf.browser.fromPixels() can not be null");
    }
    let isPixelData = false;
    let isImageData = false;
    let isVideo = false;
    let isImage = false;
    let isCanvasLike = false;
    if (pixels.data instanceof Uint8Array) {
      isPixelData = true;
    } else if (typeof ImageData !== "undefined" && pixels instanceof ImageData) {
      isImageData = true;
    } else if (typeof HTMLVideoElement !== "undefined" && pixels instanceof HTMLVideoElement) {
      isVideo = true;
    } else if (typeof HTMLImageElement !== "undefined" && pixels instanceof HTMLImageElement) {
      isImage = true;
    } else if (pixels.getContext != null) {
      isCanvasLike = true;
    } else {
      throw new Error(`pixels passed to tf.browser.fromPixels() must be either an HTMLVideoElement, HTMLImageElement, HTMLCanvasElement, ImageData in browser, or OffscreenCanvas, ImageData in webworker or {data: Uint32Array, width: number, height: number}, but was ${pixels.constructor.name}`);
    }
    if (isVideo) {
      const HAVE_CURRENT_DATA_READY_STATE = 2;
      if (isVideo && pixels.readyState < HAVE_CURRENT_DATA_READY_STATE) {
        throw new Error("The video element has not loaded data yet. Please wait for `loadeddata` event on the <video> element.");
      }
    }
    const kernel = getKernel(FromPixels, ENGINE.backendName);
    if (kernel != null) {
      const inputs = {pixels};
      const attrs = {numChannels};
      return ENGINE.runKernel(FromPixels, inputs, attrs);
    }
    const [width, height] = isVideo ? [
      pixels.videoWidth,
      pixels.videoHeight
    ] : [pixels.width, pixels.height];
    let vals;
    if (isCanvasLike) {
      vals = pixels.getContext("2d").getImageData(0, 0, width, height).data;
    } else if (isImageData || isPixelData) {
      vals = pixels.data;
    } else if (isImage || isVideo) {
      if (fromPixels2DContext == null) {
        fromPixels2DContext = document.createElement("canvas").getContext("2d");
      }
      fromPixels2DContext.canvas.width = width;
      fromPixels2DContext.canvas.height = height;
      fromPixels2DContext.drawImage(pixels, 0, 0, width, height);
      vals = fromPixels2DContext.getImageData(0, 0, width, height).data;
    }
    let values;
    if (numChannels === 4) {
      values = new Int32Array(vals);
    } else {
      const numPixels = width * height;
      values = new Int32Array(numPixels * numChannels);
      for (let i = 0; i < numPixels; i++) {
        for (let channel = 0; channel < numChannels; ++channel) {
          values[i * numChannels + channel] = vals[i * 4 + channel];
        }
      }
    }
    const outShape = [height, width, numChannels];
    return tensor3d(values, outShape, "int32");
  }
  async function toPixels(img, canvas) {
    let $img = convertToTensor(img, "img", "toPixels");
    if (!(img instanceof Tensor)) {
      const originalImgTensor = $img;
      $img = cast(originalImgTensor, "int32");
      originalImgTensor.dispose();
    }
    if ($img.rank !== 2 && $img.rank !== 3) {
      throw new Error(`toPixels only supports rank 2 or 3 tensors, got rank ${$img.rank}.`);
    }
    const [height, width] = $img.shape.slice(0, 2);
    const depth = $img.rank === 2 ? 1 : $img.shape[2];
    if (depth > 4 || depth === 2) {
      throw new Error(`toPixels only supports depth of size 1, 3 or 4 but got ${depth}`);
    }
    if ($img.dtype !== "float32" && $img.dtype !== "int32") {
      throw new Error(`Unsupported type for toPixels: ${$img.dtype}. Please use float32 or int32 tensors.`);
    }
    const data = await $img.data();
    const multiplier = $img.dtype === "float32" ? 255 : 1;
    const bytes = new Uint8ClampedArray(width * height * 4);
    for (let i = 0; i < height * width; ++i) {
      const rgba = [0, 0, 0, 255];
      for (let d = 0; d < depth; d++) {
        const value = data[i * depth + d];
        if ($img.dtype === "float32") {
          if (value < 0 || value > 1) {
            throw new Error(`Tensor values for a float32 Tensor must be in the range [0 - 1] but encountered ${value}.`);
          }
        } else if ($img.dtype === "int32") {
          if (value < 0 || value > 255) {
            throw new Error(`Tensor values for a int32 Tensor must be in the range [0 - 255] but encountered ${value}.`);
          }
        }
        if (depth === 1) {
          rgba[0] = value * multiplier;
          rgba[1] = value * multiplier;
          rgba[2] = value * multiplier;
        } else {
          rgba[d] = value * multiplier;
        }
      }
      const j = i * 4;
      bytes[j + 0] = Math.round(rgba[0]);
      bytes[j + 1] = Math.round(rgba[1]);
      bytes[j + 2] = Math.round(rgba[2]);
      bytes[j + 3] = Math.round(rgba[3]);
    }
    if (canvas != null) {
      canvas.width = width;
      canvas.height = height;
      const ctx = canvas.getContext("2d");
      const imageData = new ImageData(bytes, width, height);
      ctx.putImageData(imageData, 0, 0);
    }
    if ($img !== img) {
      $img.dispose();
    }
    return bytes;
  }
  const fromPixels = op({fromPixels_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/gather_nd_util.js
  const gather_nd_util_exports = {};
  __export(gather_nd_util_exports, {
    prepareAndValidate: () => prepareAndValidate
  });
  function prepareAndValidate(tensor17, indices) {
    if (tensor17.rank < 1) {
      throw new Error(`tf.gatherND() expects the input to be rank 1 or higher, but the rank was ${tensor17.rank}.`);
    }
    if (indices.rank < 1) {
      throw new Error(`tf.gatherND() expects the indices to be rank 1 or higher, but the rank was ${indices.rank}.`);
    }
    if (indices.dtype !== "int32") {
      throw new Error(`tf.gatherND() expects the indices to be int32 type, but the dtype was ${indices.dtype}.`);
    }
    if (indices.shape[indices.rank - 1] > tensor17.rank) {
      throw new Error(`index innermost dimension length must be <= tensor rank; saw: ${indices.shape[indices.rank - 1]} vs. ${tensor17.rank}`);
    }
    if (tensor17.size === 0) {
      throw new Error(`Requested more than 0 entries, but input is empty. Input shape: ${tensor17.shape}.`);
    }
    const indicesShape = indices.shape;
    const sliceRank = indicesShape[indicesShape.length - 1];
    let nResult = 1;
    for (let i = 0; i < indicesShape.length - 1; ++i) {
      nResult *= indicesShape[i];
    }
    const inputShape = tensor17.shape;
    const resultShape = indicesShape.slice();
    resultShape.pop();
    let sliceSize = 1;
    for (let i = sliceRank; i < tensor17.rank; ++i) {
      sliceSize *= inputShape[i];
      resultShape.push(inputShape[i]);
    }
    const strides = [
      ...computeStrides(tensor17.shape).map((stride) => stride / sliceSize),
      1
    ].slice(0, sliceRank);
    return [resultShape, nResult, sliceSize, strides];
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/scatter_nd_util.js
  const scatter_nd_util_exports = {};
  __export(scatter_nd_util_exports, {
    calculateShapes: () => calculateShapes,
    validateInput: () => validateInput,
    validateUpdateShape: () => validateUpdateShape
  });
  function validateUpdateShape(shape, indices, updates) {
    const sliceDim = indices.rank > 1 ? indices.shape[indices.rank - 1] : 1;
    const batchDim = indices.rank > 1 ? indices.rank - 1 : 1;
    const shapeError = `Must have updates.shape = indices.shape[:batchDim] + shape[sliceDim:], got updates.shape: ${updates.shape}, indices.shape: ${indices.shape}, shape: ${shape}, sliceDim: ${sliceDim}, and batchDim: ${batchDim}.`;
    if (updates.rank < batchDim) {
      throw new Error(shapeError + ` update.rank < ${batchDim}. `);
    }
    if (shape.length < sliceDim + (updates.rank - batchDim)) {
      throw new Error(shapeError + ` Output shape length < ${sliceDim + (updates.rank - batchDim)}`);
    }
    if (updates.rank !== batchDim + shape.length - sliceDim) {
      throw new Error(shapeError + ` update.rank != ${batchDim + shape.length - sliceDim}`);
    }
    for (let d = 0; d < batchDim; ++d) {
      if (updates.shape[d] !== indices.shape[d]) {
        throw new Error(shapeError + ` updates.shape[${d}] (${updates.shape[d]}) != indices.shape[${d}] (${indices.shape[d]}).`);
      }
    }
    for (let d = 0; d < updates.rank - batchDim; ++d) {
      if (updates.shape[d + batchDim] !== shape[d + sliceDim]) {
        throw new Error(shapeError + ` updates.shape[${d + batchDim}] (${updates.shape[d + batchDim]}) != shape[${d + batchDim}] (${shape[d + batchDim]})`);
      }
    }
  }
  function validateInput(updates, indices, shape) {
    if (indices.rank < 1) {
      throw new Error(`tf.scatterND() expects the indices to be rank 1 or higher, but the rank was ${indices.rank}.`);
    }
    if (updates.rank < 1) {
      throw new Error(`tf.scatterND() expects the updates to be rank 1 or higher, but the rank was ${updates.rank}.`);
    }
    if (indices.dtype !== "int32") {
      throw new Error(`The dtype of 'indices' should be int32, but got dtype: ${indices.dtype}`);
    }
    if (shape.length < 1) {
      throw new Error(`Output rank must be greater or equal to 1, but got shape: ${shape}`);
    }
    if (shape.length === 0) {
      if (indices.size === 0) {
        throw new Error(`Indices specified for empty output. indices shape: ${indices.shape}`);
      }
      if (updates.size === 0) {
        throw new Error(`Updates specified for empty output. updates shape: ${updates.shape}`);
      }
    }
    validateUpdateShape(shape, indices, updates);
  }
  function calculateShapes(updates, indices, shape) {
    const indicesRank = indices.shape.length;
    const sliceRank = indicesRank > 1 ? indices.shape[indicesRank - 1] : 1;
    const totalNd = shape.length;
    let sliceSize = 1;
    for (let i = sliceRank; i < totalNd; ++i) {
      sliceSize *= shape[i];
    }
    const safeSliceDim = sliceRank < 1 ? 1 : sliceRank;
    const numUpdates = sizeFromShape(indices.shape) / safeSliceDim;
    const strides = [...computeStrides(shape.slice(0, sliceRank)), 1];
    const outputSize = sizeFromShape(shape);
    return {sliceRank, numUpdates, sliceSize, strides, outputSize};
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice_util.js
  const slice_util_exports = {};
  __export(slice_util_exports, {
    assertParamsValid: () => assertParamsValid,
    computeFlatOffset: () => computeFlatOffset,
    computeOutShape: () => computeOutShape,
    getNormalizedAxes: () => getNormalizedAxes,
    isSliceContinous: () => isSliceContinous,
    maskToAxes: () => maskToAxes,
    parseSliceParams: () => parseSliceParams,
    startForAxis: () => startForAxis,
    startIndicesWithElidedDims: () => startIndicesWithElidedDims,
    stopForAxis: () => stopForAxis,
    stopIndicesWithElidedDims: () => stopIndicesWithElidedDims,
    stridesForAxis: () => stridesForAxis,
    stridesWithElidedDims: () => stridesWithElidedDims
  });
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function assertParamsValid(input, begin, size) {
    assert(input.rank === begin.length, () => `Error in slice${input.rank}D: Length of begin ${begin} must match the rank of the array (${input.rank}).`);
    assert(input.rank === size.length, () => `Error in slice${input.rank}D: Length of size ${size} must match the rank of the array (${input.rank}).`);
    for (let i = 0; i < input.rank; ++i) {
      assert(begin[i] + size[i] <= input.shape[i], () => `Error in slice${input.rank}D: begin[${i}] + size[${i}] (${begin[i] + size[i]}) would overflow input.shape[${i}] (${input.shape[i]})`);
    }
  }
  function maskToAxes(mask) {
    const axes = [];
    let axis = 0;
    while (mask > 0) {
      if (mask & 1) {
        axes.push(axis);
      }
      mask /= 2;
      axis++;
    }
    return axes;
  }
  function computeOutShape(begin, end, strides) {
    const size = [];
    for (let axis = 0; axis < begin.length; axis++) {
      size[axis] = Math.ceil((end[axis] - begin[axis]) / strides[axis]);
    }
    return size;
  }
  function stridesWithElidedDims(strides, ellipsisInsertionIndex, numElidedAxes, inputShape) {
    const newStrides = [...strides];
    for (let i = newStrides.length; i < inputShape.length; i++) {
      newStrides.push(1);
    }
    for (let i = 0; i < numElidedAxes; i++) {
      if (i === 0) {
        newStrides[ellipsisInsertionIndex] = 1;
      } else {
        newStrides.splice(ellipsisInsertionIndex, 0, 1);
        newStrides.pop();
      }
    }
    return newStrides;
  }
  function unnormalizeAxis(ellipsisInsertionIndex, numElidedAxes, normalizedAxis) {
    if (normalizedAxis <= ellipsisInsertionIndex) {
      return normalizedAxis;
    }
    return normalizedAxis - (numElidedAxes - 1);
  }
  function getElidedAxes(numElidedAxes, ellipsisInsertionIndex) {
    const elidedAxes = [];
    for (let i = 0; i < numElidedAxes; i++) {
      elidedAxes.push(ellipsisInsertionIndex + i);
    }
    return elidedAxes;
  }
  function getNormalizedAxes(inputShape, ellipsisAxes, numInterpolatedAxes, begin, end, strides, beginMask, endMask, ellipsisMask) {
    const inputRank = inputShape.length;
    let normalizedBegin = new Array(inputRank), normalizedEnd = new Array(inputRank), normalizedStrides = new Array(inputRank);
    if (ellipsisAxes.length && numInterpolatedAxes > 0) {
      const fullIndex = ellipsisAxes[0];
      const numElidedAxes = numInterpolatedAxes + 1;
      normalizedBegin = startIndicesWithElidedDims(beginMask, fullIndex, numElidedAxes, begin, inputShape);
      normalizedEnd = stopIndicesWithElidedDims(endMask, fullIndex, numElidedAxes, end, inputShape);
      normalizedStrides = stridesWithElidedDims(strides, fullIndex, numElidedAxes, inputShape);
    } else {
      for (let axis = 0; axis < inputRank; axis++) {
        normalizedBegin[axis] = startForAxis(beginMask, begin, strides, inputShape, axis, ellipsisMask);
        normalizedEnd[axis] = stopForAxis(endMask, end, strides, inputShape, axis, ellipsisMask);
        normalizedStrides[axis] = stridesForAxis(strides, axis, ellipsisMask);
      }
    }
    return {
      begin: normalizedBegin,
      end: normalizedEnd,
      strides: normalizedStrides
    };
  }
  function startIndicesWithElidedDims(beginMask, ellipsisInsertionIndex, numElidedAxes, originalBegin, inputShape) {
    const newIndices = [...inputShape];
    const elidedAxes = getElidedAxes(numElidedAxes, ellipsisInsertionIndex);
    for (let axis = 0; axis < newIndices.length; axis++) {
      if (elidedAxes.indexOf(axis) > -1) {
        newIndices[axis] = 0;
      } else {
        const originalAxis = unnormalizeAxis(ellipsisInsertionIndex, numElidedAxes, axis);
        let originalValue = originalBegin[originalAxis];
        if (beginMask & 1 << originalAxis) {
          originalValue = 0;
        }
        newIndices[axis] = originalValue;
      }
    }
    return newIndices;
  }
  function stopIndicesWithElidedDims(endMask, ellipsisInsertionIndex, numElidedAxes, originalEnd, inputShape) {
    const newIndices = [...inputShape];
    const elidedAxes = getElidedAxes(numElidedAxes, ellipsisInsertionIndex);
    for (let axis = 0; axis < newIndices.length; axis++) {
      if (elidedAxes.indexOf(axis) > -1) {
        newIndices[axis] = Number.MAX_SAFE_INTEGER;
      } else {
        const originalAxis = unnormalizeAxis(ellipsisInsertionIndex, numElidedAxes, axis);
        let originalValue = originalEnd[originalAxis];
        if (endMask & 1 << originalAxis) {
          originalValue = Number.MAX_SAFE_INTEGER;
        }
        newIndices[axis] = originalValue;
      }
    }
    for (let i = 0; i < newIndices.length; i++) {
      const axisSize = inputShape[i];
      if (newIndices[i] < 0) {
        newIndices[i] += axisSize;
      }
      newIndices[i] = clamp(0, newIndices[i], inputShape[i]);
    }
    return newIndices;
  }
  function stridesForAxis(strides, axis, ellipsisMask) {
    let stride = strides[axis];
    if (ellipsisMask & 1 << axis || stride == null) {
      stride = 1;
    }
    return stride;
  }
  function startForAxis(beginMask, startIndices, strides, inputShape, axis, ellipsisMask) {
    let start = startIndices[axis];
    const stride = strides[axis] || 1;
    if (beginMask & 1 << axis || ellipsisMask & 1 << axis || start == null) {
      if (stride > 0) {
        start = Number.MIN_SAFE_INTEGER;
      } else {
        start = Number.MAX_SAFE_INTEGER;
      }
    }
    const axisSize = inputShape[axis];
    if (start < 0) {
      start += axisSize;
    }
    start = clamp(0, start, axisSize - 1);
    return start;
  }
  function stopForAxis(endMask, stopIndices, strides, inputShape, axis, ellipsisMask) {
    let stop = stopIndices[axis];
    const stride = strides[axis] || 1;
    if (endMask & 1 << axis || ellipsisMask & 1 << axis || stop == null) {
      if (stride > 0) {
        stop = Number.MAX_SAFE_INTEGER;
      } else {
        stop = Number.MIN_SAFE_INTEGER;
      }
    }
    const axisSize = inputShape[axis];
    if (stop < 0) {
      stop += axisSize;
    }
    if (stride > 0) {
      stop = clamp(0, stop, axisSize);
    } else {
      stop = clamp(-1, stop, axisSize - 1);
    }
    return stop;
  }
  function isSliceContinous(shape, begin, size) {
    let firstNonOneAxis = size.length;
    for (let i = 0; i < size.length; i++) {
      if (size[i] > 1) {
        firstNonOneAxis = i;
        break;
      }
    }
    for (let i = firstNonOneAxis + 1; i < size.length; i++) {
      if (begin[i] > 0 || size[i] !== shape[i]) {
        return false;
      }
    }
    return true;
  }
  function computeFlatOffset(begin, strides) {
    let flatOffset = begin.length > 0 ? begin[begin.length - 1] : 1;
    for (let i = 0; i < begin.length - 1; i++) {
      flatOffset += begin[i] * strides[i];
    }
    return flatOffset;
  }
  function parseSliceParams(x, begin, size) {
    let begin_;
    if (typeof begin === "number") {
      begin_ = [begin, ...new Array(x.rank - 1).fill(0)];
    } else if (begin.length < x.rank) {
      begin_ = begin.concat(new Array(x.rank - begin.length).fill(0));
    } else {
      begin_ = begin.slice();
    }
    begin_.forEach((d) => {
      assert(d !== -1, () => "slice() does not support negative begin indexing.");
    });
    let size_;
    if (size == null) {
      size_ = new Array(x.rank).fill(-1);
    } else if (typeof size === "number") {
      size_ = [size, ...new Array(x.rank - 1).fill(-1)];
    } else if (size.length < x.rank) {
      size_ = size.concat(new Array(x.rank - size.length).fill(-1));
    } else {
      size_ = size;
    }
    size_ = size_.map((d, i) => {
      if (d >= 0) {
        return d;
      } else {
        assert(d === -1, () => `Negative size values should be exactly -1 but got ${d} for the slice() size at index ${i}.`);
        return x.shape[i] - begin_[i];
      }
    });
    return [begin_, size_];
  }

  // node_modules/@tensorflow/tfjs-core/dist/serialization.js
  const serialization_exports = {};
  __export(serialization_exports, {
    Serializable: () => Serializable,
    SerializationMap: () => SerializationMap,
    registerClass: () => registerClass
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class Serializable {
    getClassName() {
      return this.constructor.className;
    }
    static fromConfig(cls, config2) {
      return new cls(config2);
    }
  }
  class SerializationMap {
    constructor() {
      this.classNameMap = {};
    }
    static getMap() {
      if (SerializationMap.instance == null) {
        SerializationMap.instance = new SerializationMap();
      }
      return SerializationMap.instance;
    }
    static register(cls) {
      SerializationMap.getMap().classNameMap[cls.className] = [cls, cls.fromConfig];
    }
  }
  function registerClass(cls) {
    assert(cls.className != null, () => `Class being registered does not have the static className property defined.`);
    assert(typeof cls.className === "string", () => `className is required to be a string, but got type ` + typeof cls.className);
    assert(cls.className.length > 0, () => `Class being registered has an empty-string as its className, which is disallowed.`);
    SerializationMap.register(cls);
  }

  // node_modules/@tensorflow/tfjs-core/dist/test_util.js
  const test_util_exports = {};
  __export(test_util_exports, {
    TEST_EPSILON_FLOAT16: () => TEST_EPSILON_FLOAT16,
    expectArrayBuffersEqual: () => expectArrayBuffersEqual,
    expectArraysClose: () => expectArraysClose,
    expectArraysEqual: () => expectArraysEqual,
    expectNumbersClose: () => expectNumbersClose,
    expectPromiseToFail: () => expectPromiseToFail,
    expectValuesInRange: () => expectValuesInRange,
    testEpsilon: () => testEpsilon
  });
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const TEST_EPSILON_FLOAT32 = 1e-3;
  const TEST_EPSILON_FLOAT16 = 0.1;
  function expectArraysClose(actual, expected, epsilon2) {
    if (epsilon2 == null) {
      epsilon2 = testEpsilon();
    }
    return expectArraysPredicate(actual, expected, (a, b) => areClose(a, b, epsilon2));
  }
  function testEpsilon() {
    return ENGINE.backend.floatPrecision() === 32 ? TEST_EPSILON_FLOAT32 : TEST_EPSILON_FLOAT16;
  }
  function expectArraysPredicate(actual, expected, predicate) {
    let checkClassType = true;
    if (isTypedArray(actual) || isTypedArray(expected)) {
      checkClassType = false;
    }
    if (isTypedArray(actual) && isTypedArray(expected)) {
      checkClassType = true;
    }
    if (checkClassType) {
      const aType = actual.constructor.name;
      const bType = expected.constructor.name;
      if (aType !== bType) {
        throw new Error(`Arrays are of different type. Actual: ${aType}. Expected: ${bType}`);
      }
    }
    if (Array.isArray(actual) && Array.isArray(expected)) {
      const actualShape = inferShape(actual);
      const expectedShape = inferShape(expected);
      if (!arraysEqual(actualShape, expectedShape)) {
        throw new Error(`Arrays have different shapes. Actual: [${actualShape}]. Expected: [${expectedShape}]`);
      }
    }
    const actualFlat = isTypedArray(actual) ? actual : flatten(actual);
    const expectedFlat = isTypedArray(expected) ? expected : flatten(expected);
    if (actualFlat.length !== expectedFlat.length) {
      throw new Error(`Arrays have different lengths actual: ${actualFlat.length} vs expected: ${expectedFlat.length}.
Actual:   ${actualFlat}.
Expected: ${expectedFlat}.`);
    }
    for (let i = 0; i < expectedFlat.length; ++i) {
      const a = actualFlat[i];
      const e = expectedFlat[i];
      if (!predicate(a, e)) {
        throw new Error(`Arrays differ: actual[${i}] = ${a}, expected[${i}] = ${e}.
Actual:   ${actualFlat}.
Expected: ${expectedFlat}.`);
      }
    }
  }
  function expectPromiseToFail(fn, done) {
    fn().then(() => done.fail(), () => done());
  }
  function expectArraysEqual(actual, expected) {
    const exp11 = typeof expected === "string" || typeof expected === "number" || typeof expected === "boolean" ? [expected] : expected;
    if (isString(actual) || isString(actual[0]) || isString(expected) || isString(expected[0])) {
      return expectArraysPredicate(actual, exp11, (a, b) => a == b);
    }
    return expectArraysPredicate(actual, expected, (a, b) => areClose(a, b, 0));
  }
  function expectNumbersClose(a, e, epsilon2) {
    if (epsilon2 == null) {
      epsilon2 = testEpsilon();
    }
    if (!areClose(a, e, epsilon2)) {
      throw new Error(`Numbers differ: actual === ${a}, expected === ${e}`);
    }
  }
  function areClose(a, e, epsilon2) {
    if (!isFinite(a) && !isFinite(e)) {
      return true;
    }
    if (isNaN(a) || isNaN(e) || Math.abs(a - e) > epsilon2) {
      return false;
    }
    return true;
  }
  function expectValuesInRange(actual, low, high) {
    for (let i = 0; i < actual.length; i++) {
      if (actual[i] < low || actual[i] > high) {
        throw new Error(`Value out of range:${actual[i]} low: ${low}, high: ${high}`);
      }
    }
  }
  function expectArrayBuffersEqual(actual, expected) {
    expect(new Float32Array(actual)).toEqual(new Float32Array(expected));
  }

  // node_modules/@tensorflow/tfjs-core/dist/version.js
  /** @license See the LICENSE file. */
  const version = "2.4.0";

  // node_modules/@tensorflow/tfjs-core/dist/globals.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function enableProdMode() {
    env().set("PROD", true);
  }
  function enableDebugMode() {
    env().set("DEBUG", true);
  }
  function disableDeprecationWarnings() {
    env().set("DEPRECATION_WARNINGS_ENABLED", false);
    console.warn(`TensorFlow.js deprecation warnings have been disabled.`);
  }
  function deprecationWarn(msg) {
    if (env().getBool("DEPRECATION_WARNINGS_ENABLED")) {
      console.warn(msg + " You can disable deprecation warnings with tf.disableDeprecationWarnings().");
    }
  }
  setDeprecationWarningFn(deprecationWarn);
  function disposeVariables() {
    ENGINE.disposeVariables();
  }
  function engine15() {
    return ENGINE;
  }
  function memory() {
    return ENGINE.memory();
  }
  function profile(f) {
    return ENGINE.profile(f);
  }
  function tidy(nameOrFn, fn) {
    return ENGINE.tidy(nameOrFn, fn);
  }
  function dispose(container) {
    const tensors = getTensorsInContainer(container);
    tensors.forEach((tensor17) => tensor17.dispose());
  }
  function keep(result) {
    return ENGINE.keep(result);
  }
  function time(f) {
    return ENGINE.time(f);
  }
  function setBackend(backendName) {
    return ENGINE.setBackend(backendName);
  }
  function ready() {
    return ENGINE.ready();
  }
  function getBackend() {
    return ENGINE.backendName;
  }
  function removeBackend(name) {
    ENGINE.removeBackend(name);
  }
  function findBackend(name) {
    return ENGINE.findBackend(name);
  }
  function findBackendFactory(name) {
    return ENGINE.findBackendFactory(name);
  }
  function registerBackend(name, factory, priority = 1) {
    return ENGINE.registerBackend(name, factory, priority);
  }
  function backend() {
    return ENGINE.backend;
  }
  function setPlatform(platformName, platform) {
    env().setPlatform(platformName, platform);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/add.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function add_(a, b) {
    let $a = convertToTensor(a, "a", "add");
    let $b = convertToTensor(b, "b", "add");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.add($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Add);
  }
  const add2 = op({add_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/floorDiv.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function floorDiv_(a, b) {
    let $a = convertToTensor(a, "a", "floorDiv");
    let $b = convertToTensor(b, "b", "floorDiv");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.floorDiv($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, FloorDiv);
  }
  const floorDiv = op({floorDiv_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/div.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function div_(a, b) {
    let $a = convertToTensor(a, "a", "div");
    let $b = convertToTensor(b, "b", "div");
    [$a, $b] = makeTypesMatch($a, $b);
    if ($a.dtype === "int32" && $b.dtype === "int32") {
      return floorDiv($a, $b);
    }
    const forward = (backend2, save) => {
      const res = backend2.realDivide($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    const attrs = {};
    return ENGINE.runKernelFunc(forward, inputs, null, Div, attrs);
  }
  const div = op({div_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/mul.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function mul_(a, b) {
    let $a = convertToTensor(a, "a", "mul");
    let $b = convertToTensor(b, "b", "mul");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.multiply($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Multiply);
  }
  const mul = op({mul_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/abs.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function abs_(x) {
    const $x = convertToTensor(x, "x", "abs");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      save([$x]);
      if ($x.dtype === "complex64") {
        return backend2.complexAbs($x);
      }
      return backend2.abs($x);
    }, inputs, null, Abs);
  }
  const abs = op({abs_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/acos.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function acos_(x) {
    const $x = convertToTensor(x, "x", "acos");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.acos($x);
      save([$x]);
      return res;
    }, inputs, null, Acos);
  }
  const acos = op({acos_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/acosh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function acosh_(x) {
    const $x = convertToTensor(x, "x", "acosh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.acosh($x);
      save([$x]);
      return res;
    }, inputs, null, Acosh);
  }
  const acosh = op({acosh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/add_n.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function addN_(tensors) {
    assert(Array.isArray(tensors), () => "The argument passed to tf.addN() must be a list of tensors");
    assert(tensors.length >= 1, () => `Must pass at least one tensor to tf.addN(), but got ${tensors.length}`);
    const $tensors = tensors.map((t, i) => convertToTensor(t, `tensors${i}`, "addN"));
    const firstTensor = $tensors[0];
    $tensors.forEach((t) => {
      if (t.dtype !== firstTensor.dtype) {
        throw new Error("All tensors passed to tf.addN() must have the same dtype");
      }
    });
    $tensors.forEach((t) => {
      if (!arraysEqual(t.shape, firstTensor.shape)) {
        throw new Error("All tensors passed to tf.addN() must have the same shape");
      }
    });
    const forward = (backend2, save) => {
      const res = backend2.addN($tensors);
      save($tensors);
      return res;
    };
    const inputs = $tensors;
    return ENGINE.runKernelFunc(forward, inputs, null, AddN);
  }
  const addN = op({addN_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/axis_util.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function axesAreInnerMostDims(axes, rank) {
    for (let i = 0; i < axes.length; ++i) {
      if (axes[axes.length - i - 1] !== rank - 1 - i) {
        return false;
      }
    }
    return true;
  }
  function combineLocations(outputLoc, reduceLoc, axes) {
    const rank = outputLoc.length + reduceLoc.length;
    const loc = [];
    let outIdx = 0;
    let reduceIdx = 0;
    for (let dim = 0; dim < rank; dim++) {
      if (axes.indexOf(dim) === -1) {
        loc.push(outputLoc[outIdx++]);
      } else {
        loc.push(reduceLoc[reduceIdx++]);
      }
    }
    return loc;
  }
  function computeOutAndReduceShapes(aShape, axes) {
    const outShape = [];
    const rank = aShape.length;
    for (let dim = 0; dim < rank; dim++) {
      if (axes.indexOf(dim) === -1) {
        outShape.push(aShape[dim]);
      }
    }
    const reduceShape = axes.map((dim) => aShape[dim]);
    return [outShape, reduceShape];
  }
  function expandShapeToKeepDim(shape, axes) {
    const reduceSubShape = axes.map((x) => 1);
    return combineLocations(shape, reduceSubShape, axes);
  }
  function assertAxesAreInnerMostDims(msg, axes, rank) {
    assert(axesAreInnerMostDims(axes, rank), () => `${msg} supports only inner-most axes for now. Got axes ${axes} and rank-${rank} input.`);
  }
  function getAxesPermutation(axes, rank) {
    if (axesAreInnerMostDims(axes, rank)) {
      return null;
    }
    const result = [];
    for (let i = 0; i < rank; ++i) {
      if (axes.indexOf(i) === -1) {
        result.push(i);
      }
    }
    axes.forEach((axis) => result.push(axis));
    return result;
  }
  function getUndoAxesPermutation(axes) {
    return axes.map((axis, i) => [i, axis]).sort((a, b) => a[1] - b[1]).map((x) => x[0]);
  }
  function getInnerMostAxes(numAxes, rank) {
    const res = [];
    for (let i = rank - numAxes; i < rank; ++i) {
      res.push(i);
    }
    return res;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/all.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function all_(x, axis = null, keepDims = false) {
    let $x = convertToTensor(x, "x", "all", "bool");
    const forward = (backend2) => {
      const origAxes = parseAxisParam(axis, $x.shape);
      let axes = origAxes;
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      if (permutedAxes != null) {
        $x = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, $x.rank);
      }
      const res = backend2.all($x, axes);
      if (keepDims) {
        const newShape = expandShapeToKeepDim(res.shape, origAxes);
        return reshape(res, newShape);
      }
      return res;
    };
    const inputs = {x: $x};
    const attrs = {axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, All, attrs);
  }
  const all = op({all_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/any.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function any_(x, axis = null, keepDims = false) {
    let $x = convertToTensor(x, "x", "any", "bool");
    const forward = (backend2) => {
      const origAxes = parseAxisParam(axis, $x.shape);
      let axes = origAxes;
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      if (permutedAxes != null) {
        $x = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, $x.rank);
      }
      const res = backend2.any($x, axes);
      if (keepDims) {
        const newShape = expandShapeToKeepDim(res.shape, origAxes);
        return reshape(res, newShape);
      }
      return res;
    };
    const inputs = {x: $x};
    const attrs = {axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, Any, attrs);
  }
  const any = op({any_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/arg_max.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function argMax_(x, axis = 0) {
    let $x = convertToTensor(x, "x", "argMax");
    const forward = (backend2, save) => {
      save([$x]);
      let axes = parseAxisParam(axis, $x.shape);
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      if (permutedAxes != null) {
        $x = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, $x.rank);
      }
      return backend2.argMax($x, axes[0]);
    };
    const inputs = {x: $x};
    const attrs = {axis};
    return ENGINE.runKernelFunc(forward, inputs, null, ArgMax, attrs);
  }
  const argMax = op({argMax_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/arg_min.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function argMin_(x, axis = 0) {
    let $x = convertToTensor(x, "x", "argMin");
    const forward = (backend2, save) => {
      save([$x]);
      if (axis == null) {
        axis = 0;
      }
      let axes = parseAxisParam(axis, $x.shape);
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      if (permutedAxes != null) {
        $x = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, $x.rank);
      }
      return backend2.argMin($x, axes[0]);
    };
    const inputs = {x: $x};
    const attrs = {axis};
    return ENGINE.runKernelFunc(forward, inputs, null, ArgMin, attrs);
  }
  const argMin = op({argMin_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/asin.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function asin_(x) {
    const $x = convertToTensor(x, "x", "asin");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.asin($x);
      save([$x]);
      return res;
    }, inputs, null, Asin);
  }
  const asin = op({asin_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/asinh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function asinh_(x) {
    const $x = convertToTensor(x, "x", "asinh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.asinh($x);
      save([$x]);
      return res;
    }, inputs, null, Asinh);
  }
  const asinh = op({asinh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/atan.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function atan_(x) {
    const $x = convertToTensor(x, "x", "atan");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.atan($x);
      save([$x]);
      return res;
    }, inputs, null, Atan);
  }
  const atan = op({atan_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/atan2.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function atan2_(a, b) {
    let $a = convertToTensor(a, "a", "atan2");
    let $b = convertToTensor(b, "b", "atan2");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.atan2($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Atan2);
  }
  const atan2 = op({atan2_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/atanh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function atanh_(x) {
    const $x = convertToTensor(x, "x", "atanh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.atanh($x);
      save([$x]);
      return res;
    }, inputs, null, Atanh);
  }
  const atanh = op({atanh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv_util.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function computeDilation2DInfo(inputShape, filterShape, strides, pad8, dataFormat = "NHWC", dilations) {
    const inputChannels = inputShape[3];
    const $filterShape = [...filterShape, inputChannels];
    const $dataFormat = convertConv2DDataFormat(dataFormat);
    return computeConv2DInfo(inputShape, $filterShape, strides, dilations, pad8, null, null, $dataFormat);
  }
  function computePool2DInfo(inShape, filterSize, strides, dilations, pad8, roundingMode, dataFormat = "channelsLast") {
    const [filterHeight, filterWidth] = parseTupleParam(filterSize);
    let filterShape;
    if (dataFormat === "channelsLast") {
      filterShape = [filterHeight, filterWidth, inShape[3], inShape[3]];
    } else if (dataFormat === "channelsFirst") {
      filterShape = [filterHeight, filterWidth, inShape[1], inShape[1]];
    } else {
      throw new Error(`Unknown dataFormat ${dataFormat}`);
    }
    return computeConv2DInfo(inShape, filterShape, strides, dilations, pad8, roundingMode, false, dataFormat);
  }
  function computePool3DInfo(inShape, filterSize, strides, dilations, pad8, roundingMode, dataFormat = "NDHWC") {
    const [filterDepth, filterHeight, filterWidth] = parse3TupleParam(filterSize);
    let filterShape;
    let $dataFormat;
    if (dataFormat === "NDHWC") {
      $dataFormat = "channelsLast";
      filterShape = [filterDepth, filterHeight, filterWidth, inShape[4], inShape[4]];
    } else if (dataFormat === "NCDHW") {
      $dataFormat = "channelsFirst";
      filterShape = [filterDepth, filterHeight, filterWidth, inShape[1], inShape[1]];
    } else {
      throw new Error(`Unknown dataFormat ${dataFormat}`);
    }
    return computeConv3DInfo(inShape, filterShape, strides, dilations, pad8, false, $dataFormat, roundingMode);
  }
  function computeConv2DInfo(inShape, filterShape, strides, dilations, pad8, roundingMode, depthwise = false, dataFormat = "channelsLast") {
    let [batchSize, inHeight, inWidth, inChannels] = [-1, -1, -1, -1];
    if (dataFormat === "channelsLast") {
      [batchSize, inHeight, inWidth, inChannels] = inShape;
    } else if (dataFormat === "channelsFirst") {
      [batchSize, inChannels, inHeight, inWidth] = inShape;
    } else {
      throw new Error(`Unknown dataFormat ${dataFormat}`);
    }
    const [filterHeight, filterWidth, , filterChannels] = filterShape;
    const [strideHeight, strideWidth] = parseTupleParam(strides);
    const [dilationHeight, dilationWidth] = parseTupleParam(dilations);
    const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);
    const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);
    const {padInfo, outHeight, outWidth} = getPadAndOutInfo(pad8, inHeight, inWidth, strideHeight, strideWidth, effectiveFilterHeight, effectiveFilterWidth, roundingMode, dataFormat);
    const outChannels = depthwise ? filterChannels * inChannels : filterChannels;
    let outShape;
    if (dataFormat === "channelsFirst") {
      outShape = [batchSize, outChannels, outHeight, outWidth];
    } else if (dataFormat === "channelsLast") {
      outShape = [batchSize, outHeight, outWidth, outChannels];
    }
    return {
      batchSize,
      dataFormat,
      inHeight,
      inWidth,
      inChannels,
      outHeight,
      outWidth,
      outChannels,
      padInfo,
      strideHeight,
      strideWidth,
      filterHeight,
      filterWidth,
      effectiveFilterHeight,
      effectiveFilterWidth,
      dilationHeight,
      dilationWidth,
      inShape,
      outShape,
      filterShape
    };
  }
  function computeConv3DInfo(inShape, filterShape, strides, dilations, pad8, depthwise = false, dataFormat = "channelsLast", roundingMode) {
    let [batchSize, inDepth, inHeight, inWidth, inChannels] = [-1, -1, -1, -1, -1];
    if (dataFormat === "channelsLast") {
      [batchSize, inDepth, inHeight, inWidth, inChannels] = inShape;
    } else if (dataFormat === "channelsFirst") {
      [batchSize, inChannels, inDepth, inHeight, inWidth] = inShape;
    } else {
      throw new Error(`Unknown dataFormat ${dataFormat}`);
    }
    const [filterDepth, filterHeight, filterWidth, , filterChannels] = filterShape;
    const [strideDepth, strideHeight, strideWidth] = parse3TupleParam(strides);
    const [dilationDepth, dilationHeight, dilationWidth] = parse3TupleParam(dilations);
    const effectiveFilterDepth = getEffectiveFilterSize(filterDepth, dilationDepth);
    const effectiveFilterHeight = getEffectiveFilterSize(filterHeight, dilationHeight);
    const effectiveFilterWidth = getEffectiveFilterSize(filterWidth, dilationWidth);
    const {padInfo, outDepth, outHeight, outWidth} = get3DPadAndOutInfo(pad8, inDepth, inHeight, inWidth, strideDepth, strideHeight, strideWidth, effectiveFilterDepth, effectiveFilterHeight, effectiveFilterWidth, roundingMode);
    const outChannels = depthwise ? filterChannels * inChannels : filterChannels;
    let outShape;
    if (dataFormat === "channelsFirst") {
      outShape = [batchSize, outChannels, outDepth, outHeight, outWidth];
    } else if (dataFormat === "channelsLast") {
      outShape = [batchSize, outDepth, outHeight, outWidth, outChannels];
    }
    return {
      batchSize,
      dataFormat,
      inDepth,
      inHeight,
      inWidth,
      inChannels,
      outDepth,
      outHeight,
      outWidth,
      outChannels,
      padInfo,
      strideDepth,
      strideHeight,
      strideWidth,
      filterDepth,
      filterHeight,
      filterWidth,
      effectiveFilterDepth,
      effectiveFilterHeight,
      effectiveFilterWidth,
      dilationDepth,
      dilationHeight,
      dilationWidth,
      inShape,
      outShape,
      filterShape
    };
  }
  function computeOutputShape2D(inShape, fieldSize, stride, zeroPad, roundingMode) {
    if (zeroPad == null) {
      zeroPad = computeDefaultPad(inShape, fieldSize, stride);
    }
    const inputRows = inShape[0];
    const inputCols = inShape[1];
    const outputRows = conditionalRound((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
    assert(isInt(outputRows), () => `The output # of rows (${outputRows}) must be an integer. Change the stride and/or zero pad parameters`);
    const outputCols = conditionalRound((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
    assert(isInt(outputCols), () => `The output # of columns (${outputCols}) must be an integer. Change the stride and/or zero pad parameters`);
    return [outputRows, outputCols];
  }
  function computeOutputShape4D(inShape, fieldSize, outChannels, stride, zeroPad, roundingMode) {
    if (zeroPad == null) {
      zeroPad = computeDefaultPad(inShape, fieldSize, stride);
    }
    const inputDepth = inShape[0];
    const inputRows = inShape[1];
    const inputCols = inShape[2];
    const outputDepths = conditionalRound((inputDepth - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
    assert(isInt(outputDepths), () => `The output # of depths (${outputDepths}) must be an integer. Change the stride and/or zero pad parameters`);
    const outputRows = conditionalRound((inputRows - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
    assert(isInt(outputRows), () => `The output # of rows (${outputRows}) must be an integer. Change the stride and/or zero pad parameters`);
    const outputCols = conditionalRound((inputCols - fieldSize + 2 * zeroPad) / stride + 1, roundingMode);
    assert(isInt(outputCols), () => `The output # of columns (${outputCols}) must be an integer. Change the stride and/or zero pad parameters`);
    return [outputDepths, outputRows, outputCols, outChannels];
  }
  function computeDefaultPad(inputShape, fieldSize, stride, dilation = 1) {
    const effectiveFieldSize = getEffectiveFilterSize(fieldSize, dilation);
    return Math.floor((inputShape[0] * (stride - 1) - stride + effectiveFieldSize) / 2);
  }
  function parseTupleParam(param) {
    if (typeof param === "number") {
      return [param, param, param];
    }
    if (param.length === 2) {
      return [param[0], param[1], 1];
    }
    return param;
  }
  function parse3TupleParam(param) {
    return typeof param === "number" ? [param, param, param] : param;
  }
  function getEffectiveFilterSize(filterSize, dilation) {
    if (dilation <= 1) {
      return filterSize;
    }
    return filterSize + (filterSize - 1) * (dilation - 1);
  }
  function getPadAndOutInfo(pad8, inHeight, inWidth, strideHeight, strideWidth, filterHeight, filterWidth, roundingMode, dataFormat) {
    let padInfo;
    let outHeight;
    let outWidth;
    if (typeof pad8 === "number") {
      const padType = pad8 === 0 ? "VALID" : "NUMBER";
      padInfo = {top: pad8, bottom: pad8, left: pad8, right: pad8, type: padType};
      const outShape = computeOutputShape2D([inHeight, inWidth], filterHeight, strideHeight, pad8, roundingMode);
      outHeight = outShape[0];
      outWidth = outShape[1];
    } else if (pad8 === "same") {
      outHeight = Math.ceil(inHeight / strideHeight);
      outWidth = Math.ceil(inWidth / strideWidth);
      const padAlongHeight = Math.max(0, (outHeight - 1) * strideHeight + filterHeight - inHeight);
      const padAlongWidth = Math.max(0, (outWidth - 1) * strideWidth + filterWidth - inWidth);
      const top = Math.floor(padAlongHeight / 2);
      const bottom = padAlongHeight - top;
      const left = Math.floor(padAlongWidth / 2);
      const right = padAlongWidth - left;
      padInfo = {top, bottom, left, right, type: "SAME"};
    } else if (pad8 === "valid") {
      padInfo = {top: 0, bottom: 0, left: 0, right: 0, type: "VALID"};
      outHeight = Math.ceil((inHeight - filterHeight + 1) / strideHeight);
      outWidth = Math.ceil((inWidth - filterWidth + 1) / strideWidth);
    } else if (typeof pad8 === "object") {
      const top = dataFormat === "channelsLast" ? pad8[1][0] : pad8[2][0];
      const bottom = dataFormat === "channelsLast" ? pad8[1][1] : pad8[2][1];
      const left = dataFormat === "channelsLast" ? pad8[2][0] : pad8[3][0];
      const right = dataFormat === "channelsLast" ? pad8[2][1] : pad8[3][1];
      const padType = top === 0 && bottom === 0 && left === 0 && right === 0 ? "VALID" : "EXPLICIT";
      padInfo = {top, bottom, left, right, type: padType};
      outHeight = conditionalRound((inHeight - filterHeight + top + bottom) / strideHeight + 1, roundingMode);
      outWidth = conditionalRound((inWidth - filterWidth + left + right) / strideWidth + 1, roundingMode);
    } else {
      throw Error(`Unknown padding parameter: ${pad8}`);
    }
    return {padInfo, outHeight, outWidth};
  }
  function get3DPadAndOutInfo(pad8, inDepth, inHeight, inWidth, strideDepth, strideHeight, strideWidth, filterDepth, filterHeight, filterWidth, roundingMode) {
    let padInfo;
    let outDepth;
    let outHeight;
    let outWidth;
    if (typeof pad8 === "number") {
      const padType = pad8 === 0 ? "VALID" : "NUMBER";
      padInfo = {
        top: pad8,
        bottom: pad8,
        left: pad8,
        right: pad8,
        front: pad8,
        back: pad8,
        type: padType
      };
      const outShape = computeOutputShape4D([inDepth, inHeight, inWidth, 1], filterDepth, 1, strideDepth, pad8, roundingMode);
      outDepth = outShape[0];
      outHeight = outShape[1];
      outWidth = outShape[2];
    } else if (pad8 === "same") {
      outDepth = Math.ceil(inDepth / strideDepth);
      outHeight = Math.ceil(inHeight / strideHeight);
      outWidth = Math.ceil(inWidth / strideWidth);
      const padAlongDepth = (outDepth - 1) * strideDepth + filterDepth - inDepth;
      const padAlongHeight = (outHeight - 1) * strideHeight + filterHeight - inHeight;
      const padAlongWidth = (outWidth - 1) * strideWidth + filterWidth - inWidth;
      const front = Math.floor(padAlongDepth / 2);
      const back = padAlongDepth - front;
      const top = Math.floor(padAlongHeight / 2);
      const bottom = padAlongHeight - top;
      const left = Math.floor(padAlongWidth / 2);
      const right = padAlongWidth - left;
      padInfo = {top, bottom, left, right, front, back, type: "SAME"};
    } else if (pad8 === "valid") {
      padInfo = {
        top: 0,
        bottom: 0,
        left: 0,
        right: 0,
        front: 0,
        back: 0,
        type: "VALID"
      };
      outDepth = Math.ceil((inDepth - filterDepth + 1) / strideDepth);
      outHeight = Math.ceil((inHeight - filterHeight + 1) / strideHeight);
      outWidth = Math.ceil((inWidth - filterWidth + 1) / strideWidth);
    } else {
      throw Error(`Unknown padding parameter: ${pad8}`);
    }
    return {padInfo, outDepth, outHeight, outWidth};
  }
  function conditionalRound(value, roundingMode) {
    if (!roundingMode) {
      return value;
    }
    switch (roundingMode) {
      case "round":
        return Math.round(value);
      case "ceil":
        return Math.ceil(value);
      case "floor":
        return Math.floor(value);
      default:
        throw new Error(`Unknown roundingMode ${roundingMode}`);
    }
  }
  function tupleValuesAreOne(param) {
    const [dimA, dimB, dimC] = parseTupleParam(param);
    return dimA === 1 && dimB === 1 && dimC === 1;
  }
  function eitherStridesOrDilationsAreOne(strides, dilations) {
    return tupleValuesAreOne(strides) || tupleValuesAreOne(dilations);
  }
  function convertConv2DDataFormat(dataFormat) {
    if (dataFormat === "NHWC") {
      return "channelsLast";
    } else if (dataFormat === "NCHW") {
      return "channelsFirst";
    } else {
      throw new Error(`Unknown dataFormat ${dataFormat}`);
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function avgPool_(x, filterSize, strides, pad8, dimRoundingMode) {
    const $x = convertToTensor(x, "x", "avgPool", "float32");
    const dilations = 1;
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in avgPool: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in avgPool: x must be rank 4 but got rank ${x4D.rank}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in avgPool: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      const convInfo = computePool2DInfo(x4D.shape, filterSize, strides, 1, pad8, dimRoundingMode);
      save([x4D]);
      if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 && arraysEqual(convInfo.inShape, convInfo.outShape)) {
        return x4D.clone();
      }
      return backend2.avgPool(x4D, convInfo);
    };
    const inputs = {x: x4D};
    const attrs = {filterSize, strides, pad: pad8, dimRoundingMode};
    let res = ENGINE.runKernelFunc(forward, inputs, null, AvgPool, attrs);
    res = cast(res, $x.dtype);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const avgPool = op({avgPool_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_3d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function avgPool3d_(x, filterSize, strides, pad8, dimRoundingMode, dataFormat = "NDHWC", dilations) {
    if (dilations == null) {
      dilations = [1, 1, 1];
    } else {
      deprecationWarn("dilations is deprecated, this field will be gone in v3.0.0.");
    }
    const $x = convertToTensor(x, "x", "avgPool3d", "float32");
    let x5D = $x;
    let reshapedTo5D = false;
    if ($x.rank === 4) {
      reshapedTo5D = true;
      x5D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]);
    }
    assert(x5D.rank === 5, () => `Error in avgPool3d: x must be rank 5 but got rank ${x5D.rank}.`);
    assert(dataFormat === "NDHWC", () => `Error in avgPool3d: Only NDHWC is currently supported, but got dataFormat of ${dataFormat}`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in avgPool3d: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in avgPool3d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      if (dilations == null) {
        dilations = [1, 1, 1];
      }
      const convInfo = computePool3DInfo(x5D.shape, filterSize, strides, dilations, pad8, dimRoundingMode, dataFormat);
      save([x5D]);
      return backend2.avgPool3d(x5D, convInfo);
    };
    const inputs = {x: x5D};
    const attrs = {filterSize, strides, pad: pad8, dimRoundingMode, dataFormat, dilations};
    let res = ENGINE.runKernelFunc(forward, inputs, null, AvgPool3D, attrs);
    res = cast(res, x5D.dtype);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const avgPool3d = op({avgPool3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat_util.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function assertParamsConsistent(shapes, axis) {
    const rank = shapes[0].length;
    shapes.forEach((shape, i) => {
      assert(shape.length === rank, () => `Error in concat${rank}D: rank of tensors[${i}] must be the same as the rank of the rest (${rank})`);
    });
    assert(axis >= 0 && axis < rank, () => `Error in concat${rank}D: axis must be between 0 and ${rank - 1}.`);
    const firstShape = shapes[0];
    shapes.forEach((shape, i) => {
      for (let r = 0; r < rank; r++) {
        assert(r === axis || shape[r] === firstShape[r], () => `Error in concat${rank}D: Shape of tensors[${i}] (${shape}) does not match the shape of the rest (${firstShape}) along the non-concatenated axis ${i}.`);
      }
    });
  }
  function computeOutShape2(shapes, axis) {
    const outputShape = shapes[0].slice();
    for (let i = 1; i < shapes.length; i++) {
      outputShape[axis] += shapes[i][axis];
    }
    return outputShape;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function concat_(tensors, axis = 0) {
    assert(tensors.length >= 1, () => "Pass at least one tensor to concat");
    let $tensors = convertToTensorArray(tensors, "tensors", "concat");
    if ($tensors[0].dtype === "complex64") {
      $tensors.forEach((tensor17) => {
        if (tensor17.dtype !== "complex64") {
          throw new Error(`Cannot concatenate complex64 tensors with a tensor
          with dtype ${tensor17.dtype}. `);
        }
      });
    }
    const $axis = parseAxisParam(axis, $tensors[0].shape)[0];
    const outShape = computeOutShape2($tensors.map((t) => t.shape), $axis);
    if (sizeFromShape(outShape) === 0) {
      return tensor4([], outShape);
    }
    $tensors = $tensors.filter((t) => t.size > 0);
    if ($tensors.length === 1) {
      return $tensors[0];
    }
    const shapes = $tensors.map((t) => t.shape);
    assertParamsConsistent(shapes, $axis);
    const forward = (backend2, save) => {
      const res = backend2.concat($tensors, $axis);
      save($tensors);
      return res;
    };
    const inputs = $tensors;
    const attr = {axis};
    return ENGINE.runKernelFunc(forward, inputs, null, Concat, attr);
  }
  const concat = op({concat_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sigmoid.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sigmoid_(x) {
    const $x = convertToTensor(x, "x", "sigmoid");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.sigmoid($x);
      save([res]);
      return res;
    }, inputs, null, Sigmoid);
  }
  const sigmoid = op({sigmoid_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function slice_(x, begin, size) {
    const $x = convertToTensor(x, "x", "slice");
    if ($x.rank === 0) {
      throw new Error("Slicing scalar is not possible");
    }
    const [begin_, size_] = parseSliceParams($x, begin, size);
    assertParamsValid($x, begin_, size_);
    const forward = (backend2, save) => {
      save([$x]);
      return backend2.slice($x, begin_, size_);
    };
    const inputs = {x: $x};
    const attrs = {begin, size};
    return ENGINE.runKernelFunc(forward, inputs, null, Slice, attrs);
  }
  const slice = op({slice_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tanh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tanh_(x) {
    const $x = convertToTensor(x, "x", "tanh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const y = backend2.tanh($x);
      save([y]);
      return y;
    }, inputs, null, Tanh);
  }
  const tanh2 = op({tanh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/basic_lstm_cell.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function basicLSTMCell_(forgetBias, lstmKernel, lstmBias, data, c, h) {
    const $forgetBias = convertToTensor(forgetBias, "forgetBias", "basicLSTMCell");
    const $lstmKernel = convertToTensor(lstmKernel, "lstmKernel", "basicLSTMCell");
    const $lstmBias = convertToTensor(lstmBias, "lstmBias", "basicLSTMCell");
    const $data = convertToTensor(data, "data", "basicLSTMCell");
    const $c = convertToTensor(c, "c", "basicLSTMCell");
    const $h = convertToTensor(h, "h", "basicLSTMCell");
    const combined = concat([$data, $h], 1);
    const weighted = matMul(combined, $lstmKernel);
    const res = add2(weighted, $lstmBias);
    const batchSize = res.shape[0];
    const sliceCols = res.shape[1] / 4;
    const sliceSize = [batchSize, sliceCols];
    const i = slice(res, [0, 0], sliceSize);
    const j = slice(res, [0, sliceCols], sliceSize);
    const f = slice(res, [0, sliceCols * 2], sliceSize);
    const o = slice(res, [0, sliceCols * 3], sliceSize);
    const newC = add2(mul(sigmoid(i), tanh2(j)), mul($c, sigmoid(add2($forgetBias, f))));
    const newH = mul(tanh2(newC), sigmoid(o));
    return [newC, newH];
  }
  const basicLSTMCell = op({basicLSTMCell_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/batch_to_space_nd.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function batchToSpaceND_(x, blockShape, crops) {
    const $x = convertToTensor(x, "x", "batchToSpaceND");
    const prod3 = blockShape.reduce((a, b) => a * b);
    assert($x.rank >= 1 + blockShape.length, () => `input rank is ${$x.rank} but should be > than blockShape.length ${blockShape.length}`);
    assert(crops.length === blockShape.length, () => `crops.length is ${crops.length} but should be equal to blockShape.length  ${blockShape.length}`);
    assert($x.shape[0] % prod3 === 0, () => `input tensor batch is ${$x.shape[0]} but is not divisible by the product of the elements of blockShape ${blockShape.join(" * ")} === ${prod3}`);
    const forward = (backend2) => {
      return backend2.batchToSpaceND($x, blockShape, crops);
    };
    const inputs = {x: $x};
    const attrs = {blockShape, crops};
    return ENGINE.runKernelFunc(forward, inputs, null, BatchToSpaceND, attrs);
  }
  const batchToSpaceND = op({batchToSpaceND_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm_util.js
  function xAs4D(x) {
    let x4D;
    if (x.rank === 0 || x.rank === 1) {
      x4D = reshape(x, [1, 1, 1, x.size]);
    } else if (x.rank === 2) {
      x4D = reshape(x, [1, 1, x.shape[0], x.shape[1]]);
    } else if (x.rank === 3) {
      x4D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
    } else {
      x4D = x;
    }
    return x4D;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function batchNorm_(x, mean5, variance, offset, scale2, varianceEpsilon) {
    if (varianceEpsilon == null) {
      varianceEpsilon = 1e-3;
    }
    const $x = convertToTensor(x, "x", "batchNorm");
    const $mean = convertToTensor(mean5, "mean", "batchNorm");
    const $variance = convertToTensor(variance, "variance", "batchNorm");
    let $scale;
    if (scale2 != null) {
      $scale = convertToTensor(scale2, "scale", "batchNorm");
    }
    let $offset;
    if (offset != null) {
      $offset = convertToTensor(offset, "offset", "batchNorm");
    }
    assert($mean.rank === $variance.rank, () => "Batch normalization gradient requires mean and variance to have equal ranks.");
    assert($offset == null || $mean.rank === $offset.rank, () => "Batch normalization gradient requires mean and offset to have equal ranks.");
    assert($scale == null || $mean.rank === $scale.rank, () => "Batch normalization gradient requires mean and scale to have equal ranks.");
    const x4D = xAs4D($x);
    const forward = (backend2, save) => {
      save([x4D, $mean, $variance, $scale]);
      return backend2.batchNorm(x4D, as1DOr4D($mean), as1DOr4D($variance), as1DOr4D($offset), as1DOr4D($scale), varianceEpsilon);
    };
    const inputs = {
      x: x4D,
      scale: $scale,
      offset: $offset,
      mean: $mean,
      variance: $variance
    };
    const attrs = {varianceEpsilon};
    const res = ENGINE.runKernelFunc(forward, inputs, null, FusedBatchNorm, attrs);
    return reshape(res, $x.shape);
  }
  function as1DOr4D(x) {
    if (x == null) {
      return null;
    }
    if (x.rank === 0) {
      return reshape(x, [x.size]);
    } else if (x.rank === 1) {
      return x;
    } else if (x.rank === 2) {
      return reshape(x, [1, 1, x.shape[0], x.shape[1]]);
    } else if (x.rank === 3) {
      return reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
    }
    return x;
  }
  const batchNorm = op({batchNorm_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm2d.js
  function batchNorm2d_(x, mean5, variance, offset, scale2, varianceEpsilon) {
    const $x = convertToTensor(x, "x", "batchNorm");
    const $mean = convertToTensor(mean5, "mean", "batchNorm");
    const $variance = convertToTensor(variance, "variance", "batchNorm");
    let $scale;
    if (scale2 != null) {
      $scale = convertToTensor(scale2, "scale", "batchNorm");
    }
    let $offset;
    if (offset != null) {
      $offset = convertToTensor(offset, "offset", "batchNorm");
    }
    assert($x.rank === 2, () => `Error in batchNorm2D: x must be rank 2 but got rank ${$x.rank}.`);
    assert($mean.rank === 2 || $mean.rank === 1, () => `Error in batchNorm2D: mean must be rank 2 or rank 1 but got rank ${$mean.rank}.`);
    assert($variance.rank === 2 || $variance.rank === 1, () => `Error in batchNorm2D: variance must be rank 2 or rank 1 but got rank ${$variance.rank}.`);
    if ($scale != null) {
      assert($scale.rank === 2 || $scale.rank === 1, () => `Error in batchNorm2D: scale must be rank 2 or rank 1 but got rank ${$scale.rank}.`);
    }
    if ($offset != null) {
      assert($offset.rank === 2 || $offset.rank === 1, () => `Error in batchNorm2D: offset must be rank 2 or rank 1 but got rank ${$offset.rank}.`);
    }
    return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
  }
  const batchNorm2d = op({batchNorm2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm3d.js
  function batchNorm3d_(x, mean5, variance, offset, scale2, varianceEpsilon) {
    const $x = convertToTensor(x, "x", "batchNorm");
    const $mean = convertToTensor(mean5, "mean", "batchNorm");
    const $variance = convertToTensor(variance, "variance", "batchNorm");
    let $scale;
    if (scale2 != null) {
      $scale = convertToTensor(scale2, "scale", "batchNorm");
    }
    let $offset;
    if (offset != null) {
      $offset = convertToTensor(offset, "offset", "batchNorm");
    }
    assert($x.rank === 3, () => `Error in batchNorm3D: x must be rank 3 but got rank ${$x.rank}.`);
    assert($mean.rank === 3 || $mean.rank === 1, () => `Error in batchNorm3D: mean must be rank 3 or rank 1 but got rank ${$mean.rank}.`);
    assert($variance.rank === 3 || $variance.rank === 1, () => `Error in batchNorm3D: variance must be rank 3 or rank 1 but got rank ${$variance.rank}.`);
    if ($scale != null) {
      assert($scale.rank === 3 || $scale.rank === 1, () => `Error in batchNorm3D: scale must be rank 3 or rank 1 but got rank ${$scale.rank}.`);
    }
    if ($offset != null) {
      assert($offset.rank === 3 || $offset.rank === 1, () => `Error in batchNorm3D: offset must be rank 3 or rank 1 but got rank ${$offset.rank}.`);
    }
    return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
  }
  const batchNorm3d = op({batchNorm3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/batchnorm4d.js
  function batchNorm4d_(x, mean5, variance, offset, scale2, varianceEpsilon) {
    const $x = convertToTensor(x, "x", "batchNorm");
    const $mean = convertToTensor(mean5, "mean", "batchNorm");
    const $variance = convertToTensor(variance, "variance", "batchNorm");
    let $scale;
    if (scale2 != null) {
      $scale = convertToTensor(scale2, "scale", "batchNorm");
    }
    let $offset;
    if (offset != null) {
      $offset = convertToTensor(offset, "offset", "batchNorm");
    }
    assert($x.rank === 4, () => `Error in batchNorm4D: x must be rank 4 but got rank ${$x.rank}.`);
    assert($mean.rank === 4 || $mean.rank === 1, () => `Error in batchNorm4D: mean must be rank 4 or rank 1 but got rank ${$mean.rank}.`);
    assert($variance.rank === 4 || $variance.rank === 1, () => `Error in batchNorm4D: variance must be rank 4 or rank 1 but got rank ${$variance.rank}.`);
    if ($scale != null) {
      assert($scale.rank === 4 || $scale.rank === 1, () => `Error in batchNorm4D: scale must be rank 4 or rank 1 but got rank ${$scale.rank}.`);
    }
    if ($offset != null) {
      assert($offset.rank === 4 || $offset.rank === 1, () => `Error in batchNorm4D: offset must be rank 4 or rank 1 but got rank ${$offset.rank}.`);
    }
    return batchNorm($x, $mean, $variance, $offset, $scale, varianceEpsilon);
  }
  const batchNorm4d = op({batchNorm4d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/broadcast_to.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function broadcastTo_(x, shape) {
    let input = convertToTensor(x, "broadcastTo", "x");
    const xShape = input.shape;
    if (shape.some((d) => !(d > 0) || d % 1 !== 0)) {
      throw new Error(`broadcastTo(): Invalid broadcast shape [${shape}].`);
    }
    if (shape.length < input.rank) {
      throw new Error(`broadcastTo(): shape.length=${shape.length} < input.rank=${input.rank}.`);
    }
    if (shape.length > input.rank) {
      const newShape = input.shape.slice();
      while (newShape.length < shape.length) {
        newShape.unshift(1);
      }
      input = reshape(input, newShape);
    }
    const inputShape = input.shape;
    const reps = Array.from(shape);
    for (let i = shape.length - 1; i >= 0; i--) {
      if (inputShape[i] === shape[i]) {
        reps[i] = 1;
      } else if (input.shape[i] !== 1) {
        throw new Error(`broadcastTo(): [${xShape}] cannot be broadcast to [${shape}].`);
      }
    }
    const axes = reps.map((n, i) => n > 1 ? i : -1).filter((i) => i >= 0);
    if (axes.length === 0) {
      return clone(input);
    }
    const forward = (backend2) => backend2.tile(input, reps);
    const inputs = {x: input};
    const attrs = {shape, inputShape};
    return ENGINE.runKernelFunc(forward, inputs, null, BroadcastTo, attrs);
  }
  const broadcastTo = op({broadcastTo_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/ceil.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function ceil_(x) {
    const $x = convertToTensor(x, "x", "ceil");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.ceil($x), inputs, null, Ceil);
  }
  const ceil = op({ceil_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/clip_by_value.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function clipByValue_(x, clipValueMin, clipValueMax) {
    const $x = convertToTensor(x, "x", "clipByValue");
    assert(clipValueMin <= clipValueMax, () => `Error in clip: min (${clipValueMin}) must be less than or equal to max (${clipValueMax}).`);
    const inputs = {x: $x};
    const attrs = {clipValueMin, clipValueMax};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.clip($x, clipValueMin, clipValueMax);
      save([$x]);
      return res;
    }, inputs, null, ClipByValue, attrs);
  }
  const clipByValue = op({clipByValue_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat_1d.js
  function concat1d_(tensors) {
    return concat(tensors, 0);
  }
  const concat1d = op({concat1d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat_2d.js
  function concat2d_(tensors, axis) {
    return concat(tensors, axis);
  }
  const concat2d = op({concat2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat_3d.js
  function concat3d_(tensors, axis) {
    return concat(tensors, axis);
  }
  const concat3d = op({concat3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/concat_4d.js
  function concat4d_(tensors, axis) {
    return concat(tensors, axis);
  }
  const concat4d = op({concat4d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv2d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv2d_(x, filter, strides, pad8, dataFormat = "NHWC", dilations = [1, 1], dimRoundingMode) {
    const $x = convertToTensor(x, "x", "conv2d");
    const $filter = convertToTensor(filter, "filter", "conv2d");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in conv2d: input must be rank 4, but got rank ${x4D.rank}.`);
    assert($filter.rank === 4, () => `Error in conv2d: filter must be rank 4, but got rank ${$filter.rank}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in conv2d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const inDepth = dataFormat === "NHWC" ? x4D.shape[3] : x4D.shape[1];
    assert(inDepth === $filter.shape[2], () => `Error in conv2d: depth of input (${inDepth}) must match input depth for filter ${$filter.shape[2]}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in conv2D: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    const forward = (backend2, save) => {
      const $dataFormat = convertConv2DDataFormat(dataFormat);
      const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad8, dimRoundingMode, false, $dataFormat);
      const res2 = backend2.conv2d(x4D, $filter, convInfo);
      save([x4D, $filter]);
      return res2;
    };
    const inputs = {x: x4D, filter: $filter};
    const attrs = {strides, pad: pad8, dataFormat, dilations, dimRoundingMode};
    const res = ENGINE.runKernelFunc(forward, inputs, null, Conv2D, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const conv2d = op({conv2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv1d.js
  function conv1d_(x, filter, stride, pad8, dataFormat = "NWC", dilation = 1, dimRoundingMode) {
    const $x = convertToTensor(x, "x", "conv1d");
    const $filter = convertToTensor(filter, "filter", "conv1d");
    let x3D = $x;
    let reshapedTo3D = false;
    if ($x.rank === 2) {
      reshapedTo3D = true;
      x3D = reshape($x, [1, $x.shape[0], $x.shape[1]]);
    }
    assert(x3D.rank === 3, () => `Error in conv1d: input must be rank 3, but got rank ${x3D.rank}.`);
    assert($filter.rank === 3, () => `Error in conv1d: filter must be rank 3, but got rank ${$filter.rank}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in conv1d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    assert(x3D.shape[2] === $filter.shape[1], () => `Error in conv1d: depth of input (${x3D.shape[2]}) must match input depth for filter ${$filter.shape[1]}.`);
    assert(eitherStridesOrDilationsAreOne(stride, dilation), () => `Error in conv1D: Either stride or dilation must be 1. Got stride ${stride} and dilation '${dilation}'`);
    assert(dataFormat === "NWC", () => `Error in conv1d: got dataFormat of ${dataFormat} but only NWC is currently supported.`);
    const filter4D = reshape($filter, [1, $filter.shape[0], $filter.shape[1], $filter.shape[2]]);
    const input4D = reshape(x3D, [x3D.shape[0], 1, x3D.shape[1], x3D.shape[2]]);
    const strides = [1, stride];
    const dilations = [1, dilation];
    const conv2dDataFormat = "NHWC";
    const res = conv2d(input4D, filter4D, strides, pad8, conv2dDataFormat, dilations, dimRoundingMode);
    if (reshapedTo3D) {
      return reshape(res, [res.shape[2], res.shape[3]]);
    }
    return reshape(res, [res.shape[0], res.shape[2], res.shape[3]]);
  }
  const conv1d = op({conv1d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_backprop_input.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv2DBackpropInput_(xShape, dy, filter, strides, pad8, dataFormat = "NHWC", dimRoundingMode) {
    assert(xShape.length === dy.rank, () => `Length of inShape (${xShape.length}) and rank of dy (${dy.rank}) must match`);
    let xShape4D = xShape;
    let dy4D = dy;
    let reshapedTo4D = false;
    if (dy.rank === 3) {
      reshapedTo4D = true;
      dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
      xShape4D = [1, xShape[0], xShape[1], xShape[2]];
    }
    assert(xShape4D.length === 4, () => `Error in conv2dDerInput: inShape must be length 4, but got length ${xShape4D.length}.`);
    assert(dy4D.rank === 4, () => `Error in conv2dDerInput: dy must be rank 4, but got rank ${dy4D.rank}`);
    assert(filter.rank === 4, () => `Error in conv2dDerInput: filter must be rank 4, but got rank ${filter.rank}`);
    const inDepth = dataFormat === "NHWC" ? xShape4D[3] : xShape4D[1];
    const outDepth = dataFormat === "NHWC" ? dy4D.shape[3] : dy4D.shape[1];
    assert(inDepth === filter.shape[2], () => `Error in conv2dDerInput: depth of input (${inDepth}) must match input depth for filter ${filter.shape[2]}.`);
    assert(outDepth === filter.shape[3], () => `Error in conv2dDerInput: depth of output (${outDepth}) must match output depth for filter ${filter.shape[3]}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in conv2dDerInput: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      const dilations = 1;
      const $dataFormat = convertConv2DDataFormat(dataFormat);
      const convInfo = computeConv2DInfo(xShape4D, filter.shape, strides, dilations, pad8, dimRoundingMode, false, $dataFormat);
      const res2 = backend2.conv2dDerInput(dy4D, filter, convInfo);
      save([dy4D, filter]);
      return res2;
    };
    const inputs = {dy: dy4D, filter};
    const attrs = {strides, pad: pad8, dataFormat, dimRoundingMode, inputShape: xShape4D};
    const res = ENGINE.runKernelFunc(forward, inputs, null, Conv2DBackpropInput, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const conv2DBackpropInput = op({conv2DBackpropInput_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_transpose.js
  function conv2dTranspose_(x, filter, outputShape, strides, pad8, dimRoundingMode) {
    const $x = convertToTensor(x, "x", "conv2dTranspose");
    const $filter = convertToTensor(filter, "filter", "conv2dTranspose");
    return conv2DBackpropInput(outputShape, $x, $filter, strides, pad8, "NHWC", dimRoundingMode);
  }
  const conv2dTranspose = op({conv2dTranspose_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv3d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv3d_(x, filter, strides, pad8, dataFormat = "NDHWC", dilations = [1, 1, 1]) {
    const $x = convertToTensor(x, "x", "conv3d");
    const $filter = convertToTensor(filter, "filter", "conv3d");
    let x5D = $x;
    let reshapedTo5D = false;
    if ($x.rank === 4) {
      reshapedTo5D = true;
      x5D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]);
    }
    assert(x5D.rank === 5, () => `Error in conv3d: input must be rank 5, but got rank ${x5D.rank}.`);
    assert($filter.rank === 5, () => `Error in conv3d: filter must be rank 5, but got rank ${$filter.rank}.`);
    assert(x5D.shape[4] === $filter.shape[3], () => `Error in conv3d: depth of input (${x5D.shape[4]}) must match input depth for filter ${$filter.shape[3]}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in conv3D: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    assert(dataFormat === "NDHWC", () => `Error in conv3d: got dataFormat of ${dataFormat} but only NDHWC is currently supported.`);
    const forward = (backend2, save) => {
      const convInfo = computeConv3DInfo(x5D.shape, $filter.shape, strides, dilations, pad8);
      const res2 = backend2.conv3d(x5D, $filter, convInfo);
      save([x5D, $filter]);
      return res2;
    };
    const inputs = {x: x5D, filter: $filter};
    const attrs = {strides, pad: pad8, dataFormat, dilations};
    const res = ENGINE.runKernelFunc(forward, inputs, null, Conv3D, attrs);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const conv3d = op({conv3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_backprop_input.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv3DBackpropInput_(xShape, dy, filter, strides, pad8) {
    assert(xShape.length === dy.rank, () => `Length of inShape (${xShape.length}) and rank of dy (${dy.rank}) must match`);
    let xShape5D = xShape;
    let dy5D = dy;
    let reshapedTo5D = false;
    if (dy.rank === 4) {
      reshapedTo5D = true;
      dy5D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
      xShape5D = [1, xShape[0], xShape[1], xShape[2], xShape[3]];
    }
    const inDepth = xShape5D[4];
    const outDepth = dy5D.shape[4];
    assert(xShape5D.length === 5, () => `Error in conv3dDerInput: inShape must be length 5, but got length ${xShape5D.length}.`);
    assert(dy5D.rank === 5, () => `Error in conv3dDerInput: dy must be rank 5, but got rank ${dy5D.rank}`);
    assert(filter.rank === 5, () => `Error in conv3dDerInput: filter must be rank 5, but got rank ${filter.rank}`);
    assert(inDepth === filter.shape[3], () => `Error in conv3dDerInput: depth of input (${inDepth}) must match input depth for filter ${filter.shape[3]}.`);
    assert(outDepth === filter.shape[4], () => `Error in conv3dDerInput: depth of output (${outDepth}) must match output depth for filter ${filter.shape[4]}.`);
    const forward = (backend2) => {
      const dilations = 1;
      const convInfo = computeConv3DInfo(xShape5D, filter.shape, strides, dilations, pad8);
      return backend2.conv3dDerInput(dy5D, filter, convInfo);
    };
    const inputs = {dy: dy5D};
    const attrs = {pad: pad8};
    const res = ENGINE.runKernelFunc(forward, inputs, null, Conv3DBackpropInputV2, attrs);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const conv3DBackpropInput = op({conv3DBackpropInput_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_transpose.js
  function conv3dTranspose_(x, filter, outputShape, strides, pad8) {
    const $x = convertToTensor(x, "x", "conv3dTranspose");
    const $filter = convertToTensor(filter, "filter", "conv3dTranspose");
    return conv3DBackpropInput(outputShape, $x, $filter, strides, pad8);
  }
  const conv3dTranspose = op({conv3dTranspose_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/cos.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function cos_(x) {
    const $x = convertToTensor(x, "x", "cos");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.cos($x);
      save([$x]);
      return res;
    }, inputs, null, Cos);
  }
  const cos = op({cos_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/cosh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function cosh_(x) {
    const $x = convertToTensor(x, "x", "cosh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.cosh($x);
      save([$x]);
      return res;
    }, inputs, null, Cosh);
  }
  const cosh = op({cosh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/cumsum.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function cumsum_(x, axis = 0, exclusive = false, reverse9 = false) {
    const $x = convertToTensor(x, "x", "cumsum");
    const forward = (backend2, save) => {
      const permutation = getAxesPermutation([axis], $x.rank);
      let permutedX = $x;
      if (permutation != null) {
        permutedX = transpose($x, permutation);
      }
      const permutedAxis = getInnerMostAxes(1, $x.rank)[0];
      let value = backend2.cumsum(permutedX, permutedAxis, exclusive, reverse9);
      save([$x]);
      if (permutation != null) {
        const reversePermutation = getUndoAxesPermutation(permutation);
        value = transpose(value, reversePermutation);
      }
      return value;
    };
    const inputs = {x: $x};
    const attrs = {axis, exclusive, reverse: reverse9};
    return ENGINE.runKernelFunc(forward, inputs, null, Cumsum, attrs);
  }
  const cumsum = op({cumsum_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/depth_to_space.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function depthToSpace_(x, blockSize, dataFormat = "NHWC") {
    const $x = convertToTensor(x, "x", "depthToSpace");
    const inputHeight = dataFormat === "NHWC" ? $x.shape[1] : $x.shape[2];
    const inputWidth = dataFormat === "NHWC" ? $x.shape[2] : $x.shape[3];
    const inputDepth = dataFormat === "NHWC" ? $x.shape[3] : $x.shape[1];
    assert(inputHeight * blockSize >= 0, () => `Negative dimension size caused by overflow when multiplying
    ${inputHeight} and ${blockSize}  for depthToSpace with input shape
    ${$x.shape}`);
    assert(inputWidth * blockSize >= 0, () => `Negative dimension size caused by overflow when multiplying
    ${inputWidth} and ${blockSize} for depthToSpace with input shape
        ${$x.shape}`);
    assert(inputDepth % (blockSize * blockSize) === 0, () => `Dimension size must be evenly divisible by ${blockSize * blockSize} but is ${inputDepth} for depthToSpace with input shape ${$x.shape}`);
    const forward = (backend2) => backend2.depthToSpace($x, blockSize, dataFormat);
    const inputs = {x: $x};
    const attrs = {blockSize, dataFormat};
    return ENGINE.runKernelFunc(forward, inputs, null, DepthToSpace, attrs);
  }
  const depthToSpace = op({depthToSpace_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function depthwiseConv2d_(x, filter, strides, pad8, dataFormat = "NHWC", dilations = [1, 1], dimRoundingMode) {
    const $x = convertToTensor(x, "x", "depthwiseConv2d");
    const $filter = convertToTensor(filter, "filter", "depthwiseConv2d");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in depthwiseConv2d: input must be rank 4, but got rank ${x4D.rank}.`);
    assert($filter.rank === 4, () => `Error in depthwiseConv2d: filter must be rank 4, but got rank ${$filter.rank}.`);
    assert(x4D.shape[3] === $filter.shape[2], () => `Error in depthwiseConv2d: number of input channels (${x4D.shape[3]}) must match the inChannels dimension in filter ${$filter.shape[2]}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in depthwiseConv2d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      if (dilations == null) {
        dilations = [1, 1];
      }
      assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in depthwiseConv2d: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
      const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad8, dimRoundingMode, true);
      const res2 = backend2.depthwiseConv2D(x4D, $filter, convInfo);
      save([x4D, $filter]);
      return res2;
    };
    const inputs = {x: x4D, filter: $filter};
    const attrs = {strides, pad: pad8, dataFormat, dilations, dimRoundingMode};
    const res = ENGINE.runKernelFunc(forward, inputs, null, DepthwiseConv2dNative, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const depthwiseConv2d = op({depthwiseConv2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/diag.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function diag_(x) {
    const $x = convertToTensor(x, "x", "diag");
    const forward = (backend2) => {
      const flat = reshape($x, [$x.size]);
      const result = backend2.diag(flat);
      const outShape = [...x.shape, ...x.shape];
      return reshape(result, outShape);
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Diag);
  }
  const diag = op({diag_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/dilation2d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function dilation2d_(x, filter, strides, pad8, dilations = [1, 1], dataFormat = "NHWC") {
    const $x = convertToTensor(x, "x", "dilation2d");
    const $filter = convertToTensor(filter, "filter", "dilation2d");
    assert($x.rank === 3 || $x.rank === 4, () => `Error in dilation2d: input must be rank 3 or 4, but got rank ${$x.rank}.`);
    assert($filter.rank === 3, () => `Error in dilation2d: filter must be rank 3, but got rank ${$filter.rank}.`);
    assert(dataFormat === "NHWC", () => `Error in dilation2d: Only NHWC is currently supported, but got dataFormat of ${dataFormat}`);
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
      reshapedTo4D = true;
    }
    const inputs = {x: x4D, filter: $filter};
    const attrs = {strides, pad: pad8, dilations};
    const res = ENGINE.runKernel(Dilation2D, inputs, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const dilation2d = op({dilation2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/broadcast_util.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getBroadcastDims(inShape, outShape) {
    const inRank = inShape.length;
    const dims = [];
    for (let i = 0; i < inRank; i++) {
      const dim = inRank - 1 - i;
      const a = inShape[dim] || 1;
      const b = outShape[outShape.length - 1 - i] || 1;
      if (b > 1 && a === 1) {
        dims.unshift(dim);
      }
    }
    return dims;
  }
  function getReductionAxes(inShape, outShape) {
    const result = [];
    for (let i = 0; i < outShape.length; i++) {
      const inDim = inShape[inShape.length - i - 1];
      const outAxis = outShape.length - i - 1;
      const outDim = outShape[outAxis];
      if (inDim == null || inDim === 1 && outDim > 1) {
        result.unshift(outAxis);
      }
    }
    return result;
  }
  function assertAndGetBroadcastShape(shapeA, shapeB) {
    const result = [];
    const l = Math.max(shapeA.length, shapeB.length);
    for (let i = 0; i < l; i++) {
      let a = shapeA[shapeA.length - i - 1];
      if (a == null) {
        a = 1;
      }
      let b = shapeB[shapeB.length - i - 1];
      if (b == null) {
        b = 1;
      }
      if (a === 1) {
        result.unshift(b);
      } else if (b === 1) {
        result.unshift(a);
      } else if (a !== b) {
        const errMsg = `Operands could not be broadcast together with shapes ${shapeA} and ${shapeB}.`;
        throw Error(errMsg);
      } else {
        result.unshift(a);
      }
    }
    return result;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/equal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function equal_(a, b) {
    let $a = convertToTensor(a, "a", "equal");
    let $b = convertToTensor(b, "b", "equal");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2) => backend2.equal($a, $b);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Equal);
  }
  const equal = op({equal_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/where.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function where_(condition, a, b) {
    const $a = convertToTensor(a, "a", "where");
    const $b = convertToTensor(b, "b", "where");
    const $condition = convertToTensor(condition, "condition", "where", "bool");
    const broadcastShape = assertAndGetBroadcastShape($a.shape, $b.shape);
    const $broadcastedA = broadcastTo($a, broadcastShape);
    const $broadcastedB = broadcastTo($b, broadcastShape);
    if ($condition.rank === 1) {
      assert($condition.shape[0] === $a.shape[0], () => "The first dimension of `a` must match the size of `condition`.");
    }
    if ($condition.rank !== 1) {
      assertShapesMatch($condition.shape, $broadcastedB.shape, "Error in where: ");
    }
    const forward = (backend2, save) => {
      const res = backend2.select($condition, $broadcastedA, $broadcastedB);
      save([$condition]);
      return res;
    };
    const inputs = {
      condition: $condition,
      t: $broadcastedA,
      e: $broadcastedB
    };
    return ENGINE.runKernelFunc(forward, inputs, null, SelectV2);
  }
  const where = op({where_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/zeros_like.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function zerosLike_(x) {
    const $x = convertToTensor(x, "x", "zerosLike");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.zerosLike($x), inputs, null, ZerosLike);
  }
  const zerosLike = op({zerosLike_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/div_no_nan.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function divNoNan_(a, b) {
    let $a = convertToTensor(a, "a", "div");
    let $b = convertToTensor(b, "b", "div");
    [$a, $b] = makeTypesMatch($a, $b);
    const divResult = div($a, $b);
    const zeros9 = zerosLike(divResult);
    const bEqualsZero = equal($b, zeros9);
    return where(bEqualsZero, zeros9, divResult);
  }
  const divNoNan = op({divNoNan_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/dot.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function dot_(t1, t2) {
    const $t1 = convertToTensor(t1, "t1", "dot");
    const $t2 = convertToTensor(t2, "t2", "dot");
    assert(($t1.rank === 1 || $t1.rank === 2) && ($t2.rank === 1 || $t2.rank === 2), () => `Error in dot: inputs must all be rank 1 or 2, but got ranks ${$t1.rank} and ${$t2.rank}.`);
    const t1Inner = $t1.rank === 1 ? $t1.size : $t1.shape[1];
    const t2Inner = $t2.rank === 1 ? $t2.size : $t2.shape[0];
    assert(t1Inner === t2Inner, () => `Error in dot: inner dimensions of inputs must match, but got ${t1Inner} and ${t2Inner}.`);
    if ($t1.rank === 1 && $t2.rank === 1) {
      const t12D = reshape($t1, [1, -1]);
      const t22D = reshape($t2, [-1, 1]);
      const t1t2 = matMul(t12D, t22D);
      return reshape(t1t2, []);
    } else if ($t1.rank === 1 && $t2.rank === 2) {
      const t12D = reshape($t1, [1, -1]);
      const t22D = reshape($t2, [$t2.shape[0], $t2.shape[1]]);
      const t1t2 = matMul(t12D, t22D);
      return reshape(t1t2, [t1t2.size]);
    } else if ($t1.rank === 2 && $t2.rank === 1) {
      const t22D = reshape($t2, [-1, 1]);
      const t1t2 = matMul($t1, t22D);
      return reshape(t1t2, [t1t2.size]);
    } else {
      const t22D = reshape($t2, [$t2.shape[0], $t2.shape[1]]);
      const t1t2 = matMul($t1, t22D);
      return t1t2;
    }
  }
  const dot = op({dot_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/elu.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function elu_(x) {
    const $x = convertToTensor(x, "x", "elu");
    const forward = (backend2, save) => {
      const y = backend2.elu($x);
      save([y]);
      return y;
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Elu);
  }
  const elu = op({elu_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/erf.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function erf_(x) {
    let $x = convertToTensor(x, "x", "erf");
    assert($x.dtype === "int32" || $x.dtype === "float32", () => "Input dtype must be `int32` or `float32`.");
    if ($x.dtype === "int32") {
      $x = cast($x, "float32");
    }
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.erf($x);
      save([$x]);
      return res;
    }, inputs, null, Erf);
  }
  const erf = op({erf_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/exp.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function exp_(x) {
    const $x = convertToTensor(x, "x", "exp");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.exp($x);
      save([res]);
      return res;
    }, inputs, null, Exp);
  }
  const exp = op({exp_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/expand_dims.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function expandDims_(x, axis = 0) {
    const parseAs = null;
    const $x = convertToTensor(x, "x", "expandDims", parseAs);
    assert(axis <= $x.rank, () => "Axis must be <= rank of the tensor");
    const newShape = $x.shape.slice();
    if (axis < 0) {
      assert(-($x.rank + 1) <= axis, () => `Axis must be in the interval [${-($x.rank + 1)}, ${$x.rank}]`);
      axis = $x.rank + axis + 1;
    }
    newShape.splice(axis, 0, 1);
    return reshape($x, newShape);
  }
  const expandDims = op({expandDims_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/expm1.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function expm1_(x) {
    const $x = convertToTensor(x, "x", "expm1");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.expm1($x);
      save([$x]);
      return res;
    }, inputs, null, Expm1);
  }
  const expm1 = op({expm1_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tile.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tile_(x, reps) {
    const parseAs = null;
    const $x = convertToTensor(x, "x", "tile", parseAs);
    assert($x.rank === reps.length, () => `Error in transpose: rank of input ${$x.rank} must match length of reps ${reps}.`);
    const forward = (backend2, save) => {
      const res = backend2.tile($x, reps);
      save([$x]);
      return res;
    };
    const inputsToSave = [$x];
    const inputs = {x: $x};
    const attrs = {reps};
    return ENGINE.runKernelFunc(forward, inputs, null, Tile, attrs, inputsToSave);
  }
  const tile = op({tile_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/eye.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function eye_(numRows, numColumns, batchShape, dtype = "float32") {
    if (numColumns == null) {
      numColumns = numRows;
    }
    const buff = buffer([numRows, numColumns], dtype);
    const n = numRows <= numColumns ? numRows : numColumns;
    for (let i = 0; i < n; ++i) {
      buff.set(1, i, i);
    }
    const out = reshape(buff.toTensor(), [numRows, numColumns]);
    if (batchShape == null) {
      return out;
    } else {
      if (batchShape.length === 1) {
        return tile(expandDims(out, 0), [batchShape[0], 1, 1]);
      } else if (batchShape.length === 2) {
        return tile(expandDims(expandDims(out, 0), 0), [batchShape[0], batchShape[1], 1, 1]);
      } else if (batchShape.length === 3) {
        return tile(expandDims(expandDims(expandDims(out, 0), 0), 0), [
          batchShape[0],
          batchShape[1],
          batchShape[2],
          1,
          1
        ]);
      } else {
        throw new Error(`eye() currently supports only 1D and 2D batchShapes, but received ${batchShape.length}D.`);
      }
    }
  }
  const eye = op({eye_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/fill.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function fill(shape, value, dtype) {
    const attrs = {shape, value, dtype};
    return ENGINE.runKernelFunc((backend2) => backend2.fill(shape, value, dtype), {}, null, Fill, attrs);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/floor.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function floor_(x) {
    const $x = convertToTensor(x, "x", "floor");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.floor($x), inputs, null, Floor);
  }
  const floor = op({floor_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reduce_util.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const PARALLELIZE_THRESHOLD = 30;
  function computeOptimalWindowSize(inSize) {
    if (inSize <= PARALLELIZE_THRESHOLD) {
      return inSize;
    }
    return nearestDivisor(inSize, Math.floor(Math.sqrt(inSize)));
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/segment_util.js
  const segment_util_exports = {};
  __export(segment_util_exports, {
    collectGatherOpShapeInfo: () => collectGatherOpShapeInfo,
    computeOutShape: () => computeOutShape3,
    segOpComputeOptimalWindowSize: () => segOpComputeOptimalWindowSize
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function segOpComputeOptimalWindowSize(inSize, numSegments) {
    let done = false;
    let res;
    if (inSize <= PARALLELIZE_THRESHOLD) {
      res = inSize;
      done = true;
    } else {
      res = nearestDivisor(inSize, Math.floor(Math.sqrt(inSize)));
    }
    while (!done) {
      if (res > numSegments || res === inSize) {
        done = true;
      } else {
        res = nearestDivisor(inSize, res + 1);
      }
    }
    return res;
  }
  function computeOutShape3(aShape, axis, numSegments) {
    const outShape = [];
    const rank = aShape.length;
    for (let dim = 0; dim < rank; dim++) {
      if (dim !== axis) {
        outShape.push(aShape[dim]);
      } else {
        outShape.push(numSegments);
      }
    }
    return outShape;
  }
  function collectGatherOpShapeInfo(x, indices, axis) {
    const dimSize = x.shape[axis];
    const outputShape = [];
    let batchSize = 1;
    let sliceSize = 1;
    for (let i = 0; i < axis; i++) {
      outputShape.push(x.shape[i]);
      batchSize *= x.shape[i];
    }
    for (let i = 0; i < indices.rank; i++) {
      outputShape.push(indices.shape[i]);
    }
    for (let i = axis + 1; i < x.rank; i++) {
      outputShape.push(x.shape[i]);
      sliceSize *= x.shape[i];
    }
    return {batchSize, sliceSize, dimSize, outputShape};
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/gather.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function gather_(x, indices, axis = 0) {
    const $x = convertToTensor(x, "x", "gather");
    const $indices = convertToTensor(indices, "indices", "gather", "int32");
    const inputs = {x: $x, indices: $indices};
    const attrs = {axis};
    const forward = (backend2, save) => {
      const parsedAxis = parseAxisParam(axis, $x.shape)[0];
      const shapeInfo = collectGatherOpShapeInfo($x, $indices, parsedAxis);
      const res = backend2.gather($x, reshape($indices, [$indices.size]), parsedAxis);
      save([$x, $indices]);
      return reshape(res, shapeInfo.outputShape);
    };
    return ENGINE.runKernelFunc(forward, inputs, null, GatherV2, attrs);
  }
  const gather = op({gather_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/greater.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function greater_(a, b) {
    let $a = convertToTensor(a, "a", "greater");
    let $b = convertToTensor(b, "b", "greater");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2) => backend2.greater($a, $b);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Greater);
  }
  const greater = op({greater_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/greater_equal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function greaterEqual_(a, b) {
    let $a = convertToTensor(a, "a", "greaterEqual");
    let $b = convertToTensor(b, "b", "greaterEqual");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2, save) => {
      const res = backend2.greaterEqual($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, GreaterEqual);
  }
  const greaterEqual = op({greaterEqual_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/imag.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function imag_(input) {
    const $input = convertToTensor(input, "input", "imag");
    const forward = (backend2) => {
      return backend2.imag($input);
    };
    const inputs = {input: $input};
    return ENGINE.runKernelFunc(forward, inputs, null, Imag);
  }
  const imag = op({imag_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/is_finite.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function isFinite_(x) {
    const $x = convertToTensor(x, "x", "isFinite");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.isFinite($x), inputs, null, IsFinite);
  }
  const isFinite2 = op({isFinite_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/is_inf.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function isInf_(x) {
    const $x = convertToTensor(x, "x", "isInf");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.isInf($x), inputs, null, IsInf);
  }
  const isInf = op({isInf_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/is_nan.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function isNaN_(x) {
    const $x = convertToTensor(x, "x", "isNaN");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.isNaN($x), inputs, null, IsNan);
  }
  const isNaN2 = op({isNaN_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/maximum.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maximum_(a, b) {
    let $a = convertToTensor(a, "a", "maximum");
    let $b = convertToTensor(b, "b", "maximum");
    [$a, $b] = makeTypesMatch($a, $b);
    if ($a.dtype === "bool") {
      $a = cast($a, "int32");
      $b = cast($b, "int32");
    }
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2, save) => {
      const res = backend2.maximum($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Maximum);
  }
  const maximum = op({maximum_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/scalar.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function scalar(value, dtype) {
    if ((isTypedArray(value) && dtype !== "string" || Array.isArray(value)) && dtype !== "complex64") {
      throw new Error("Error creating a new Scalar: value must be a primitive (number|boolean|string)");
    }
    if (dtype === "string" && isTypedArray(value) && !(value instanceof Uint8Array)) {
      throw new Error("When making a scalar from encoded string, the value must be `Uint8Array`.");
    }
    const shape = [];
    const inferredShape = [];
    return makeTensor(value, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/leaky_relu.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function leakyRelu_(x, alpha = 0.2) {
    const $x = convertToTensor(x, "x", "leakyRelu");
    return maximum(mul(scalar(alpha), $x), $x);
  }
  const leakyRelu = op({leakyRelu_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/less.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function less_(a, b) {
    let $a = convertToTensor(a, "a", "less");
    let $b = convertToTensor(b, "b", "less");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2) => backend2.less($a, $b);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Less);
  }
  const less = op({less_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/less_equal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function lessEqual_(a, b) {
    let $a = convertToTensor(a, "a", "lessEqual");
    let $b = convertToTensor(b, "b", "lessEqual");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2, save) => {
      const res = backend2.lessEqual($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, LessEqual);
  }
  const lessEqual = op({lessEqual_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/linspace.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function linspace(start, stop, num) {
    if (num <= 0) {
      throw new Error("The number of values should be positive.");
    }
    const attrs = {start, stop, num};
    return ENGINE.runKernelFunc((backend2) => backend2.linspace(start, stop, num), {}, null, LinSpace, attrs);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/local_response_normalization.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function localResponseNormalization_(x, depthRadius = 5, bias = 1, alpha = 1, beta = 0.5) {
    const $x = convertToTensor(x, "x", "localResponseNormalization");
    assert($x.rank === 4 || $x.rank === 3, () => `Error in localResponseNormalization: x must be rank 3 or 4 but got
               rank ${$x.rank}.`);
    assert(isInt(depthRadius), () => `Error in localResponseNormalization: depthRadius must be an integer but got depthRadius ${depthRadius}.`);
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    const forward = (backend2, save) => {
      const y = backend2.localResponseNormalization4D(x4D, depthRadius, bias, alpha, beta);
      save([x4D, y]);
      return y;
    };
    const inputs = {x: x4D};
    const attrs = {depthRadius, bias, alpha, beta};
    const res = ENGINE.runKernelFunc(forward, inputs, null, LRN, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    } else {
      return res;
    }
  }
  const localResponseNormalization = op({localResponseNormalization_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/log.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function log_(x) {
    const $x = convertToTensor(x, "x", "log");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.log($x);
      save([$x]);
      return res;
    }, inputs, null, Log);
  }
  const log = op({log_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/log1p.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function log1p_(x) {
    const $x = convertToTensor(x, "x", "log1p");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.log1p($x);
      save([$x]);
      return res;
    }, inputs, null, Log1p);
  }
  const log1p = op({log1p_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function grad(f) {
    assert(isFunction(f), () => "The f passed in grad(f) must be a function");
    return (x, dy) => {
      const $x = convertToTensor(x, "x", "tf.grad", null);
      const $dy = dy != null ? convertToTensor(dy, "dy", "tf.grad") : null;
      return ENGINE.tidy(() => {
        const {value, grads: grads2} = ENGINE.gradients(() => f($x), [$x], $dy);
        if ($dy != null) {
          assertShapesMatch(value.shape, $dy.shape, "The shape of dy passed in grad(f)(x, dy) must match the shape returned by f(x)");
        }
        checkGrads(grads2);
        return grads2[0];
      });
    };
  }
  function grads(f) {
    assert(isFunction(f), () => "The f passed in grads(f) must be a function");
    return (args, dy) => {
      assert(Array.isArray(args), () => "The args passed in grads(f)(args) must be an array of `Tensor`s or `TensorLike`s");
      const $args = convertToTensorArray(args, "args", "tf.grads", null);
      const $dy = dy != null ? convertToTensor(dy, "dy", "tf.grads") : null;
      return ENGINE.tidy(() => {
        const {value, grads: grads2} = ENGINE.gradients(() => f(...$args), $args, $dy);
        if ($dy != null) {
          assertShapesMatch(value.shape, $dy.shape, "The shape of dy passed in grads(f)([x1,...], dy) must match the shape returned by f([x1,...])");
        }
        checkGrads(grads2);
        return grads2;
      });
    };
  }
  function valueAndGrad(f) {
    assert(isFunction(f), () => "The f passed in valueAndGrad(f) must be a function");
    return (x, dy) => {
      assert(x instanceof Tensor, () => "The x passed in valueAndGrad(f)(x) must be a tensor");
      assert(dy == null || dy instanceof Tensor, () => "The dy passed in valueAndGrad(f)(x, dy) must be a tensor");
      const {grads: grads2, value} = ENGINE.gradients(() => f(x), [x], dy);
      checkGrads(grads2);
      return {grad: grads2[0], value};
    };
  }
  function valueAndGrads(f) {
    assert(isFunction(f), () => "The f passed in valueAndGrads(f) must be a function");
    return (args, dy) => {
      assert(Array.isArray(args) && args.every((arg) => arg instanceof Tensor), () => "The args passed in valueAndGrads(f)(args) must be array of tensors");
      assert(dy == null || dy instanceof Tensor, () => "The dy passed in valueAndGrads(f)(args, dy) must be a tensor");
      const res = ENGINE.gradients(() => f(...args), args, dy);
      if (dy != null) {
        assertShapesMatch(res.value.shape, dy.shape, "The shape of dy passed in valueAndGrads(f)([x1,...], dy) must match the shape returned by f([x1,...])");
      }
      checkGrads(res.grads);
      return res;
    };
  }
  function variableGrads(f, varList) {
    assert(isFunction(f), () => "The f passed in variableGrads(f) must be a function");
    assert(varList == null || Array.isArray(varList) && varList.every((v) => v instanceof Variable), () => "The varList passed in variableGrads(f, varList) must be an array of variables");
    const specifiedVarList = varList != null;
    if (!specifiedVarList) {
      varList = [];
      for (const varName in ENGINE.registeredVariables) {
        varList.push(ENGINE.registeredVariables[varName]);
      }
    }
    const specifiedNonTrainable = specifiedVarList ? varList.filter((variable3) => !variable3.trainable) : null;
    const originalVarCount = varList.length;
    varList = varList.filter((variable3) => variable3.trainable);
    assert(varList.length > 0, () => `variableGrads() expects at least one of the input variables to be trainable, but none of the ${originalVarCount} variables is trainable.`);
    const allowNoGradients = true;
    const {value, grads: grads2} = ENGINE.gradients(f, varList, null, allowNoGradients);
    assert(grads2.some((g) => g != null), () => "Cannot find a connection between any variable and the result of the loss function y=f(x). Please make sure the operations that use variables are inside the function f passed to minimize().");
    assert(value.rank === 0, () => `The f passed in variableGrads(f) must return a scalar, but it returned a rank-${value.rank} tensor`);
    const namedGrads = {};
    varList.forEach((v, i) => {
      if (grads2[i] != null) {
        namedGrads[v.name] = grads2[i];
      }
    });
    if (specifiedNonTrainable != null) {
      specifiedNonTrainable.forEach((v) => namedGrads[v.name] = null);
    }
    return {value, grads: namedGrads};
  }
  function customGrad(f) {
    return ENGINE.customGrad(f);
  }
  function checkGrads(grads2) {
    const numNullGradients = grads2.filter((g) => g == null).length;
    if (numNullGradients > 0) {
      throw new Error(`Cannot compute gradient of y=f(x) with respect to x. Make sure that
    the f you passed encloses all operations that lead from x to y.`);
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/neg.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function neg_(x) {
    const $x = convertToTensor(x, "x", "neg");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.neg($x), inputs, null, Negate);
  }
  const neg = op({neg_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/softplus.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function softplus_(x) {
    const $x = convertToTensor(x, "x", "softplus");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.softplus($x);
      save([$x]);
      return res;
    }, inputs, null, Softplus);
  }
  const softplus = op({softplus_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/log_sigmoid.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logSigmoid_(x) {
    const $x = convertToTensor(x, "x", "logSigmoid");
    const customOp = customGrad((x2) => {
      const value = neg(softplus(neg(x2)));
      const gradFunc = (dy) => {
        const derX = mul(dy, sigmoid(neg(x2)));
        return derX;
      };
      return {value, gradFunc};
    });
    return customOp($x);
  }
  const logSigmoid = op({logSigmoid_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/max.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function max_(x, axis = null, keepDims = false) {
    const $x = convertToTensor(x, "x", "max");
    const forward = (backend2, save) => {
      const origAxes = parseAxisParam(axis, $x.shape);
      let axes = origAxes;
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      let maxInput = $x;
      if (permutedAxes != null) {
        maxInput = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, maxInput.rank);
      }
      const y = backend2.max(maxInput, axes);
      if (permutedAxes != null) {
        maxInput.dispose();
      }
      let res = y;
      if (keepDims) {
        const expandedShape = expandShapeToKeepDim(res.shape, parseAxisParam(axis, $x.shape));
        res = reshape(res, expandedShape);
        y.dispose();
      }
      save([$x, res]);
      return res;
    };
    const inputs = {x: $x};
    const attrs = {reductionIndices: axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, Max, attrs);
  }
  const max = op({max_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sub.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sub_(a, b) {
    let $a = convertToTensor(a, "a", "sub");
    let $b = convertToTensor(b, "b", "sub");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.subtract($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Sub);
  }
  const sub = op({sub_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sum.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sum_(x, axis = null, keepDims = false) {
    let $x = convertToTensor(x, "x", "sum");
    if ($x.dtype === "bool") {
      $x = cast($x, "int32");
    }
    const forward = (backend2, save) => {
      save([$x]);
      const axes = parseAxisParam(axis, $x.shape);
      const permutation = getAxesPermutation(axes, $x.rank);
      let reductionAxes = axes;
      let permutedX = $x;
      if (permutation != null) {
        permutedX = transpose($x, permutation);
        reductionAxes = getInnerMostAxes(reductionAxes.length, $x.rank);
      }
      let value = backend2.sum(permutedX, reductionAxes);
      if (keepDims) {
        const newShape = expandShapeToKeepDim(value.shape, axes);
        value = reshape(value, newShape);
      }
      return value;
    };
    const inputs = {x: $x};
    const attrs = {axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, Sum, attrs);
  }
  const sum2 = op({sum_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/log_softmax.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logSoftmax_(logits, axis = -1) {
    const $logits = convertToTensor(logits, "logits", "logSoftmax");
    if (axis === -1) {
      axis = $logits.rank - 1;
    }
    if (axis !== $logits.rank - 1) {
      throw Error(`Log Softmax along a non-last dimension is not yet supported. Logits was rank ${$logits.rank} and axis was ${axis}`);
    }
    const forward = (backend2, save) => {
      const keepDims = true;
      const xMax = max(logits, axis, true);
      const shifted = sub(logits, xMax);
      const value = sub(cast(shifted, "float32"), log(sum2(exp(shifted), axis, keepDims)));
      save([value]);
      return value;
    };
    const inputs = {logits: $logits};
    const attrs = {axis};
    return ENGINE.runKernelFunc(forward, inputs, null, LogSoftmax, attrs);
  }
  const logSoftmax = op({logSoftmax_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/log_sum_exp.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logSumExp_(x, axis = null, keepDims = false) {
    const $x = convertToTensor(x, "x", "logSumExp");
    const axes = parseAxisParam(axis, $x.shape);
    const xMax = max($x, axes, true);
    const a = sub($x, xMax);
    const b = exp(a);
    const c = sum2(b, axes);
    const d = log(c);
    const res = add2(reshape(xMax, d.shape), d);
    if (keepDims) {
      const newShape = expandShapeToKeepDim(res.shape, axes);
      return reshape(res, newShape);
    }
    return res;
  }
  const logSumExp = op({logSumExp_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/logical_and.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logicalAnd_(a, b) {
    const $a = convertToTensor(a, "a", "logicalAnd", "bool");
    const $b = convertToTensor(b, "b", "logicalAnd", "bool");
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc((backend2) => backend2.logicalAnd($a, $b), inputs, null, LogicalAnd);
  }
  const logicalAnd = op({logicalAnd_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/logical_not.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logicalNot_(x) {
    const $x = convertToTensor(x, "x", "logicalNot", "bool");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.logicalNot($x), inputs, null, LogicalNot);
  }
  const logicalNot = op({logicalNot_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/logical_or.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logicalOr_(a, b) {
    const $a = convertToTensor(a, "a", "logicalOr", "bool");
    const $b = convertToTensor(b, "b", "logicalOr", "bool");
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc((backend2) => backend2.logicalOr($a, $b), inputs, null, LogicalOr);
  }
  const logicalOr = op({logicalOr_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/logical_xor.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logicalXor_(a, b) {
    const $a = convertToTensor(a, "a", "logicalXor", "bool");
    const $b = convertToTensor(b, "b", "logicalXor", "bool");
    assertAndGetBroadcastShape($a.shape, $b.shape);
    return logicalAnd(logicalOr(a, b), logicalNot(logicalAnd(a, b)));
  }
  const logicalXor = op({logicalXor_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/max_pool.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maxPool_(x, filterSize, strides, pad8, dimRoundingMode) {
    const $x = convertToTensor(x, "x", "maxPool");
    const dilations = 1;
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in maxPool: input must be rank 4 but got rank ${x4D.rank}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in maxPool: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in maxPool: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      const convInfo = computePool2DInfo(x4D.shape, filterSize, strides, 1, pad8, dimRoundingMode);
      let y;
      if (convInfo.filterWidth === 1 && convInfo.filterHeight === 1 && arraysEqual(convInfo.inShape, convInfo.outShape)) {
        y = x4D.clone();
      } else {
        y = backend2.maxPool(x4D, convInfo);
      }
      save([x4D, y]);
      return y;
    };
    const inputs = {x: x4D};
    const attrs = {filterSize, strides, pad: pad8, dimRoundingMode};
    const res = ENGINE.runKernelFunc(forward, inputs, null, MaxPool, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const maxPool = op({maxPool_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_3d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maxPool3d_(x, filterSize = [1, 1, 1], strides, pad8, dimRoundingMode, dataFormat = "NDHWC", dilations) {
    if (dilations == null) {
      dilations = [1, 1, 1];
    } else {
      deprecationWarn("dilations is deprecated, this field will be gone in v3.0.0.");
    }
    const $x = convertToTensor(x, "x", "maxPool3d");
    let x5D = $x;
    let reshapedTo5D = false;
    if ($x.rank === 4) {
      reshapedTo5D = true;
      x5D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2], $x.shape[3]]);
    }
    assert(x5D.rank === 5, () => `Error in maxPool3d: x must be rank 5 but got rank ${x5D.rank}.`);
    assert(dataFormat === "NDHWC", () => `Error in maxPool3d: Only NDHWC is currently supported, but got dataFormat of ${dataFormat}`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in maxPool3d: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in maxPool3d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2, save) => {
      if (dilations == null) {
        dilations = [1, 1, 1];
      }
      const convInfo = computePool3DInfo(x5D.shape, filterSize, strides, dilations, pad8, dimRoundingMode, dataFormat);
      const y = backend2.maxPool3d(x5D, convInfo);
      save([x5D, y]);
      return y;
    };
    const inputs = {x: x5D};
    const attrs = {filterSize, strides, pad: pad8, dimRoundingMode, dataFormat, dilations};
    const res = ENGINE.runKernelFunc(forward, inputs, null, MaxPool3D, attrs);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const maxPool3d = op({maxPool3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_with_argmax.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maxPoolWithArgmax_(x, filterSize, strides, pad8, includeBatchInIndex = false) {
    const $x = convertToTensor(x, "x", "maxPoolWithArgmax");
    const inputs = {x: $x};
    const attrs = {filterSize, strides, pad: pad8, includeBatchInIndex};
    const result = ENGINE.runKernel(MaxPoolWithArgmax, inputs, attrs);
    return {result: result[0], indexes: result[1]};
  }
  const maxPoolWithArgmax = op({maxPoolWithArgmax_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/zeros.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function zeros(shape, dtype = "float32") {
    if (dtype === "complex64") {
      const real6 = zeros(shape, "float32");
      const imag6 = zeros(shape, "float32");
      return complex(real6, imag6);
    }
    const values = makeZerosTypedArray(sizeFromShape(shape), dtype);
    return ENGINE.makeTensor(values, shape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/ones.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function ones2(shape, dtype = "float32") {
    if (dtype === "complex64") {
      const real6 = ones2(shape, "float32");
      const imag6 = zeros(shape, "float32");
      return complex(real6, imag6);
    }
    const values = makeOnesTypedArray(sizeFromShape(shape), dtype);
    return ENGINE.makeTensor(values, shape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/mean.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function mean_(x, axis = null, keepDims = false) {
    const $x = convertToTensor(x, "x", "mean");
    const axes = parseAxisParam(axis, $x.shape);
    const shapes = computeOutAndReduceShapes($x.shape, axes);
    const reduceShape = shapes[1];
    const reduceSize = sizeFromShape(reduceShape);
    const customOp = customGrad((x2) => {
      const reduceSizeScalar = scalar(reduceSize);
      const xReduce = reduceSizeScalar.dtype === x2.dtype ? x2 : cast(x2, reduceSizeScalar.dtype);
      const res = div(xReduce, reduceSizeScalar);
      const value = sum2(res, axis, keepDims);
      const gradFunc = (dy) => {
        const expandedDyShape = x2.shape.slice();
        axes.forEach((axis2) => {
          expandedDyShape[axis2] = 1;
        });
        const expandedDy = reshape(dy, expandedDyShape);
        const derX = div(mul(expandedDy, ones2(x2.shape, "float32")), reduceSize);
        return derX;
      };
      return {value, gradFunc};
    });
    return customOp($x);
  }
  const mean = op({mean_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/min.js
  function min_(x, axis = null, keepDims = false) {
    const $x = convertToTensor(x, "x", "min");
    const forward = (backend2, save) => {
      const origAxes = parseAxisParam(axis, $x.shape);
      let axes = origAxes;
      const permutedAxes = getAxesPermutation(axes, $x.rank);
      let minInput = $x;
      if (permutedAxes != null) {
        minInput = transpose($x, permutedAxes);
        axes = getInnerMostAxes(axes.length, $x.rank);
      }
      const y = backend2.min(minInput, axes);
      if (permutedAxes != null) {
        minInput.dispose();
      }
      let res = y;
      if (keepDims) {
        const expandedShape = expandShapeToKeepDim(res.shape, origAxes);
        res = reshape(y, expandedShape);
        y.dispose();
      }
      save([$x, res]);
      return res;
    };
    const inputs = {x: $x};
    const attrs = {axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, Min, attrs);
  }
  const min = op({min_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/minimum.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function minimum_(a, b) {
    let $a = convertToTensor(a, "a", "minimum");
    let $b = convertToTensor(b, "b", "minimum");
    [$a, $b] = makeTypesMatch($a, $b);
    if ($a.dtype === "bool") {
      $a = cast($a, "int32");
      $b = cast($b, "int32");
    }
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2, save) => {
      const res = backend2.minimum($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Minimum);
  }
  const minimum = op({minimum_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/mod.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function mod_(a, b) {
    let $a = convertToTensor(a, "a", "mod");
    let $b = convertToTensor(b, "b", "mod");
    [$a, $b] = makeTypesMatch($a, $b);
    const forward = (backend2, save) => {
      const res = backend2.mod($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, Mod);
  }
  const mod = op({mod_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/square.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function square_(x) {
    const $x = convertToTensor(x, "x", "square");
    const attrs = {};
    const inputsToSave = [$x];
    const outputsToSave = [];
    return ENGINE.runKernelFunc((backend2, save) => {
      save([$x]);
      return backend2.square($x);
    }, {x: $x}, null, "Square", attrs, inputsToSave, outputsToSave);
  }
  const square = op({square_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/moments.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function moments_(x, axis = null, keepDims = false) {
    x = convertToTensor(x, "x", "moments");
    const axes = parseAxisParam(axis, x.shape);
    const xMean = mean(x, axes, keepDims);
    let keepDimsShape = xMean.shape;
    if (!keepDims) {
      keepDimsShape = expandShapeToKeepDim(xMean.shape, axes);
    }
    const devSquared = square(sub(cast(x, "float32"), reshape(xMean, keepDimsShape)));
    const variance = mean(devSquared, axes, keepDims);
    return {mean: xMean, variance};
  }
  const moments = op({moments_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/multi_rnn_cell.js
  function multiRNNCell_(lstmCells, data, c, h) {
    const $data = convertToTensor(data, "data", "multiRNNCell");
    const $c = convertToTensorArray(c, "c", "multiRNNCell");
    const $h = convertToTensorArray(h, "h", "multiRNNCell");
    let input = $data;
    const newStates = [];
    for (let i = 0; i < lstmCells.length; i++) {
      const output = lstmCells[i](input, $c[i], $h[i]);
      newStates.push(output[0]);
      newStates.push(output[1]);
      input = output[1];
    }
    const newC = [];
    const newH = [];
    for (let i = 0; i < newStates.length; i += 2) {
      newC.push(newStates[i]);
      newH.push(newStates[i + 1]);
    }
    return [newC, newH];
  }
  const multiRNNCell = op({multiRNNCell_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/multinomial.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function multinomial_(logits, numSamples, seed, normalized = false) {
    const $logits = convertToTensor(logits, "logits", "multinomial");
    const numOutcomes = $logits.size;
    const origRank = $logits.rank;
    if (numOutcomes < 2) {
      throw new Error(`Error in multinomial: you need at least 2 outcomes, but got ${numOutcomes}.`);
    }
    if (origRank > 2) {
      throw new Error(`Rank of probabilities must be 1 or 2, but is ${origRank}`);
    }
    seed = seed || Math.random();
    const logits2D = origRank === 1 ? reshape($logits, [1, -1]) : $logits;
    const res = ENGINE.runKernelFunc((backend2) => backend2.multinomial(logits2D, normalized, numSamples, seed), {logits2D});
    return origRank === 1 ? reshape(res, [res.size]) : res;
  }
  const multinomial = op({multinomial_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/not_equal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function notEqual_(a, b) {
    let $a = convertToTensor(a, "a", "notEqual");
    let $b = convertToTensor(b, "b", "notEqual");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2) => backend2.notEqual($a, $b);
    const inputs = {a: $a, b: $b};
    return ENGINE.runKernelFunc(forward, inputs, null, NotEqual);
  }
  const notEqual = op({notEqual_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/real.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function real_(input) {
    const $input = convertToTensor(input, "input", "real");
    const forward = (backend2) => {
      return backend2.real($input);
    };
    const inputs = {input: $input};
    return ENGINE.runKernelFunc(forward, inputs, null, Real);
  }
  const real = op({real_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/ones_like.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function onesLike_(x) {
    const $x = convertToTensor(x, "x", "onesLike");
    const forward = (backend2, save) => {
      if ($x.dtype === "complex64") {
        const r = onesLike(real($x));
        const i = zerosLike(imag($x));
        return complex(r, i);
      }
      return backend2.onesLike($x);
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, OnesLike);
  }
  const onesLike = op({onesLike_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/outer_product.js
  function outerProduct_(v1, v2) {
    const $v1 = convertToTensor(v1, "v1", "outerProduct");
    const $v2 = convertToTensor(v2, "v2", "outerProduct");
    assert($v1.rank === 1 && $v2.rank === 1, () => `Error in outerProduct: inputs must be rank 1, but got ranks ${$v1.rank} and ${$v2.rank}.`);
    const v12D = reshape($v1, [-1, 1]);
    const v22D = reshape($v2, [1, -1]);
    return matMul(v12D, v22D);
  }
  const outerProduct = op({outerProduct_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function pad_(x, paddings, constantValue = 0) {
    const $x = convertToTensor(x, "x", "pad");
    if ($x.rank === 0) {
      throw new Error("pad(scalar) is not defined. Pass non-scalar to pad");
    }
    const forward = (backend2, save) => {
      save([$x]);
      return backend2.pad($x, paddings, constantValue);
    };
    const attrs = {paddings, constantValue};
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, PadV2, attrs);
  }
  const pad = op({pad_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pad1d.js
  function pad1d_(x, paddings, constantValue = 0) {
    assert(paddings.length === 2, () => "Invalid number of paddings. Must be length of 2.");
    return pad(x, [paddings], constantValue);
  }
  const pad1d = op({pad1d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pad2d.js
  function pad2d_(x, paddings, constantValue = 0) {
    assert(paddings.length === 2 && paddings[0].length === 2 && paddings[1].length === 2, () => "Invalid number of paddings. Must be length of 2 each.");
    return pad(x, paddings, constantValue);
  }
  const pad2d = op({pad2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pad3d.js
  function pad3d_(x, paddings, constantValue = 0) {
    assert(paddings.length === 3 && paddings[0].length === 2 && paddings[1].length === 2 && paddings[2].length === 2, () => "Invalid number of paddings. Must be length of 2 each.");
    return pad(x, paddings, constantValue);
  }
  const pad3d = op({pad3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pad4d.js
  function pad4d_(x, paddings, constantValue = 0) {
    assert(paddings.length === 4 && paddings[0].length === 2 && paddings[1].length === 2 && paddings[2].length === 2 && paddings[3].length === 2, () => "Invalid number of paddings. Must be length of 2 each.");
    return pad(x, paddings, constantValue);
  }
  const pad4d = op({pad4d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/space_to_batch_nd.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function spaceToBatchND_(x, blockShape, paddings) {
    const $x = convertToTensor(x, "x", "spaceToBatchND");
    assert($x.rank >= 1 + blockShape.length, () => `input rank ${$x.rank} should be > than [blockShape] ${blockShape.length}`);
    assert(paddings.length === blockShape.length, () => `paddings.shape[0] ${paddings.length} must be equal to [blockShape] ${blockShape.length}`);
    assert($x.shape.reduce((a, b, i) => {
      if (i > 0 && i <= blockShape.length) {
        return a && (b + paddings[i - 1][0] + paddings[i - 1][1]) % blockShape[i - 1] === 0;
      }
      return a;
    }, true), () => `input spatial dimensions ${$x.shape.slice(1)} with paddings ${paddings.toString()} must be divisible by blockShapes ${blockShape.toString()}`);
    const forward = (backend2) => backend2.spaceToBatchND($x, blockShape, paddings);
    const inputs = {x: $x};
    const attrs = {blockShape, paddings};
    return ENGINE.runKernelFunc(forward, inputs, null, SpaceToBatchND, attrs);
  }
  const spaceToBatchND = op({spaceToBatchND_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pool.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function pool_(input, windowShape, poolingType, pad8, dilations, strides) {
    if (dilations == null) {
      dilations = [1, 1];
    }
    if (strides == null) {
      strides = 1;
    }
    if (pad8 === 0) {
      pad8 = "valid";
    }
    const $x = convertToTensor(input, "x", "maxPool");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in pool: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    const convInfo = computePool2DInfo(x4D.shape, windowShape, strides, dilations, pad8);
    const dilation = [convInfo.dilationHeight, convInfo.dilationWidth];
    let basePadding;
    if (pad8 === "same") {
      basePadding = withSpaceToBatchBasePaddings([convInfo.filterHeight, convInfo.filterWidth], dilation);
    } else {
      basePadding = [[0, 0], [0, 0]];
    }
    const isDilationOne = dilation[0] === 1 && dilation[1] === 1;
    const [adjustedPadding, adjustedCrops] = requiredSpaceToBatchPaddings([convInfo.inHeight, convInfo.inWidth], dilation, basePadding);
    const convertedPad = isDilationOne ? pad8 : "valid";
    const convertedX = isDilationOne ? x4D : spaceToBatchND(x4D, dilation, adjustedPadding);
    const forwardOp = poolingType === "avg" ? () => avgPool(convertedX, windowShape, strides, convertedPad) : () => maxPool(convertedX, windowShape, strides, convertedPad);
    const y = forwardOp();
    const res = isDilationOne ? y : batchToSpaceND(y, dilation, adjustedCrops);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  function requiredSpaceToBatchPaddings(inputShape, blockShape, basePadding) {
    const padStart = basePadding.map((b) => b[0]);
    const origPadEnd = basePadding.map((b) => b[1]);
    const fullInputShape = inputShape.concat(padStart, origPadEnd);
    const padEndExtra = blockShape.map((b, i) => (b - fullInputShape[i] % b) % b);
    const padEnd = origPadEnd.map((s, i) => s + padEndExtra[i]);
    const paddings = blockShape.map((_, i) => [padStart[i], padEnd[i]]);
    const crops = blockShape.map((_, i) => [0, padEndExtra[i]]);
    return [paddings, crops];
  }
  function withSpaceToBatchBasePaddings(filterShape, dilation) {
    const dilatedFilterShape = filterShape.map((s, i) => {
      return s + (s - 1) * (dilation[i] - 1);
    });
    const padExtraShape = dilatedFilterShape.map((s) => s - 1);
    const padExtraStart = padExtraShape.map((s) => Math.floor(s / 2));
    const padExtraEnd = padExtraShape.map((s, i) => s - padExtraStart[i]);
    return padExtraShape.map((_, i) => {
      return [padExtraStart[i], padExtraEnd[i]];
    });
  }
  const pool = op({pool_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/pow.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function pow_(base, exp11) {
    let $base = convertToTensor(base, "base", "pow");
    let $exp = convertToTensor(exp11, "exp", "pow");
    [$base, $exp] = makeTypesMatch($base, $exp);
    const inputs = {a: $base, b: $exp};
    const forward = (backend2, save) => {
      const y = backend2.pow($base, $exp);
      save([$base, $exp, y]);
      return y;
    };
    return ENGINE.runKernelFunc(forward, inputs, null, Pow);
  }
  const pow = op({pow_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/prelu.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function prelu_(x, alpha) {
    const $x = convertToTensor(x, "x", "prelu");
    const $alpha = convertToTensor(alpha, "alpha", "prelu");
    const forward = (backend2, save) => {
      const res = backend2.prelu($x, $alpha);
      save([$x, $alpha]);
      return res;
    };
    const inputs = {x: $x, alpha: $alpha};
    return ENGINE.runKernelFunc(forward, inputs, null, Prelu);
  }
  const prelu = op({prelu_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/prod.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function prod_(x, axis = null, keepDims = false) {
    let $x = convertToTensor(x, "x", "prod");
    const forward = (backend2) => {
      if ($x.dtype === "bool") {
        $x = cast($x, "int32");
      }
      const axes = parseAxisParam(axis, $x.shape);
      const permutation = getAxesPermutation(axes, $x.rank);
      let reductionAxes = axes;
      let permutedX = $x;
      if (permutation != null) {
        permutedX = transpose($x, permutation);
        reductionAxes = getInnerMostAxes(reductionAxes.length, $x.rank);
      }
      let value = backend2.prod(permutedX, reductionAxes);
      if (keepDims) {
        const newShape = expandShapeToKeepDim(value.shape, axes);
        value = reshape(value, newShape);
      }
      return value;
    };
    const inputs = {x: $x};
    const attrs = {axis, keepDims};
    return ENGINE.runKernelFunc(forward, inputs, null, Prod, attrs);
  }
  const prod = op({prod_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/rand.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function rand_(shape, randFunction, dtype) {
    const size = sizeFromShape(shape);
    let values = null;
    if (dtype == null || dtype === "float32") {
      values = new Float32Array(size);
    } else if (dtype === "int32") {
      values = new Int32Array(size);
    } else if (dtype === "bool") {
      values = new Uint8Array(size);
    } else {
      throw new Error(`Unknown data type ${dtype}`);
    }
    for (let i = 0; i < size; i++) {
      values[i] = randFunction();
    }
    return ENGINE.makeTensor(values, shape, dtype);
  }
  const rand = op({rand_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/rand_util.js
  const seedrandom = __toModule(require_seedrandom2());
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class MPRandGauss {
    constructor(mean5, stdDeviation, dtype, truncated, seed) {
      this.mean = mean5;
      this.stdDev = stdDeviation;
      this.dtype = dtype;
      this.nextVal = NaN;
      this.truncated = truncated;
      if (this.truncated) {
        this.upper = this.mean + this.stdDev * 2;
        this.lower = this.mean - this.stdDev * 2;
      }
      const seedValue = seed ? seed : Math.random();
      this.random = seedrandom.alea(seedValue.toString());
    }
    nextValue() {
      if (!isNaN(this.nextVal)) {
        const value = this.nextVal;
        this.nextVal = NaN;
        return value;
      }
      let resultX, resultY;
      let isValid = false;
      while (!isValid) {
        let v1, v2, s;
        do {
          v1 = 2 * this.random() - 1;
          v2 = 2 * this.random() - 1;
          s = v1 * v1 + v2 * v2;
        } while (s >= 1 || s === 0);
        const mul62 = Math.sqrt(-2 * Math.log(s) / s);
        resultX = this.mean + this.stdDev * v1 * mul62;
        resultY = this.mean + this.stdDev * v2 * mul62;
        if (!this.truncated || this.isValidTruncated(resultX)) {
          isValid = true;
        }
      }
      if (!this.truncated || this.isValidTruncated(resultY)) {
        this.nextVal = this.convertValue(resultY);
      }
      return this.convertValue(resultX);
    }
    convertValue(value) {
      if (this.dtype == null || this.dtype === "float32") {
        return value;
      }
      return Math.round(value);
    }
    isValidTruncated(value) {
      return value <= this.upper && value >= this.lower;
    }
  }
  class RandGamma {
    constructor(alpha, beta, dtype, seed) {
      this.alpha = alpha;
      this.beta = 1 / beta;
      this.dtype = dtype;
      const seedValue = seed ? seed : Math.random();
      this.randu = seedrandom.alea(seedValue.toString());
      this.randn = new MPRandGauss(0, 1, dtype, false, this.randu());
      if (alpha < 1) {
        this.d = alpha + 2 / 3;
      } else {
        this.d = alpha - 1 / 3;
      }
      this.c = 1 / Math.sqrt(9 * this.d);
    }
    nextValue() {
      let x2, v0, v1, x, u, v;
      while (true) {
        do {
          x = this.randn.nextValue();
          v = 1 + this.c * x;
        } while (v <= 0);
        v *= v * v;
        x2 = x * x;
        v0 = 1 - 0.331 * x2 * x2;
        v1 = 0.5 * x2 + this.d * (1 - v + Math.log(v));
        u = this.randu();
        if (u < v0 || Math.log(u) < v1) {
          break;
        }
      }
      v = 1 / this.beta * this.d * v;
      if (this.alpha < 1) {
        v *= Math.pow(this.randu(), 1 / this.alpha);
      }
      return this.convertValue(v);
    }
    convertValue(value) {
      if (this.dtype === "float32") {
        return value;
      }
      return Math.round(value);
    }
  }
  class UniformRandom {
    constructor(min4 = 0, max6 = 1, dtype, seed) {
      this.canReturnFloat = () => this.dtype == null || this.dtype === "float32";
      this.min = min4;
      this.range = max6 - min4;
      this.dtype = dtype;
      if (seed == null) {
        seed = Math.random();
      }
      if (typeof seed === "number") {
        seed = seed.toString();
      }
      if (!this.canReturnFloat() && this.range <= 1) {
        throw new Error(`The difference between ${min4} - ${max6} <= 1 and dtype is not float`);
      }
      this.random = seedrandom.alea(seed);
    }
    convertValue(value) {
      if (this.canReturnFloat()) {
        return value;
      }
      return Math.round(value);
    }
    nextValue() {
      return this.convertValue(this.min + this.range * this.random());
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/random_gamma.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function randomGamma_(shape, alpha, beta = 1, dtype = "float32", seed) {
    if (beta == null) {
      beta = 1;
    }
    if (dtype == null) {
      dtype = "float32";
    }
    if (dtype !== "float32" && dtype !== "int32") {
      throw new Error(`Unsupported data type ${dtype}`);
    }
    const rgamma = new RandGamma(alpha, beta, dtype, seed);
    const res = buffer(shape, dtype);
    for (let i = 0; i < res.values.length; i++) {
      res.values[i] = rgamma.nextValue();
    }
    return res.toTensor();
  }
  const randomGamma = op({randomGamma_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/random_normal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function randomNormal_(shape, mean5 = 0, stdDev = 1, dtype, seed) {
    if (dtype != null && dtype === "bool") {
      throw new Error(`Unsupported data type ${dtype}`);
    }
    const randGauss = new MPRandGauss(mean5, stdDev, dtype, false, seed);
    const res = buffer(shape, dtype);
    for (let i = 0; i < res.values.length; i++) {
      res.values[i] = randGauss.nextValue();
    }
    return res.toTensor();
  }
  const randomNormal = op({randomNormal_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/random_uniform.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function randomUniform_(shape, minval = 0, maxval = 1, dtype = "float32", seed) {
    const res = buffer(shape, dtype);
    const random = new UniformRandom(minval, maxval, null, seed);
    for (let i = 0; i < res.values.length; i++) {
      res.values[i] = random.nextValue();
    }
    return res.toTensor();
  }
  const randomUniform = op({randomUniform_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor1d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor1d(values, dtype) {
    assertNonNull(values);
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 1) {
      throw new Error("tensor1d() requires values to be a flat/TypedArray");
    }
    const shape = null;
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/range.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function range(start, stop, step7 = 1, dtype = "float32") {
    if (step7 === 0) {
      throw new Error("Cannot have a step of zero");
    }
    const forward = () => {
      const sameStartStop = start === stop;
      const increasingRangeNegativeStep = start < stop && step7 < 0;
      const decreasingRangePositiveStep = stop < start && step7 > 1;
      if (sameStartStop || increasingRangeNegativeStep || decreasingRangePositiveStep) {
        return zeros([0], dtype);
      }
      const numElements = Math.abs(Math.ceil((stop - start) / step7));
      const values = makeZerosTypedArray(numElements, dtype);
      if (stop < start && step7 === 1) {
        step7 = -1;
      }
      values[0] = start;
      for (let i = 1; i < values.length; i++) {
        values[i] = values[i - 1] + step7;
      }
      return tensor1d(values, dtype);
    };
    const attrs = {start, stop, step: step7, dtype};
    return ENGINE.runKernelFunc(forward, {}, null, Range, attrs);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/reciprocal.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reciprocal_(x) {
    const $x = convertToTensor(x, "x", "reciprocal");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.reciprocal($x);
      save([$x]);
      return res;
    }, inputs, null, Reciprocal);
  }
  const reciprocal = op({reciprocal_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/relu.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function relu_(x) {
    const $x = convertToTensor(x, "x", "relu");
    const forward = (backend2, save) => {
      save([$x]);
      if ($x.dtype === "bool") {
        return cast($x, "int32");
      }
      return backend2.relu($x);
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Relu);
  }
  const relu = op({relu_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/relu6.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function relu6_(x) {
    const $x = convertToTensor(x, "x", "relu6");
    const forward = (backend2, save) => {
      save([$x]);
      if ($x.dtype === "bool") {
        return cast($x, "int32");
      }
      return backend2.relu6($x);
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Relu6);
  }
  const relu6 = op({relu6_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reverse.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reverse_(x, axis) {
    const $x = convertToTensor(x, "x", "reverse");
    const forward = (backend2) => {
      const axes = parseAxisParam(axis, $x.shape);
      if ($x.rank === 0) {
        return clone($x);
      }
      const res = backend2.reverse($x, axes);
      return reshape(res, $x.shape);
    };
    const inputs = {x: $x};
    const attrs = {dims: axis};
    return ENGINE.runKernelFunc(forward, inputs, null, Reverse, attrs);
  }
  const reverse = op({reverse_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reverse_1d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reverse1d_(x) {
    const $x = convertToTensor(x, "x", "reverse");
    assert($x.rank === 1, () => `Error in reverse1D: x must be rank 1 but got rank ${$x.rank}.`);
    return reverse($x, 0);
  }
  const reverse1d = op({reverse1d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reverse_2d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reverse2d_(x, axis) {
    const $x = convertToTensor(x, "x", "reverse");
    assert($x.rank === 2, () => `Error in reverse2D: x must be rank 2 but got rank ${$x.rank}.`);
    return reverse($x, axis);
  }
  const reverse2d = op({reverse2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reverse_3d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reverse3d_(x, axis) {
    const $x = convertToTensor(x, "x", "reverse");
    assert($x.rank === 3, () => `Error in reverse3D: x must be rank 3 but got rank ${$x.rank}.`);
    return reverse($x, axis);
  }
  const reverse3d = op({reverse3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/reverse_4d.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function reverse4d_(x, axis) {
    const $x = convertToTensor(x, "x", "reverse");
    assert($x.rank === 4, () => `Error in reverse4D: x must be rank 4 but got rank ${$x.rank}.`);
    return reverse($x, axis);
  }
  const reverse4d = op({reverse4d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/round.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function round_(x) {
    const $x = convertToTensor(x, "x", "round");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.round($x), inputs, null, Round);
  }
  const round = op({round_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/rsqrt.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function rsqrt_(x) {
    const $x = convertToTensor(x, "x", "rsqrt");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.rsqrt($x);
      save([$x]);
      return res;
    }, inputs, null, Rsqrt);
  }
  const rsqrt = op({rsqrt_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/selu.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function selu_(x) {
    const $x = convertToTensor(x, "x", "selu");
    const forward = (backend2, save) => {
      const res = backend2.selu($x);
      save([$x]);
      return res;
    };
    const inputs = {x: $x};
    return ENGINE.runKernelFunc(forward, inputs, null, Selu);
  }
  const selu = op({selu_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/separable_conv2d.js
  function separableConv2d_(x, depthwiseFilter, pointwiseFilter, strides, pad8, dilation = [1, 1], dataFormat = "NHWC") {
    const $x = convertToTensor(x, "x", "separableConv2d");
    const $depthwiseFilter = convertToTensor(depthwiseFilter, "depthwiseFilter", "separableConv2d");
    const $pointwiseFilter = convertToTensor(pointwiseFilter, "pointwiseFilter", "separableConv2d");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    if (dataFormat === "NCHW") {
      throw new Error("separableConv2d currently does not support dataFormat NCHW; only NHWC is supported");
    }
    assert(x4D.rank === 4, () => `Error in separableConv2d: input must be rank 4, but got rank ${x4D.rank}.`);
    assert($depthwiseFilter.rank === 4, () => `Error in separableConv2d: depthwise filter must be rank 4, but got rank ${$depthwiseFilter.rank}.`);
    assert($pointwiseFilter.rank === 4, () => `Error in separableConv2d: pointwise filter must be rank 4, but got rank ${$depthwiseFilter.rank}.`);
    assert($pointwiseFilter.shape[0] === 1, () => `Error in separableConv2d: the first dimension of pointwise filter  must be 1, but got ${$pointwiseFilter.shape[0]}.`);
    assert($pointwiseFilter.shape[1] === 1, () => `Error in separableConv2d: the second dimension of pointwise filter must be 1, but got ${$pointwiseFilter.shape[1]}.`);
    const inChannels = $depthwiseFilter.shape[2];
    const channelMultiplier = $depthwiseFilter.shape[3];
    assert($pointwiseFilter.shape[2] === inChannels * channelMultiplier, () => `Error in separableConv2d: the third dimension of pointwise filter must be ${inChannels * channelMultiplier}, but got ${$pointwiseFilter.shape[2]}.`);
    const depthwise = depthwiseConv2d(x4D, $depthwiseFilter, strides, pad8, dataFormat, dilation);
    const pointwiseStride = 1;
    const res = conv2d(depthwise, $pointwiseFilter, pointwiseStride, "valid", dataFormat);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const separableConv2d = op({separableConv2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/setdiff1d_async.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function setdiff1dAsync_(x, y) {
    const $x = convertToTensor(x, "x", "setdiff1d");
    const $y = convertToTensor(y, "y", "setdiff1d");
    assert($x.dtype === $y.dtype, () => `x and y should have the same dtype, but got x (${$x.dtype}) and y (${$y.dtype}).`);
    assert($x.rank === 1, () => `x should be 1D tensor, but got x (${$x.shape}).`);
    assert($y.rank === 1, () => `y should be 1D tensor, but got y (${$y.shape}).`);
    const xVals = await $x.data();
    const yVals = await $y.data();
    const ySet = new Set(yVals);
    let outputSize = 0;
    for (let i = 0; i < xVals.length; i++) {
      if (!ySet.has(xVals[i])) {
        outputSize++;
      }
    }
    const buffer11 = new TensorBuffer([outputSize], $x.dtype);
    const indices = new TensorBuffer([outputSize], "int32");
    for (let i = 0, p = 0; i < xVals.length; i++) {
      if (!ySet.has(xVals[i])) {
        buffer11.values[p] = xVals[i];
        indices.values[p] = i;
        p++;
      }
    }
    return [buffer11.toTensor(), indices.toTensor()];
  }
  const setdiff1dAsync = setdiff1dAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/sign.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sign_(x) {
    const $x = convertToTensor(x, "x", "sign");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2) => backend2.sign($x), inputs, null, Sign);
  }
  const sign = op({sign_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sin.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sin_(x) {
    const $x = convertToTensor(x, "x", "sin");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.sin($x);
      save([$x]);
      return res;
    }, inputs, null, Sin);
  }
  const sin = op({sin_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sinh.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sinh_(x) {
    const $x = convertToTensor(x, "x", "sinh");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.sinh($x);
      save([$x]);
      return res;
    }, inputs, null, Sinh);
  }
  const sinh = op({sinh_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice1d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function slice1d_(x, begin, size) {
    const $x = convertToTensor(x, "x", "slice1d");
    assert($x.rank === 1, () => `slice1d expects a rank-1 tensor, but got a rank-${$x.rank} tensor`);
    return slice($x, [begin], [size]);
  }
  const slice1d = op({slice1d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice2d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function slice2d_(x, begin, size) {
    const $x = convertToTensor(x, "x", "slice2d");
    assert($x.rank === 2, () => `slice2d expects a rank-2 tensor, but got a rank-${$x.rank} tensor`);
    return slice($x, begin, size);
  }
  const slice2d = op({slice2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice3d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function slice3d_(x, begin, size) {
    const $x = convertToTensor(x, "x", "slice3d");
    assert($x.rank === 3, () => `slice3d expects a rank-3 tensor, but got a rank-${$x.rank} tensor`);
    return slice($x, begin, size);
  }
  const slice3d = op({slice3d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/slice4d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function slice4d_(x, begin, size) {
    const $x = convertToTensor(x, "x", "slice4d");
    assert($x.rank === 4, () => `slice4d expects a rank-4 tensor, but got a rank-${$x.rank} tensor`);
    return slice($x, begin, size);
  }
  const slice4d = op({slice4d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/softmax.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function softmax_(logits, dim = -1) {
    const $logits = convertToTensor(logits, "logits", "softmax", "float32");
    if (dim === -1) {
      dim = $logits.rank - 1;
    }
    if (dim !== $logits.rank - 1) {
      throw Error(`Softmax along a non-last dimension is not yet supported. Logits was rank ${$logits.rank} and dim was ${dim}`);
    }
    const inputs = {logits: $logits};
    const attrs = {dim};
    return ENGINE.runKernelFunc((backend2, save) => {
      const y = backend2.softmax($logits, dim);
      save([y]);
      return y;
    }, inputs, null, Softmax, attrs);
  }
  const softmax = op({softmax_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/spectral/fft.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function fft_(input) {
    assert(input.dtype === "complex64", () => `The dtype for tf.spectral.fft() must be complex64 but got ${input.dtype}.`);
    const inputs = {input};
    return ENGINE.runKernelFunc((backend2) => {
      const innerDimensionSize = input.shape[input.shape.length - 1];
      const batch = input.size / innerDimensionSize;
      const input2D = input.as2D(batch, innerDimensionSize);
      const result = backend2.fft(input2D);
      return result.reshape(input.shape);
    }, inputs, null, FFT);
  }
  const fft = op({fft_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/spectral/ifft.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function ifft_(input) {
    assert(input.dtype === "complex64", () => `The dtype for tf.spectral.ifft() must be complex64 but got ${input.dtype}.`);
    const inputs = {input};
    return ENGINE.runKernelFunc((backend2) => {
      const innerDimensionSize = input.shape[input.shape.length - 1];
      const batch = input.size / innerDimensionSize;
      const input2D = reshape(input, [batch, innerDimensionSize]);
      const result = backend2.ifft(input2D);
      return reshape(result, input.shape);
    }, inputs, null, IFFT);
  }
  const ifft = op({ifft_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/spectral/irfft.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function irfft_(input) {
    const innerDimensionSize = input.shape[input.shape.length - 1];
    const batch = input.size / innerDimensionSize;
    let ret;
    if (innerDimensionSize <= 2) {
      const complexInput = reshape(input, [batch, innerDimensionSize]);
      ret = ifft(complexInput);
    } else {
      const outputShape = [batch, 2 * (innerDimensionSize - 1)];
      const realInput = reshape(real(input), [batch, innerDimensionSize]);
      const imagInput = reshape(imag(input), [batch, innerDimensionSize]);
      const realConjugate = reverse(slice(realInput, [0, 1], [batch, innerDimensionSize - 2]), 1);
      const imagConjugate = mul(reverse(slice(imagInput, [0, 1], [batch, innerDimensionSize - 2]), 1), scalar(-1));
      const r = concat([realInput, realConjugate], 1);
      const i = concat([imagInput, imagConjugate], 1);
      const complexInput = reshape(complex(r, i), [outputShape[0], outputShape[1]]);
      ret = ifft(complexInput);
    }
    ret = real(ret);
    if (input.rank === 3 && input.shape[0] !== 0) {
      const temp = ret;
      const batch2 = input.shape[0];
      ret = reshape(ret, [batch2, ret.shape[0] / batch2, ret.shape[1]]);
      temp.dispose();
    }
    return ret;
  }
  const irfft = op({irfft_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/split_util.js
  function prepareSplitSize(x, numOrSizeSplits, axis = 0) {
    let splitSizes = [];
    if (typeof numOrSizeSplits === "number") {
      assert(x.shape[axis] % numOrSizeSplits === 0, () => "Number of splits must evenly divide the axis.");
      splitSizes = new Array(numOrSizeSplits).fill(x.shape[axis] / numOrSizeSplits);
    } else {
      const numOfNegs = numOrSizeSplits.reduce((count, value) => {
        if (value === -1) {
          count += 1;
        }
        return count;
      }, 0);
      assert(numOfNegs <= 1, () => "There should be only one negative value in split array.");
      const negIndex = numOrSizeSplits.indexOf(-1);
      if (negIndex !== -1) {
        const total = numOrSizeSplits.reduce((a, b) => b > 0 ? a + b : a);
        numOrSizeSplits[negIndex] = x.shape[axis] - total;
      }
      assert(x.shape[axis] === numOrSizeSplits.reduce((a, b) => a + b), () => "The sum of sizes must match the size of the axis dimension.");
      splitSizes = numOrSizeSplits;
    }
    return splitSizes;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/split.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function split_(x, numOrSizeSplits, axis = 0) {
    const $x = convertToTensor(x, "x", "split");
    const forward = (backend2, _) => {
      const $axis = parseAxisParam(axis, $x.shape)[0];
      const splitSizes = prepareSplitSize($x, numOrSizeSplits, $axis);
      return backend2.split($x, splitSizes, $axis);
    };
    const inputs = {x: $x};
    const attr = {numOrSizeSplits, axis};
    return ENGINE.runKernelFunc(forward, inputs, null, SplitV, attr);
  }
  const split = op({split_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/spectral/rfft.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function rfft_(input, fftLength) {
    assert(input.dtype === "float32", () => `The dtype for rfft() must be real value but got ${input.dtype}`);
    let innerDimensionSize = input.shape[input.shape.length - 1];
    const batch = input.size / innerDimensionSize;
    let adjustedInput;
    if (fftLength != null && fftLength < innerDimensionSize) {
      const begin = input.shape.map((v) => 0);
      const size = input.shape.map((v) => v);
      size[input.shape.length - 1] = fftLength;
      adjustedInput = slice(input, begin, size);
      innerDimensionSize = fftLength;
    } else if (fftLength != null && fftLength > innerDimensionSize) {
      const zerosShape = input.shape.map((v) => v);
      zerosShape[input.shape.length - 1] = fftLength - innerDimensionSize;
      adjustedInput = concat([input, zeros(zerosShape)], input.shape.length - 1);
      innerDimensionSize = fftLength;
    } else {
      adjustedInput = input;
    }
    const zerosInput = zerosLike(adjustedInput);
    const complexInput = reshape(complex(adjustedInput, zerosInput), [batch, innerDimensionSize]);
    const ret = fft(complexInput);
    const half = Math.floor(innerDimensionSize / 2) + 1;
    const realValues = real(ret);
    const imagValues = imag(ret);
    const realComplexConjugate = split(realValues, [half, innerDimensionSize - half], realValues.shape.length - 1);
    const imagComplexConjugate = split(imagValues, [half, innerDimensionSize - half], imagValues.shape.length - 1);
    const outputShape = adjustedInput.shape.slice();
    outputShape[adjustedInput.shape.length - 1] = half;
    return reshape(complex(realComplexConjugate[0], imagComplexConjugate[0]), outputShape);
  }
  const rfft = op({rfft_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sqrt.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sqrt_(x) {
    const $x = convertToTensor(x, "x", "sqrt");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.sqrt($x);
      save([$x]);
      return res;
    }, inputs, null, Sqrt);
  }
  const sqrt = op({sqrt_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/squared_difference.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function squaredDifference_(a, b) {
    let $a = convertToTensor(a, "a", "squaredDifference");
    let $b = convertToTensor(b, "b", "squaredDifference");
    [$a, $b] = makeTypesMatch($a, $b);
    assertAndGetBroadcastShape($a.shape, $b.shape);
    const forward = (backend2, save) => {
      const res = backend2.squaredDifference($a, $b);
      save([$a, $b]);
      return res;
    };
    const inputs = {a: $a, b: $b};
    const attrs = {};
    return ENGINE.runKernelFunc(forward, inputs, null, SquaredDifference, attrs);
  }
  const squaredDifference = op({squaredDifference_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/squeeze.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function squeeze_(x, axis) {
    const $x = convertToTensor(x, "x", "squeeze");
    return reshape($x, squeezeShape($x.shape, axis).newShape);
  }
  const squeeze = op({squeeze_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/stack.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function stack_(tensors, axis = 0) {
    const $tensors = convertToTensorArray(tensors, "tensors", "stack");
    assert($tensors.length >= 1, () => "Pass at least one tensor to tf.stack");
    if ($tensors.length === 1) {
      return expandDims($tensors[0], axis);
    }
    const rank = $tensors[0].rank;
    const shape = $tensors[0].shape;
    const dtype = $tensors[0].dtype;
    assert(axis <= rank, () => "Axis must be <= rank of the tensor");
    $tensors.forEach((t) => {
      assertShapesMatch(shape, t.shape, "All tensors passed to stack must have matching shapes");
      assert(dtype === t.dtype, () => "All tensors passed to stack must have matching dtypes");
    });
    const expandedTensors = $tensors.map((t) => expandDims(t, axis));
    return concat(expandedTensors, axis);
  }
  const stack = op({stack_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/step.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function step_(x, alpha = 0) {
    const $x = convertToTensor(x, "x", "step");
    const inputs = {x: $x};
    const attrs = {alpha};
    return ENGINE.runKernelFunc((backend2) => backend2.step($x, alpha), inputs, null, Step, attrs);
  }
  const step = op({step_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/strided_slice.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function stridedSlice_(x, begin, end, strides, beginMask = 0, endMask = 0, ellipsisMask = 0, newAxisMask = 0, shrinkAxisMask = 0) {
    let $x = convertToTensor(x, "x", "stridedSlice");
    const forward = (backend2) => {
      if (strides == null) {
        strides = new Array(begin.length);
      }
      const ellipsisAxes = maskToAxes(ellipsisMask);
      if (ellipsisAxes.length > 1) {
        throw new Error("Multiple ellipses in slice is not allowed.");
      }
      if (ellipsisMask !== 0 && newAxisMask !== 0) {
        throw new Error("Using both ellipsisMask and newAxisMask is not yet supported.");
      }
      if (ellipsisMask !== 0 && shrinkAxisMask !== 0) {
        throw new Error("Using both ellipsisMask and shrinkAxisMask is not yet supported.");
      }
      const numInterpolatedAxes = $x.rank - begin.length;
      const expandAxes = maskToAxes(newAxisMask);
      const newShape = $x.shape.slice();
      expandAxes.forEach((axis) => {
        begin[axis] = 0;
        end[axis] = 1;
        newShape.splice(axis, 0, 1);
      });
      $x = reshape($x, newShape);
      const {begin: normalizedBegin, end: normalizedEnd, strides: normalizedStrides} = getNormalizedAxes($x.shape, ellipsisAxes, numInterpolatedAxes, begin, end, strides, beginMask, endMask, ellipsisMask);
      begin = normalizedBegin;
      end = normalizedEnd;
      strides = normalizedStrides;
      const shrinkAxes = maskToAxes(shrinkAxisMask);
      shrinkAxes.forEach((axis) => {
        end[axis] = begin[axis] + 1;
        strides[axis] = 1;
      });
      const size = computeOutShape(begin, end, strides);
      const outShape = size.filter((_, axis) => shrinkAxes.indexOf(axis) === -1);
      const nonStrided = strides.every((v) => v === 1);
      if (nonStrided) {
        return reshape(slice($x, begin, size), outShape);
      }
      const res = backend2.stridedSlice($x, begin, end, strides);
      return reshape(res, outShape);
    };
    const inputs = {x: $x};
    const attrs = {
      begin,
      end,
      strides,
      beginMask,
      endMask,
      ellipsisMask,
      newAxisMask,
      shrinkAxisMask
    };
    return ENGINE.runKernelFunc(forward, inputs, null, StridedSlice, attrs);
  }
  const stridedSlice = op({stridedSlice_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tan.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tan_(x) {
    const $x = convertToTensor(x, "x", "tan");
    const inputs = {x: $x};
    return ENGINE.runKernelFunc((backend2, save) => {
      const res = backend2.tan($x);
      save([$x]);
      return res;
    }, inputs, null, Tan);
  }
  const tan = op({tan_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor2d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor2d(values, shape, dtype) {
    assertNonNull(values);
    if (shape != null && shape.length !== 2) {
      throw new Error("tensor2d() requires shape to have two numbers");
    }
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 2 && inferredShape.length !== 1) {
      throw new Error("tensor2d() requires values to be number[][] or flat/TypedArray");
    }
    if (inferredShape.length === 1 && shape == null) {
      throw new Error("tensor2d() requires shape to be provided when `values` are a flat/TypedArray");
    }
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor4d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor4d(values, shape, dtype) {
    assertNonNull(values);
    if (shape != null && shape.length !== 4) {
      throw new Error("tensor4d() requires shape to have four numbers");
    }
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 4 && inferredShape.length !== 1) {
      throw new Error("tensor4d() requires values to be number[][][][] or flat/TypedArray");
    }
    if (inferredShape.length === 1 && shape == null) {
      throw new Error("tensor4d() requires shape to be provided when `values` are a flat array");
    }
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor5d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor5d(values, shape, dtype) {
    assertNonNull(values);
    if (shape != null && shape.length !== 5) {
      throw new Error("tensor5d() requires shape to have five numbers");
    }
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 5 && inferredShape.length !== 1) {
      throw new Error("tensor5d() requires values to be number[][][][][] or flat/TypedArray");
    }
    if (inferredShape.length === 1 && shape == null) {
      throw new Error("tensor5d() requires shape to be provided when `values` are a flat array");
    }
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/tensor6d.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tensor6d(values, shape, dtype) {
    assertNonNull(values);
    if (shape != null && shape.length !== 6) {
      throw new Error("tensor6d() requires shape to have six numbers");
    }
    const inferredShape = inferShape(values, dtype);
    if (inferredShape.length !== 6 && inferredShape.length !== 1) {
      throw new Error("tensor6d() requires values to be number[][][][][][] or flat/TypedArray");
    }
    if (inferredShape.length === 1 && shape == null) {
      throw new Error("tensor6d() requires shape to be provided when `values` are a flat array");
    }
    shape = shape || inferredShape;
    return makeTensor(values, shape, inferredShape, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/topk.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function topk_(x, k = 1, sorted = true) {
    const $x = convertToTensor(x, "x", "topk");
    if ($x.rank === 0) {
      throw new Error("topk() expects the input to be of rank 1 or higher");
    }
    const lastDim = $x.shape[$x.shape.length - 1];
    if (k > lastDim) {
      throw new Error(`'k' passed to topk() must be <= the last dimension (${lastDim}) but got ${k}`);
    }
    const inputs = {x: $x};
    const attrs = {k, sorted};
    const [values, indices] = ENGINE.runKernelFunc((b) => b.topk($x, k, sorted), inputs, null, TopK, attrs);
    return {values, indices};
  }
  const topk = op({topk_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/truncated_normal.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function truncatedNormal_(shape, mean5 = 0, stdDev = 1, dtype, seed) {
    if (dtype != null && dtype === "bool") {
      throw new Error(`Unsupported data type $ { dtype }`);
    }
    const randGauss = new MPRandGauss(mean5, stdDev, dtype, true, seed);
    const res = buffer(shape, dtype);
    for (let i = 0; i < res.values.length; i++) {
      res.values[i] = randGauss.nextValue();
    }
    return res.toTensor();
  }
  const truncatedNormal = op({truncatedNormal_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/unsorted_segment_sum.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function unsortedSegmentSum_(x, segmentIds, numSegments) {
    const $x = convertToTensor(x, "x", "unsortedSegmentSum");
    const $segmentIds = convertToTensor(segmentIds, "segmentIds", "unsortedSegmentSum", "int32");
    assert(isInt(numSegments), () => "numSegments must be of dtype int");
    const inputs = {x: $x, segmentIds: $segmentIds};
    const attrs = {numSegments};
    const forward = (backend2, save) => {
      const res = backend2.unsortedSegmentSum($x, $segmentIds, numSegments);
      save([$segmentIds]);
      return res;
    };
    return ENGINE.runKernelFunc(forward, inputs, null, UnsortedSegmentSum, attrs);
  }
  const unsortedSegmentSum = op({unsortedSegmentSum_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/unstack.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function unstack_(x, axis = 0) {
    const $x = convertToTensor(x, "x", "unstack");
    assert(axis >= -$x.shape.length && axis < $x.shape.length, () => `Axis = ${axis} is not in [-${$x.shape.length}, ${$x.shape.length})`);
    if (axis < 0) {
      axis += $x.shape.length;
    }
    const inputs = {value: $x};
    const attrs = {axis};
    const forward = (backend2) => backend2.unstack($x, axis);
    return ENGINE.runKernelFunc(forward, inputs, null, Unpack, attrs);
  }
  const unstack = op({unstack_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/variable.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function variable(initialValue, trainable = true, name, dtype) {
    return ENGINE.makeVariable(initialValue, trainable, name, dtype);
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/where_impl.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function whereImpl(condShape, condVals) {
    const indices = [];
    for (let i = 0; i < condVals.length; i++) {
      if (condVals[i]) {
        indices.push(i);
      }
    }
    const inBuffer = buffer(condShape, "int32");
    const out = buffer([indices.length, condShape.length], "int32");
    for (let i = 0; i < indices.length; i++) {
      const loc = inBuffer.indexToLoc(indices[i]);
      const offset = i * condShape.length;
      out.values.set(loc, offset);
    }
    return out.toTensor();
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/where_async.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function whereAsync_(condition) {
    const $condition = convertToTensor(condition, "condition", "whereAsync", "bool");
    const vals = await $condition.data();
    const res = whereImpl($condition.shape, vals);
    if (condition !== $condition) {
      $condition.dispose();
    }
    return res;
  }
  const whereAsync = whereAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/boolean_mask.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function booleanMaskAsync_(tensor17, mask, axis) {
    const $tensor = convertToTensor(tensor17, "tensor", "boolMask");
    const $mask = convertToTensor(mask, "mask", "boolMask", "bool");
    const axisFrom = axis == null ? 0 : axis;
    const maskDim = $mask.rank;
    const tensorShape = $tensor.shape;
    assert(maskDim > 0, () => "mask cannot be scalar");
    assertShapesMatch(tensorShape.slice(axisFrom, axisFrom + maskDim), $mask.shape, `mask's shape must match the first K dimensions of tensor's shape,`);
    let leadingSize = 1;
    for (let i = axisFrom; i < axisFrom + maskDim; i++) {
      leadingSize *= tensorShape[i];
    }
    const targetTensorShape = tensorShape.slice(0, axisFrom).concat([leadingSize], tensorShape.slice(axisFrom + maskDim));
    const reshapedTensor = reshape($tensor, targetTensorShape);
    const reshapedMask = reshape($mask, [-1]);
    const positivePositions = await whereAsync(reshapedMask);
    const indices = squeeze(positivePositions, [1]);
    const res = gather(reshapedTensor, indices, axisFrom);
    if (tensor17 !== $tensor) {
      $tensor.dispose();
    }
    if (mask !== $mask) {
      $mask.dispose();
    }
    indices.dispose();
    reshapedTensor.dispose();
    reshapedMask.dispose();
    positivePositions.dispose();
    return res;
  }
  const booleanMaskAsync = booleanMaskAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/compare.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function notEqualStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "notEqualStrict");
    const $b = convertToTensor(b, "b", "notEqualStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in notEqualStrict: ");
    return notEqual($a, $b);
  }
  function lessStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "lessStrict");
    const $b = convertToTensor(b, "b", "lessStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in lessStrict: ");
    return less($a, $b);
  }
  function equalStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "equalStrict");
    const $b = convertToTensor(b, "b", "equalStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in equalStrict: ");
    return equal($a, $b);
  }
  function lessEqualStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "lessEqualStrict");
    const $b = convertToTensor(b, "b", "lessEqualStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in lessEqualStrict: ");
    return lessEqual($a, $b);
  }
  function greaterStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "greaterStrict");
    const $b = convertToTensor(b, "b", "greaterStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in greaterStrict: ");
    return greater($a, $b);
  }
  function greaterEqualStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "greaterEqualStrict");
    const $b = convertToTensor(b, "b", "greaterEqualStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in greaterEqualStrict: ");
    return greaterEqual($a, $b);
  }
  const equalStrict = op({equalStrict_});
  const greaterEqualStrict = op({greaterEqualStrict_});
  const greaterStrict = op({greaterStrict_});
  const lessEqualStrict = op({lessEqualStrict_});
  const lessStrict = op({lessStrict_});
  const notEqualStrict = op({notEqualStrict_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/binary_ops.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function addStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "addStrict");
    const $b = convertToTensor(b, "b", "addStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in addStrict: ");
    return add2($a, $b);
  }
  function subStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "subStrict");
    const $b = convertToTensor(b, "b", "subStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in subStrict: ");
    return sub($a, $b);
  }
  function powStrict_(base, exp11) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    assertShapesMatch(base.shape, exp11.shape, "Error in powStrict: ");
    return pow(base, exp11);
  }
  function mulStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "mul");
    const $b = convertToTensor(b, "b", "mul");
    assertShapesMatch($a.shape, $b.shape, "Error in multiplyStrict: ");
    return mul($a, $b);
  }
  function divStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "div");
    const $b = convertToTensor(b, "b", "div");
    assertShapesMatch($a.shape, $b.shape, "Error in divideStrict: ");
    return div($a, $b);
  }
  function modStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "modStrict");
    const $b = convertToTensor(b, "b", "modStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in modStrict: ");
    return mod($a, $b);
  }
  function minimumStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "minimumStrict");
    const $b = convertToTensor(b, "b", "minimumStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in minimumStrict: ");
    return minimum($a, $b);
  }
  function maximumStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "maximumStrict");
    const $b = convertToTensor(b, "b", "maximumStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in maximumStrict: ");
    return maximum($a, $b);
  }
  function squaredDifferenceStrict_(a, b) {
    deprecationWarn("strict variants of ops have been deprecated and will be removed in future");
    const $a = convertToTensor(a, "a", "squaredDifferenceStrict");
    const $b = convertToTensor(b, "b", "squaredDifferenceStrict");
    assertShapesMatch($a.shape, $b.shape, "Error in squaredDifferenceStrict: ");
    return squaredDifference($a, $b);
  }
  const addStrict = op({addStrict_});
  const divStrict = op({divStrict_});
  const maximumStrict = op({maximumStrict_});
  const minimumStrict = op({minimumStrict_});
  const modStrict = op({modStrict_});
  const mulStrict = op({mulStrict_});
  const powStrict = op({powStrict_});
  const squaredDifferenceStrict = op({squaredDifferenceStrict_});
  const subStrict = op({subStrict_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/norm.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function norm_(x, ord = "euclidean", axis = null, keepDims = false) {
    x = convertToTensor(x, "x", "norm");
    const norm4 = normImpl(x, ord, axis);
    let keepDimsShape = norm4.shape;
    if (keepDims) {
      const axes = parseAxisParam(axis, x.shape);
      keepDimsShape = expandShapeToKeepDim(norm4.shape, axes);
    }
    return reshape(norm4, keepDimsShape);
  }
  function normImpl(x, p, axis = null) {
    if (x.rank === 0) {
      return abs(x);
    }
    if (x.rank !== 1 && axis === null) {
      return normImpl(reshape(x, [-1]), p, axis);
    }
    if (x.rank === 1 || typeof axis === "number" || Array.isArray(axis) && axis.length === 1) {
      if (p === 1) {
        return sum2(abs(x), axis);
      }
      if (p === Infinity) {
        return max(abs(x), axis);
      }
      if (p === -Infinity) {
        return min(abs(x), axis);
      }
      if (p === "euclidean" || p === 2) {
        return sqrt(sum2(pow(abs(x), scalar(2, "int32")), axis));
      }
      throw new Error(`Error in norm: invalid ord value: ${p}`);
    }
    if (Array.isArray(axis) && axis.length === 2) {
      if (p === 1) {
        return max(sum2(abs(x), axis[0]), axis[1] - 1);
      }
      if (p === Infinity) {
        return max(sum2(abs(x), axis[1]), axis[0]);
      }
      if (p === -Infinity) {
        return min(sum2(abs(x), axis[1]), axis[0]);
      }
      if (p === "fro" || p === "euclidean") {
        return sqrt(sum2(square(x), axis));
      }
      throw new Error(`Error in norm: invalid ord value: ${p}`);
    }
    throw new Error(`Error in norm: invalid axis: ${axis}`);
  }
  const norm = op({norm_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/moving_average.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function movingAverage_(v, x, decay, step7, zeroDebias = true) {
    const $v = convertToTensor(v, "v", "movingAverage");
    const $x = convertToTensor(x, "x", "movingAverage");
    const $decay = convertToTensor(decay, "decay", "movingAverage");
    assertTypesMatch($v, $x);
    assert(arraysEqual($v.shape, $x.shape), () => "Shape mismatch in v and x");
    const one = scalar(1);
    const oneMinusDecay = sub(one, $decay);
    let update = mul(sub($x, $v), oneMinusDecay);
    if (zeroDebias) {
      assert(step7 != null, () => "When using zeroDebias: true, step is required.");
      const $step = convertToTensor(step7, "step", "movingAverage");
      update = div(update, sub(one, pow($decay, $step)));
    }
    return add2($v, update);
  }
  const movingAverage = op({movingAverage_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/scatter_nd.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function scatterND_(indices, updates, shape) {
    const $indices = convertToTensor(indices, "indices", "scatterND", "int32");
    const $updates = convertToTensor(updates, "updates", "scatterND");
    validateInput($updates, $indices, shape);
    const forward = (backend2) => {
      return backend2.scatterND($indices, $updates, shape);
    };
    const inputs = {indices: $indices, updates: $updates};
    const attrs = {shape};
    return ENGINE.runKernelFunc(forward, inputs, null, ScatterNd, attrs);
  }
  const scatterND = op({scatterND_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/sparse_to_dense_util.js
  function validateInput2(sparseIndices, sparseValues, outputShape, defaultValues) {
    if (sparseIndices.dtype !== "int32") {
      throw new Error(`tf.sparseToDense() expects the indices to be int32 type, but the dtype was ${sparseIndices.dtype}.`);
    }
    if (sparseIndices.rank > 2) {
      throw new Error(`sparseIndices should be a scalar, vector, or matrix, but got shape ${sparseIndices.shape}.`);
    }
    const numElems = sparseIndices.rank > 0 ? sparseIndices.shape[0] : 1;
    const numDims = sparseIndices.rank > 1 ? sparseIndices.shape[1] : 1;
    if (outputShape.length !== numDims) {
      throw new Error(`outputShape has incorrect number of elements:, ${outputShape.length}, should be: ${numDims}.`);
    }
    const numValues = sparseValues.size;
    if (!(sparseValues.rank === 0 || sparseValues.rank === 1 && numValues === numElems)) {
      throw new Error(`sparseValues has incorrect shape ${sparseValues.shape}, should be [] or [${numElems}]`);
    }
    if (sparseValues.dtype !== defaultValues.dtype) {
      throw new Error("sparseValues.dtype must match defaultValues.dtype");
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/sparse_to_dense.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sparseToDense_(sparseIndices, sparseValues, outputShape, defaultValue = 0) {
    const $sparseIndices = convertToTensor(sparseIndices, "sparseIndices", "sparseToDense", "int32");
    const $sparseValues = convertToTensor(sparseValues, "sparseValues", "sparseToDense");
    const $defaultValue = convertToTensor(defaultValue, "defaultValue", "sparseToDense", $sparseValues.dtype);
    validateInput2($sparseIndices, $sparseValues, outputShape, $defaultValue);
    const inputs = {
      sparseIndices: $sparseIndices,
      sparseValues: $sparseValues,
      defaultValue: $defaultValue
    };
    const attrs = {outputShape};
    return ENGINE.runKernelFunc((backend2) => backend2.sparseToDense($sparseIndices, $sparseValues, outputShape, $defaultValue), inputs, null, SparseToDense, attrs);
  }
  const sparseToDense = op({sparseToDense_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/gather_nd.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function gatherND_(x, indices) {
    const $indices = convertToTensor(indices, "indices", "gatherND", "int32");
    const $x = convertToTensor(x, "x", "gatherND");
    const forward = (backend2) => {
      return backend2.gatherND($x, $indices);
    };
    const inputs = {params: $x, indices: $indices};
    return ENGINE.runKernelFunc(forward, inputs, null, GatherNd);
  }
  const gatherND = op({gatherND_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/dropout_util.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getNoiseShape(x, noiseShape) {
    if (noiseShape == null) {
      return x.shape.slice();
    }
    if (arraysEqual(x.shape, noiseShape)) {
      return noiseShape;
    }
    if (x.shape.length === noiseShape.length) {
      const newDimension = [];
      for (let i = 0; i < x.shape.length; i++) {
        if (noiseShape[i] == null && x.shape[i] != null) {
          newDimension.push(x.shape[i]);
        } else {
          newDimension.push(noiseShape[i]);
        }
      }
      return newDimension;
    }
    return noiseShape;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/dropout.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function dropout_(x, rate, noiseShape, seed) {
    const $x = convertToTensor(x, "x", "dropout");
    assert($x.dtype === "float32", () => `x has to be a floating point tensor since it's going to be scaled, but got a ${$x.dtype} tensor instead.`);
    assert(rate >= 0 && rate < 1, () => `rate must be a float in the range [0, 1), but got ${rate}.`);
    if (rate === 0) {
      return x instanceof Tensor ? $x.clone() : $x;
    }
    const $noiseShape = getNoiseShape($x, noiseShape);
    const keepProb = 1 - rate;
    const multiplier = div(floor(add2(randomUniform($noiseShape, 0, 1, "float32", seed), keepProb)), keepProb);
    return mul($x, multiplier);
  }
  const dropout = op({dropout_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/signal_ops_util.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function enclosingPowerOfTwo(value) {
    return Math.floor(Math.pow(2, Math.ceil(Math.log(value) / Math.log(2))));
  }
  function cosineWindow(windowLength, a, b) {
    const even = 1 - windowLength % 2;
    const newValues = new Float32Array(windowLength);
    for (let i = 0; i < windowLength; ++i) {
      const cosArg = 2 * Math.PI * i / (windowLength + even - 1);
      newValues[i] = a - b * Math.cos(cosArg);
    }
    return tensor1d(newValues, "float32");
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/in_top_k.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function inTopKAsync_(predictions, targets, k = 1) {
    const $predictions = convertToTensor(predictions, "predictions", "inTopK");
    const $targets = convertToTensor(targets, "targets", "inTopK");
    assert($predictions.rank > 1, () => `inTopK() expects the predictions to be of rank 2 or higher, but got ${$predictions.rank}`);
    assert($predictions.rank - 1 === $targets.rank, () => `predictions rank should be 1 larger than targets rank, but got predictions rank ${$predictions.rank} and targets rank ${$targets.rank}`);
    assertShapesMatch($predictions.shape.slice(0, $predictions.shape.length - 1), $targets.shape, `predictions's shape should be align with the targets' shape, except the last dimension.`);
    const lastDim = $predictions.shape[$predictions.shape.length - 1];
    assert(k > 0 && k <= lastDim, () => `'k' passed to inTopK() must be > 0 && <= the predictions last dimension (${lastDim}), but got ${k}`);
    const predictionsVals = await $predictions.data();
    const targetsVals = await $targets.data();
    const [batch, size] = [predictionsVals.length / lastDim, lastDim];
    const precision = getTypedArrayFromDType("bool", batch);
    for (let b = 0; b < batch; b++) {
      const offset = b * size;
      const vals = predictionsVals.subarray(offset, offset + size);
      const valAndInd = [];
      for (let i = 0; i < vals.length; i++) {
        valAndInd.push({value: vals[i], index: i});
      }
      valAndInd.sort((a, b2) => b2.value - a.value);
      precision[b] = 0;
      for (let i = 0; i < k; i++) {
        if (valAndInd[i].index === targetsVals[b]) {
          precision[b] = 1;
          break;
        }
      }
    }
    if (predictions !== $predictions) {
      $predictions.dispose();
    }
    if (targets !== $targets) {
      $targets.dispose();
    }
    return tensor4(precision, $targets.shape, "bool");
  }
  const inTopKAsync = inTopKAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv2d_backprop_filter.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv2DBackpropFilter_(x, dy, filterShape, strides, pad8, dataFormat = "NHWC", dimRoundingMode) {
    let x4D = x;
    if (x.rank === 3) {
      x4D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
    }
    let dy4D = dy;
    if (dy4D.rank === 3) {
      dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in conv2dDerFilter: input must be rank 4, but got shape ${x4D.shape}.`);
    assert(dy4D.rank === 4, () => `Error in conv2dDerFilter: dy must be rank 4, but got shape ${dy4D.shape}.`);
    assert(filterShape.length === 4, () => `Error in conv2dDerFilter: filterShape must be length 4, but got ${filterShape}.`);
    const inDepth = dataFormat === "NHWC" ? x4D.shape[3] : x4D.shape[1];
    const outDepth = dataFormat === "NHWC" ? dy4D.shape[3] : dy4D.shape[1];
    assert(inDepth === filterShape[2], () => `Error in conv2dDerFilter: depth of input ${inDepth}) must match input depth in filter (${filterShape[2]}.`);
    assert(outDepth === filterShape[3], () => `Error in conv2dDerFilter: depth of dy (${outDepth}) must match output depth for filter (${filterShape[3]}).`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in conv2dDerFilter: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2) => {
      const dilations = 1;
      const $dataFormat = convertConv2DDataFormat(dataFormat);
      const convInfo = computeConv2DInfo(x4D.shape, filterShape, strides, dilations, pad8, dimRoundingMode, false, $dataFormat);
      return backend2.conv2dDerFilter(x4D, dy4D, convInfo);
    };
    const inputs = {x: x4D, dy: dy4D};
    const attrs = {strides, pad: pad8, dataFormat, dimRoundingMode};
    return ENGINE.runKernelFunc(forward, inputs, null, Conv2DBackpropFilter, attrs);
  }
  const conv2DBackpropFilter = op({conv2DBackpropFilter_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/fused_util.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getFusedDyActivation(dy, y, activation) {
    if (activation == null || activation === "linear") {
      return dy;
    }
    if (activation === "relu") {
      return mul(dy, step(y));
    }
    throw new Error(`Cannot compute gradient for fused activation ${activation}.`);
  }
  function getFusedBiasGradient(bias, dyActivation) {
    let res = dyActivation;
    const reduceAxes = getReductionAxes(bias.shape, dyActivation.shape);
    if (reduceAxes.length > 0) {
      res = sum2(res, reduceAxes);
    }
    return reshape(res, bias.shape);
  }
  function applyActivation(x, activation, preluActivationWeights) {
    if (activation === "linear") {
      return x;
    } else if (activation === "relu") {
      return relu(x);
    } else if (activation === "elu") {
      return elu(x);
    } else if (activation === "relu6") {
      return relu6(x);
    } else if (activation === "prelu") {
      return prelu(x, preluActivationWeights);
    }
    throw new Error(`Unknown fused activation ${activation}.`);
  }
  const shouldFuse = (gradientDepth, activation) => {
    const gradientMode = gradientDepth > 0;
    return !gradientMode || activation === "linear";
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/fused/conv2d.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function fusedConv2d_({x, filter, strides, pad: pad8, dataFormat = "NHWC", dilations = [1, 1], dimRoundingMode, bias, activation = "linear", preluActivationWeights}) {
    activation = activation || "linear";
    if (shouldFuse(ENGINE.state.gradientDepth, activation) === false) {
      let result = conv2d(x, filter, strides, pad8, dataFormat, dilations, dimRoundingMode);
      if (bias != null) {
        result = add2(result, bias);
      }
      return applyActivation(result, activation, preluActivationWeights);
    }
    const $x = convertToTensor(x, "x", "conv2d");
    const $filter = convertToTensor(filter, "filter", "conv2d");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in fused conv2d: input must be rank 4, but got rank ${x4D.rank}.`);
    assert($filter.rank === 4, () => `Error in fused conv2d: filter must be rank 4, but got rank ${$filter.rank}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in fused conv2d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    assert(x4D.shape[3] === $filter.shape[2], () => `Error in conv2d: depth of input (${x4D.shape[3]}) must match input depth for filter ${$filter.shape[2]}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in conv2D: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    assert(dataFormat === "NHWC", () => `Error in conv2d: got dataFormat of ${dataFormat} but only NHWC is currently supported.`);
    const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad8, dimRoundingMode);
    let $bias;
    if (bias != null) {
      $bias = convertToTensor(bias, "bias", "fused conv2d");
      [$bias] = makeTypesMatch($bias, $x);
      assertAndGetBroadcastShape(convInfo.outShape, $bias.shape);
    }
    let $preluActivationWeights;
    if (preluActivationWeights != null) {
      $preluActivationWeights = convertToTensor(preluActivationWeights, "prelu weights", "fused conv2d");
    }
    const grad2 = (dy, saved) => {
      const [$filter2, x4D2, y, $bias2] = saved;
      const dyActivation = getFusedDyActivation(dy, y, activation);
      assert(tupleValuesAreOne(dilations), () => `Error in gradient of fused conv2D: dilation rates greater than 1 are not yet supported in gradients. Got dilations '${dilations}'`);
      const xDer = conv2DBackpropInput(x4D2.shape, dyActivation, $filter2, strides, pad8);
      const filterDer = conv2DBackpropFilter(x4D2, dyActivation, $filter2.shape, strides, pad8);
      const der = [xDer, filterDer];
      if ($bias2 != null) {
        const biasDer = getFusedBiasGradient($bias2, dyActivation);
        der.push(biasDer);
      }
      return der;
    };
    const forward = (backend2) => {
      const res = backend2.fusedConv2d({
        input: x4D,
        filter: $filter,
        convInfo,
        bias: $bias,
        activation,
        preluActivationWeights: $preluActivationWeights
      });
      return res;
    };
    const inputs = {
      x: x4D,
      filter: $filter,
      bias: $bias,
      preluActivationWeights: $preluActivationWeights
    };
    const attrs = {strides, pad: pad8, dataFormat, dilations, dimRoundingMode, activation};
    if (bias == null) {
      const customOp = customGrad((x4D2, filter2, save) => {
        let res = ENGINE.runKernelFunc(forward, inputs, null, FusedConv2D, attrs);
        save([filter2, x4D2, res]);
        if (reshapedTo4D) {
          res = reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
        }
        return {value: res, gradFunc: grad2};
      });
      return customOp(x4D, $filter);
    } else {
      const customOpWithBias = customGrad((x4D2, filter2, bias2, save) => {
        let res = ENGINE.runKernelFunc(forward, inputs, null, FusedConv2D, attrs);
        save([filter2, x4D2, res, bias2]);
        if (reshapedTo4D) {
          res = reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
        }
        return {value: res, gradFunc: grad2};
      });
      return customOpWithBias(x4D, $filter, $bias);
    }
  }
  const conv2d5 = op({fusedConv2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d_native_backprop_filter.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function depthwiseConv2dNativeBackpropFilter_(x, dy, filterShape, convInfo) {
    let x4D = x;
    if (x.rank === 3) {
      x4D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2]]);
    }
    let dy4D = dy;
    if (dy4D.rank === 3) {
      dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
    }
    const forward = (backend2) => backend2.depthwiseConv2DDerFilter(x4D, dy4D, convInfo);
    const inputs = {x: x4D, dy: dy4D};
    return ENGINE.runKernelFunc(forward, inputs, null, DepthwiseConv2dNativeBackpropFilter);
  }
  const depthwiseConv2dNativeBackpropFilter = op({depthwiseConv2dNativeBackpropFilter_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/depthwise_conv2d_native_backprop_input.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function depthwiseConv2dNativeBackpropInput_(xShape, dy, filter, convInfo) {
    let dy4D = dy;
    let reshapedTo4D = false;
    if (dy.rank === 3) {
      reshapedTo4D = true;
      dy4D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2]]);
    }
    const forward = (backend2) => backend2.depthwiseConv2DDerInput(dy4D, filter, convInfo);
    const inputs = {dy: dy4D};
    const res = ENGINE.runKernelFunc(forward, inputs, null, DepthwiseConv2dNativeBackpropInput);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const depthwiseConv2dNativeBackpropInput = op({depthwiseConv2dNativeBackpropInput_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/fused/depthwise_conv2d.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function fusedDepthwiseConv2d_({x, filter, strides, pad: pad8, dataFormat = "NHWC", dilations = [1, 1], dimRoundingMode, bias, activation = "linear", preluActivationWeights}) {
    if (shouldFuse(ENGINE.state.gradientDepth, activation) === false) {
      let result = depthwiseConv2d(x, filter, strides, pad8, dataFormat, dilations, dimRoundingMode);
      if (bias != null) {
        result = add2(result, bias);
      }
      return applyActivation(result, activation, preluActivationWeights);
    }
    const $x = convertToTensor(x, "x", "depthwiseConv2d");
    const $filter = convertToTensor(filter, "filter", "depthwiseConv2d");
    let x4D = $x;
    let reshapedTo4D = false;
    if ($x.rank === 3) {
      reshapedTo4D = true;
      x4D = reshape($x, [1, $x.shape[0], $x.shape[1], $x.shape[2]]);
    }
    assert(x4D.rank === 4, () => `Error in fused depthwiseConv2d: input must be rank 4, but got rank ${x4D.rank}.`);
    assert($filter.rank === 4, () => `Error in fused depthwiseConv2d: filter must be rank 4, but got rank ${$filter.rank}.`);
    assert(x4D.shape[3] === $filter.shape[2], () => `Error in fused depthwiseConv2d: number of input channels (${x4D.shape[3]}) must match the inChannels dimension in filter ${$filter.shape[2]}.`);
    if (dilations == null) {
      dilations = [1, 1];
    }
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in fused depthwiseConv2d: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in fused depthwiseConv2d: pad must be an integer when using dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const convInfo = computeConv2DInfo(x4D.shape, $filter.shape, strides, dilations, pad8, dimRoundingMode, true);
    let $bias;
    if (bias != null) {
      $bias = convertToTensor(bias, "bias", "fused conv2d");
      [$bias] = makeTypesMatch($bias, $x);
      assertAndGetBroadcastShape(convInfo.outShape, $bias.shape);
    }
    let $preluActivationWeights;
    if (preluActivationWeights != null) {
      $preluActivationWeights = convertToTensor(preluActivationWeights, "prelu weights", "fused depthwiseConv2d");
    }
    const grad2 = (dy, saved) => {
      assert(tupleValuesAreOne(dilations), () => `Error in gradient of fused depthwiseConv2d: dilation rates greater than 1 are not yet supported. Got dilations '${dilations}'`);
      const [$filter2, x4D2, y, bias2] = saved;
      const dyActivation = getFusedDyActivation(dy, y, activation);
      const xDer = depthwiseConv2dNativeBackpropInput(x4D2.shape, dyActivation, $filter2, convInfo);
      const filterDer = depthwiseConv2dNativeBackpropFilter(x4D2, dyActivation, $filter2.shape, convInfo);
      if (bias2 != null) {
        const biasDer = getFusedBiasGradient($bias, dyActivation);
        return [xDer, filterDer, biasDer];
      }
      return [xDer, filterDer];
    };
    const forward = (backend2) => {
      const res = backend2.fusedDepthwiseConv2D({
        input: x4D,
        filter: $filter,
        convInfo,
        bias: $bias,
        activation,
        preluActivationWeights: $preluActivationWeights
      });
      return res;
    };
    const inputs = {
      x: x4D,
      filter: $filter,
      bias: $bias,
      preluActivationWeights: $preluActivationWeights
    };
    const attrs = {strides, pad: pad8, dataFormat, dilations, dimRoundingMode, activation};
    if (bias == null) {
      const customOp = customGrad((x4D2, filter2, save) => {
        let res = ENGINE.runKernelFunc(forward, inputs, null, FusedDepthwiseConv2D, attrs);
        save([filter2, x4D2, res]);
        if (reshapedTo4D) {
          res = reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
        }
        return {value: res, gradFunc: grad2};
      });
      return customOp(x4D, $filter);
    } else {
      const customOpWithBias = customGrad((x4D2, filter2, bias2, save) => {
        let res = ENGINE.runKernelFunc(forward, inputs, null, FusedDepthwiseConv2D, attrs);
        save([filter2, x4D2, res, bias2]);
        if (reshapedTo4D) {
          res = reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
        }
        return {value: res, gradFunc: grad2};
      });
      return customOpWithBias(x4D, $filter, $bias);
    }
  }
  const depthwiseConv2d2 = op({fusedDepthwiseConv2d_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/fused/mat_mul.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function fusedMatMul_({a, b, transposeA = false, transposeB = false, bias, activation = "linear", preluActivationWeights}) {
    if (shouldFuse(ENGINE.state.gradientDepth, activation) === false) {
      let result = matMul(a, b, transposeA, transposeB);
      if (bias != null) {
        result = add2(result, bias);
      }
      return applyActivation(result, activation, preluActivationWeights);
    }
    let $a = convertToTensor(a, "a", "fused matMul");
    let $b = convertToTensor(b, "b", "fused matMul");
    [$a, $b] = makeTypesMatch($a, $b);
    const innerShapeA = transposeA ? $a.shape[$a.rank - 2] : $a.shape[$a.rank - 1];
    const innerShapeB = transposeB ? $b.shape[$b.rank - 1] : $b.shape[$b.rank - 2];
    const outerShapeA = transposeA ? $a.shape[$a.rank - 1] : $a.shape[$a.rank - 2];
    const outerShapeB = transposeB ? $b.shape[$b.rank - 2] : $b.shape[$b.rank - 1];
    const outerDimsA = $a.shape.slice(0, -2);
    const outerDimsB = $b.shape.slice(0, -2);
    const batchDimA = sizeFromShape(outerDimsA);
    const batchDimB = sizeFromShape(outerDimsB);
    assert($a.rank >= 2 && $b.rank >= 2 && $a.rank === $b.rank, () => `Error in fused matMul: inputs must have the same rank of at least 2, got ranks ${$a.rank} and ${$b.rank}.`);
    assert(arraysEqual(outerDimsA, outerDimsB), () => `Error in fused matMul: outer dimensions (${outerDimsA}) and (${outerDimsB}) of Tensors with shapes ${$a.shape} and ${$b.shape} must match.`);
    assert(innerShapeA === innerShapeB, () => `Error in fused matMul: inner shapes (${innerShapeA}) and (${innerShapeB}) of Tensors with shapes ${$a.shape} and ${$b.shape} and transposeA=${transposeA} and transposeB=${transposeB} must match.`);
    const outShape = $a.shape.slice(0, -2).concat([outerShapeA, outerShapeB]);
    const a3D = transposeA ? reshape($a, [batchDimA, innerShapeA, outerShapeA]) : reshape($a, [batchDimA, outerShapeA, innerShapeA]);
    const b3D = transposeB ? reshape($b, [batchDimB, outerShapeB, innerShapeB]) : reshape($b, [batchDimB, innerShapeB, outerShapeB]);
    let $bias;
    if (bias != null) {
      $bias = convertToTensor(bias, "bias", "fused matMul");
      [$bias] = makeTypesMatch($bias, $a);
      assertAndGetBroadcastShape(outShape, $bias.shape);
    }
    let $preluActivationWeights;
    if (preluActivationWeights != null) {
      $preluActivationWeights = convertToTensor(preluActivationWeights, "prelu weights", "fused matMul");
    }
    const grad2 = (dy, saved) => {
      const [a3D2, b3D2, y, $bias2] = saved;
      const dyActivation = getFusedDyActivation(reshape(dy, y.shape), y, activation);
      let aDer;
      let bDer;
      if (!transposeA && !transposeB) {
        aDer = matMul(dyActivation, b3D2, false, true);
        bDer = matMul(a3D2, dyActivation, true, false);
      } else if (!transposeA && transposeB) {
        aDer = matMul(dyActivation, b3D2, false, false);
        bDer = matMul(dyActivation, a3D2, true, false);
      } else if (transposeA && !transposeB) {
        aDer = matMul(b3D2, dyActivation, false, true);
        bDer = matMul(a3D2, dyActivation, false, false);
      } else {
        aDer = matMul(b3D2, dyActivation, true, true);
        bDer = matMul(dyActivation, a3D2, true, true);
      }
      if (bias != null) {
        const biasDer = getFusedBiasGradient($bias2, dyActivation);
        return [aDer, bDer, biasDer];
      } else {
        return [aDer, bDer];
      }
    };
    const forward = (backend2) => {
      const y = backend2.fusedBatchMatMul({
        a: a3D,
        b: b3D,
        transposeA,
        transposeB,
        bias: $bias,
        activation,
        preluActivationWeights: $preluActivationWeights
      });
      return y;
    };
    const inputs = {
      a: a3D,
      b: b3D,
      bias: $bias,
      preluActivationWeights: $preluActivationWeights
    };
    const attrs = {transposeA, transposeB, activation};
    if (bias == null) {
      const customOp = customGrad((a3D2, b3D2, save) => {
        const res = ENGINE.runKernelFunc(forward, inputs, null, _FusedMatMul, attrs);
        save([a3D2, b3D2, res]);
        return {value: reshape(res, outShape), gradFunc: grad2};
      });
      return customOp(a3D, b3D);
    } else {
      const customOpWithBias = customGrad((a3D2, b3D2, $bias2, save) => {
        const res = ENGINE.runKernelFunc(forward, inputs, null, _FusedMatMul, attrs);
        save([a3D2, b3D2, res, $bias2]);
        return {value: reshape(res, outShape), gradFunc: grad2};
      });
      return customOpWithBias(a3D, b3D, $bias);
    }
  }
  const matMul2 = op({fusedMatMul_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/fused_ops.js
  const fused_ops_exports = {};
  __export(fused_ops_exports, {
    conv2d: () => conv2d5,
    depthwiseConv2d: () => depthwiseConv2d2,
    matMul: () => matMul2
  });
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */

  // node_modules/@tensorflow/tfjs-core/dist/ops/signal/hamming_window.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function hammingWindow_(windowLength) {
    return cosineWindow(windowLength, 0.54, 0.46);
  }
  const hammingWindow = op({hammingWindow_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/signal/hann_window.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function hannWindow_(windowLength) {
    return cosineWindow(windowLength, 0.5, 0.5);
  }
  const hannWindow = op({hannWindow_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/signal/frame.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function frame_(signal2, frameLength, frameStep, padEnd = false, padValue = 0) {
    let start = 0;
    const output = [];
    while (start + frameLength <= signal2.size) {
      output.push(slice(signal2, start, frameLength));
      start += frameStep;
    }
    if (padEnd) {
      while (start < signal2.size) {
        const padLen = start + frameLength - signal2.size;
        const pad8 = concat([
          slice(signal2, start, frameLength - padLen),
          fill([padLen], padValue)
        ]);
        output.push(pad8);
        start += frameStep;
      }
    }
    if (output.length === 0) {
      return tensor2d([], [0, frameLength]);
    }
    return reshape(concat(output), [output.length, frameLength]);
  }
  const frame = op({frame_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/signal/stft.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function stft_(signal2, frameLength, frameStep, fftLength, windowFn = hannWindow) {
    if (fftLength == null) {
      fftLength = enclosingPowerOfTwo(frameLength);
    }
    const framedSignal = frame(signal2, frameLength, frameStep);
    const windowedSignal = mul(framedSignal, windowFn(frameLength));
    const output = [];
    for (let i = 0; i < framedSignal.shape[0]; i++) {
      output.push(rfft(slice(windowedSignal, [i, 0], [1, frameLength]), fftLength));
    }
    return concat(output);
  }
  const stft = op({stft_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/crop_and_resize.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function cropAndResize_(image2, boxes, boxInd, cropSize, method, extrapolationValue) {
    const $image = convertToTensor(image2, "image", "cropAndResize");
    const $boxes = convertToTensor(boxes, "boxes", "cropAndResize", "float32");
    const $boxInd = convertToTensor(boxInd, "boxInd", "cropAndResize", "int32");
    method = method || "bilinear";
    extrapolationValue = extrapolationValue || 0;
    const numBoxes = $boxes.shape[0];
    assert($image.rank === 4, () => `Error in cropAndResize: image must be rank 4,but got rank ${$image.rank}.`);
    assert($boxes.rank === 2 && $boxes.shape[1] === 4, () => `Error in cropAndResize: boxes must be have size [${numBoxes},4] but had shape ${$boxes.shape}.`);
    assert($boxInd.rank === 1 && $boxInd.shape[0] === numBoxes, () => `Error in cropAndResize: boxInd must be have size [${numBoxes}] but had shape ${$boxes.shape}.`);
    assert(cropSize.length === 2, () => `Error in cropAndResize: cropSize must be of length 2, but got length ${cropSize.length}.`);
    assert(cropSize[0] >= 1 && cropSize[1] >= 1, () => `cropSize must be atleast [1,1], but was ${cropSize}`);
    assert(method === "bilinear" || method === "nearest", () => `method must be bilinear or nearest, but was ${method}`);
    const forward = (backend2) => backend2.cropAndResize($image, $boxes, $boxInd, cropSize, method, extrapolationValue);
    const inputs = {image: $image, boxes: $boxes, boxInd: $boxInd};
    const attrs = {method, extrapolationValue, cropSize};
    const res = ENGINE.runKernelFunc(forward, inputs, null, CropAndResize, attrs);
    return res;
  }
  const cropAndResize = op({cropAndResize_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/flip_left_right.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function flipLeftRight_(image2) {
    const $image = convertToTensor(image2, "image", "flipLeftRight", "float32");
    assert($image.rank === 4, () => `Error in flipLeftRight: image must be rank 4,but got rank ${$image.rank}.`);
    const inputs = {image: $image};
    const res = ENGINE.runKernel(FlipLeftRight, inputs, {});
    return res;
  }
  const flipLeftRight = op({flipLeftRight_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/rotate_with_offset.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function rotateWithOffset_(image2, radians, fillValue = 0, center = 0.5) {
    const $image = convertToTensor(image2, "image", "rotateWithOffset", "float32");
    assert($image.rank === 4, () => `Error in rotateWithOffset: image must be rank 4,but got rank ${$image.rank}.`);
    const inputs = {image: $image};
    const attrs = {radians, fillValue, center};
    const res = ENGINE.runKernel(RotateWithOffset, inputs, attrs);
    return res;
  }
  const rotateWithOffset = op({rotateWithOffset_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/nonmax_util.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function nonMaxSuppSanityCheck(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
    if (iouThreshold == null) {
      iouThreshold = 0.5;
    }
    if (scoreThreshold == null) {
      scoreThreshold = Number.NEGATIVE_INFINITY;
    }
    if (softNmsSigma == null) {
      softNmsSigma = 0;
    }
    const numBoxes = boxes.shape[0];
    maxOutputSize = Math.min(maxOutputSize, numBoxes);
    assert(0 <= iouThreshold && iouThreshold <= 1, () => `iouThreshold must be in [0, 1], but was '${iouThreshold}'`);
    assert(boxes.rank === 2, () => `boxes must be a 2D tensor, but was of rank '${boxes.rank}'`);
    assert(boxes.shape[1] === 4, () => `boxes must have 4 columns, but 2nd dimension was ${boxes.shape[1]}`);
    assert(scores.rank === 1, () => "scores must be a 1D tensor");
    assert(scores.shape[0] === numBoxes, () => `scores has incompatible shape with boxes. Expected ${numBoxes}, but was ${scores.shape[0]}`);
    assert(0 <= softNmsSigma && softNmsSigma <= 1, () => `softNmsSigma must be in [0, 1], but was '${softNmsSigma}'`);
    return {maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma};
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function nonMaxSuppression_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppression");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppression");
    const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold);
    maxOutputSize = inputs.maxOutputSize;
    iouThreshold = inputs.iouThreshold;
    scoreThreshold = inputs.scoreThreshold;
    const attrs = {maxOutputSize, iouThreshold, scoreThreshold};
    return ENGINE.runKernelFunc((b) => b.nonMaxSuppression($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold), {boxes: $boxes, scores: $scores}, null, NonMaxSuppressionV3, attrs);
  }
  const nonMaxSuppression = op({nonMaxSuppression_});

  // node_modules/@tensorflow/tfjs-core/dist/backends/array_util.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function binaryInsert(arr, element, comparator) {
    const index = binarySearch(arr, element, comparator);
    const insertionPoint = index < 0 ? -(index + 1) : index;
    arr.splice(insertionPoint, 0, element);
  }
  function binarySearch(arr, target, comparator) {
    return binarySearch_(arr, target, comparator || defaultComparator);
  }
  function defaultComparator(a, b) {
    return a > b ? 1 : a < b ? -1 : 0;
  }
  function binarySearch_(arr, target, comparator) {
    let left = 0;
    let right = arr.length;
    let middle = 0;
    let found = false;
    while (left < right) {
      middle = left + (right - left >>> 1);
      const compareResult = comparator(target, arr[middle]);
      if (compareResult > 0) {
        left = middle + 1;
      } else {
        right = middle;
        found = !compareResult;
      }
    }
    return found ? left : -left - 1;
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/non_max_suppression_impl.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function nonMaxSuppressionV3Impl(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
    return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0).selectedIndices;
  }
  function nonMaxSuppressionV4Impl(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, padToMaxOutputSize) {
    return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, 0, false, padToMaxOutputSize, true);
  }
  function nonMaxSuppressionV5Impl(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma) {
    return nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, true);
  }
  function nonMaxSuppressionImpl_(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma, returnScoresTensor = false, padToMaxOutputSize = false, returnValidOutputs = false) {
    const candidates = [];
    for (let i = 0; i < scores.length; i++) {
      if (scores[i] > scoreThreshold) {
        candidates.push({score: scores[i], boxIndex: i, suppressBeginIndex: 0});
      }
    }
    candidates.sort(ascendingComparator);
    const scale2 = softNmsSigma > 0 ? -0.5 / softNmsSigma : 0;
    const selectedIndices = [];
    const selectedScores = [];
    while (selectedIndices.length < maxOutputSize && candidates.length > 0) {
      const candidate = candidates.pop();
      const {score: originalScore, boxIndex, suppressBeginIndex} = candidate;
      if (originalScore < scoreThreshold) {
        break;
      }
      let ignoreCandidate = false;
      for (let j = selectedIndices.length - 1; j >= suppressBeginIndex; --j) {
        const iou3 = intersectionOverUnion(boxes, boxIndex, selectedIndices[j]);
        if (iou3 >= iouThreshold) {
          ignoreCandidate = true;
          break;
        }
        candidate.score = candidate.score * suppressWeight(iouThreshold, scale2, iou3);
        if (candidate.score <= scoreThreshold) {
          break;
        }
      }
      candidate.suppressBeginIndex = selectedIndices.length;
      if (!ignoreCandidate) {
        if (candidate.score === originalScore) {
          selectedIndices.push(boxIndex);
          selectedScores.push(candidate.score);
        } else if (candidate.score > scoreThreshold) {
          binaryInsert(candidates, candidate, ascendingComparator);
        }
      }
    }
    const validOutputs = selectedIndices.length;
    const elemsToPad = maxOutputSize - validOutputs;
    if (padToMaxOutputSize && elemsToPad > 0) {
      selectedIndices.push(...new Array(elemsToPad).fill(0));
      selectedScores.push(...new Array(elemsToPad).fill(0));
    }
    const result = {selectedIndices: tensor1d(selectedIndices, "int32")};
    if (returnScoresTensor) {
      result["selectedScores"] = tensor1d(selectedScores, "float32");
    }
    if (returnValidOutputs) {
      result["validOutputs"] = scalar(validOutputs, "int32");
    }
    return result;
  }
  function intersectionOverUnion(boxes, i, j) {
    const iCoord = boxes.subarray(i * 4, i * 4 + 4);
    const jCoord = boxes.subarray(j * 4, j * 4 + 4);
    const yminI = Math.min(iCoord[0], iCoord[2]);
    const xminI = Math.min(iCoord[1], iCoord[3]);
    const ymaxI = Math.max(iCoord[0], iCoord[2]);
    const xmaxI = Math.max(iCoord[1], iCoord[3]);
    const yminJ = Math.min(jCoord[0], jCoord[2]);
    const xminJ = Math.min(jCoord[1], jCoord[3]);
    const ymaxJ = Math.max(jCoord[0], jCoord[2]);
    const xmaxJ = Math.max(jCoord[1], jCoord[3]);
    const areaI = (ymaxI - yminI) * (xmaxI - xminI);
    const areaJ = (ymaxJ - yminJ) * (xmaxJ - xminJ);
    if (areaI <= 0 || areaJ <= 0) {
      return 0;
    }
    const intersectionYmin = Math.max(yminI, yminJ);
    const intersectionXmin = Math.max(xminI, xminJ);
    const intersectionYmax = Math.min(ymaxI, ymaxJ);
    const intersectionXmax = Math.min(xmaxI, xmaxJ);
    const intersectionArea = Math.max(intersectionYmax - intersectionYmin, 0) * Math.max(intersectionXmax - intersectionXmin, 0);
    return intersectionArea / (areaI + areaJ - intersectionArea);
  }
  function suppressWeight(iouThreshold, scale2, iou3) {
    const weight = Math.exp(scale2 * iou3 * iou3);
    return iou3 <= iouThreshold ? weight : 0;
  }
  function ascendingComparator(c1, c2) {
    return c1.score - c2.score || c1.score === c2.score && c2.boxIndex - c1.boxIndex;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression_async.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function nonMaxSuppressionAsync_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppressionAsync");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppressionAsync");
    const inputs = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold);
    maxOutputSize = inputs.maxOutputSize;
    iouThreshold = inputs.iouThreshold;
    scoreThreshold = inputs.scoreThreshold;
    const boxesAndScores = await Promise.all([$boxes.data(), $scores.data()]);
    const boxesVals = boxesAndScores[0];
    const scoresVals = boxesAndScores[1];
    const res = nonMaxSuppressionV3Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold);
    if ($boxes !== boxes) {
      $boxes.dispose();
    }
    if ($scores !== scores) {
      $scores.dispose();
    }
    return res;
  }
  const nonMaxSuppressionAsync = nonMaxSuppressionAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression_with_score.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function nonMaxSuppressionWithScore_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, softNmsSigma = 0) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppression");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppression");
    const params = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
    maxOutputSize = params.maxOutputSize;
    iouThreshold = params.iouThreshold;
    scoreThreshold = params.scoreThreshold;
    softNmsSigma = params.softNmsSigma;
    const inputs = {boxes: $boxes, scores: $scores};
    const attrs = {maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma};
    const result = ENGINE.runKernel(NonMaxSuppressionV5, inputs, attrs);
    return {selectedIndices: result[0], selectedScores: result[1]};
  }
  const nonMaxSuppressionWithScore = op({nonMaxSuppressionWithScore_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression_with_score_async.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function nonMaxSuppressionWithScoreAsync_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, softNmsSigma = 0) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppressionAsync");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppressionAsync");
    const params = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
    maxOutputSize = params.maxOutputSize;
    iouThreshold = params.iouThreshold;
    scoreThreshold = params.scoreThreshold;
    softNmsSigma = params.softNmsSigma;
    const boxesAndScores = await Promise.all([$boxes.data(), $scores.data()]);
    const boxesVals = boxesAndScores[0];
    const scoresVals = boxesAndScores[1];
    const res = nonMaxSuppressionV5Impl(boxesVals, scoresVals, maxOutputSize, iouThreshold, scoreThreshold, softNmsSigma);
    if ($boxes !== boxes) {
      $boxes.dispose();
    }
    if ($scores !== scores) {
      $scores.dispose();
    }
    return res;
  }
  const nonMaxSuppressionWithScoreAsync = nonMaxSuppressionWithScoreAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression_padded.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function nonMaxSuppressionPadded_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, padToMaxOutputSize = false) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppression");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppression");
    const params = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, null);
    const $maxOutputSize = params.maxOutputSize;
    const $iouThreshold = params.iouThreshold;
    const $scoreThreshold = params.scoreThreshold;
    const inputs = {boxes: $boxes, scores: $scores};
    const attrs = {
      maxOutputSize: $maxOutputSize,
      iouThreshold: $iouThreshold,
      scoreThreshold: $scoreThreshold,
      padToMaxOutputSize
    };
    const result = ENGINE.runKernel(NonMaxSuppressionV4, inputs, attrs);
    return {selectedIndices: result[0], validOutputs: result[1]};
  }
  const nonMaxSuppressionPadded = op({nonMaxSuppressionPadded_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/non_max_suppression_padded_async.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  async function nonMaxSuppressionPaddedAsync_(boxes, scores, maxOutputSize, iouThreshold = 0.5, scoreThreshold = Number.NEGATIVE_INFINITY, padToMaxOutputSize = false) {
    const $boxes = convertToTensor(boxes, "boxes", "nonMaxSuppressionAsync");
    const $scores = convertToTensor(scores, "scores", "nonMaxSuppressionAsync");
    const params = nonMaxSuppSanityCheck($boxes, $scores, maxOutputSize, iouThreshold, scoreThreshold, null);
    const $maxOutputSize = params.maxOutputSize;
    const $iouThreshold = params.iouThreshold;
    const $scoreThreshold = params.scoreThreshold;
    const [boxesVals, scoresVals] = await Promise.all([$boxes.data(), $scores.data()]);
    const res = nonMaxSuppressionV4Impl(boxesVals, scoresVals, $maxOutputSize, $iouThreshold, $scoreThreshold, padToMaxOutputSize);
    if ($boxes !== boxes) {
      $boxes.dispose();
    }
    if ($scores !== scores) {
      $scores.dispose();
    }
    return res;
  }
  const nonMaxSuppressionPaddedAsync = nonMaxSuppressionPaddedAsync_;

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/resize_bilinear.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function resizeBilinear_(images, size, alignCorners = false) {
    const $images = convertToTensor(images, "images", "resizeBilinear");
    assert($images.rank === 3 || $images.rank === 4, () => `Error in resizeBilinear: x must be rank 3 or 4, but got rank ${$images.rank}.`);
    assert(size.length === 2, () => `Error in resizeBilinear: new shape must 2D, but got shape ${size}.`);
    let batchImages = $images;
    let reshapedTo4D = false;
    if ($images.rank === 3) {
      reshapedTo4D = true;
      batchImages = reshape($images, [1, $images.shape[0], $images.shape[1], $images.shape[2]]);
    }
    const [newHeight, newWidth] = size;
    const forward = (backend2, save) => {
      save([batchImages]);
      return backend2.resizeBilinear(batchImages, newHeight, newWidth, alignCorners);
    };
    const inputs = {images: batchImages};
    const attrs = {alignCorners, size};
    const res = ENGINE.runKernelFunc(forward, inputs, null, ResizeBilinear, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const resizeBilinear = op({resizeBilinear_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/image/resize_nearest_neighbor.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function resizeNearestNeighbor_(images, size, alignCorners = false) {
    const $images = convertToTensor(images, "images", "resizeNearestNeighbor");
    assert($images.rank === 3 || $images.rank === 4, () => `Error in resizeNearestNeighbor: x must be rank 3 or 4, but got rank ${$images.rank}.`);
    assert(size.length === 2, () => `Error in resizeNearestNeighbor: new shape must 2D, but got shape ${size}.`);
    assert($images.dtype === "float32" || $images.dtype === "int32", () => "`images` must have `int32` or `float32` as dtype");
    let batchImages = $images;
    let reshapedTo4D = false;
    if ($images.rank === 3) {
      reshapedTo4D = true;
      batchImages = reshape($images, [1, $images.shape[0], $images.shape[1], $images.shape[2]]);
    }
    const [newHeight, newWidth] = size;
    const inputs = {images: batchImages};
    const attrs = {alignCorners, size};
    const forward = (backend2, save) => {
      save([batchImages]);
      return backend2.resizeNearestNeighbor(batchImages, newHeight, newWidth, alignCorners);
    };
    const res = ENGINE.runKernelFunc(forward, inputs, null, ResizeNearestNeighbor, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const resizeNearestNeighbor = op({resizeNearestNeighbor_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/linalg/band_part.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function bandPart_(a, numLower, numUpper) {
    assert(numLower % 1 === 0, () => `bandPart(): numLower must be an integer, got ${numLower}.`);
    assert(numUpper % 1 === 0, () => `bandPart(): numUpper must be an integer, got ${numUpper}.`);
    const $a = convertToTensor(a, "a", "bandPart");
    assert($a.rank >= 2, () => `bandPart(): Rank must be at least 2, got ${$a.rank}.`);
    const shape = $a.shape;
    const [M, N] = $a.shape.slice(-2);
    if (!(numLower <= M)) {
      throw new Error(`bandPart(): numLower (${numLower}) must not be greater than the number of rows (${M}).`);
    }
    if (!(numUpper <= N)) {
      throw new Error(`bandPart(): numUpper (${numUpper}) must not be greater than the number of columns (${N}).`);
    }
    if (numLower < 0) {
      numLower = M;
    }
    if (numUpper < 0) {
      numUpper = N;
    }
    const i = reshape(range(0, M, 1, "int32"), [-1, 1]);
    const j = range(0, N, 1, "int32");
    const ij = sub(i, j);
    const inBand = logicalAnd(lessEqual(ij, scalar(+numLower, "int32")), greaterEqual(ij, scalar(-numUpper, "int32")));
    const zero = zeros([M, N], $a.dtype);
    return reshape(stack(unstack(reshape($a, [-1, M, N])).map((mat) => where(inBand, mat, zero))), shape);
  }
  const bandPart = op({bandPart_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/linalg/gram_schmidt.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function gramSchmidt_(xs) {
    let inputIsTensor2D;
    if (Array.isArray(xs)) {
      inputIsTensor2D = false;
      assert(xs != null && xs.length > 0, () => "Gram-Schmidt process: input must not be null, undefined, or empty");
      const dim = xs[0].shape[0];
      for (let i = 1; i < xs.length; ++i) {
        assert(xs[i].shape[0] === dim, () => `Gram-Schmidt: Non-unique lengths found in the input vectors: (${xs[i].shape[0]} vs. ${dim})`);
      }
    } else {
      inputIsTensor2D = true;
      xs = split(xs, xs.shape[0], 0).map((x) => squeeze(x, [0]));
    }
    assert(xs.length <= xs[0].shape[0], () => `Gram-Schmidt: Number of vectors (${xs.length}) exceeds number of dimensions (${xs[0].shape[0]}).`);
    const ys = [];
    const xs1d = xs;
    for (let i = 0; i < xs.length; ++i) {
      ys.push(ENGINE.tidy(() => {
        let x = xs1d[i];
        if (i > 0) {
          for (let j = 0; j < i; ++j) {
            const proj = mul(sum2(mul(ys[j], x)), ys[j]);
            x = sub(x, proj);
          }
        }
        return div(x, norm(x, "euclidean"));
      }));
    }
    if (inputIsTensor2D) {
      return stack(ys, 0);
    } else {
      return ys;
    }
  }
  const gramSchmidt = op({gramSchmidt_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/linalg/qr.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function qr_(x, fullMatrices = false) {
    assert(x.rank >= 2, () => `qr() requires input tensor to have a rank >= 2, but got rank ${x.rank}`);
    if (x.rank === 2) {
      return qr2d(x, fullMatrices);
    } else {
      const outerDimsProd = x.shape.slice(0, x.shape.length - 2).reduce((value, prev) => value * prev);
      const x2ds = unstack(reshape(x, [
        outerDimsProd,
        x.shape[x.shape.length - 2],
        x.shape[x.shape.length - 1]
      ]), 0);
      const q2ds = [];
      const r2ds = [];
      x2ds.forEach((x2d) => {
        const [q2d, r2d] = qr2d(x2d, fullMatrices);
        q2ds.push(q2d);
        r2ds.push(r2d);
      });
      const q = reshape(stack(q2ds, 0), x.shape);
      const r = reshape(stack(r2ds, 0), x.shape);
      return [q, r];
    }
  }
  function qr2d(x, fullMatrices = false) {
    return ENGINE.tidy(() => {
      assert(x.shape.length === 2, () => `qr2d() requires a 2D Tensor, but got a ${x.shape.length}D Tensor.`);
      const m = x.shape[0];
      const n = x.shape[1];
      let q = eye(m);
      let r = clone(x);
      const one2D = tensor2d([[1]], [1, 1]);
      let w = clone(one2D);
      const iters = m >= n ? n : m;
      for (let j = 0; j < iters; ++j) {
        const rTemp = r;
        const wTemp = w;
        const qTemp = q;
        [w, r, q] = ENGINE.tidy(() => {
          const rjEnd1 = slice(r, [j, j], [m - j, 1]);
          const normX = norm(rjEnd1);
          const rjj = slice(r, [j, j], [1, 1]);
          const s = where(greater(rjj, 0), tensor2d([[-1]]), tensor2d([[1]]));
          const u1 = sub(rjj, mul(s, normX));
          const wPre = div(rjEnd1, u1);
          if (wPre.shape[0] === 1) {
            w = clone(one2D);
          } else {
            w = concat([
              one2D,
              slice(wPre, [1, 0], [wPre.shape[0] - 1, wPre.shape[1]])
            ], 0);
          }
          const tau = neg(div(matMul(s, u1), normX));
          const rjEndAll = slice(r, [j, 0], [m - j, n]);
          const tauTimesW = mul(tau, w);
          const wT = transpose(w);
          if (j === 0) {
            r = sub(rjEndAll, matMul(tauTimesW, matMul(wT, rjEndAll)));
          } else {
            const rTimesTau = sub(rjEndAll, matMul(tauTimesW, matMul(wT, rjEndAll)));
            r = concat([slice(r, [0, 0], [j, n]), rTimesTau], 0);
          }
          const tawTimesWT = transpose(tauTimesW);
          const qAllJEnd = slice(q, [0, j], [m, q.shape[1] - j]);
          if (j === 0) {
            q = sub(qAllJEnd, matMul(matMul(qAllJEnd, w), tawTimesWT));
          } else {
            const qTimesTau = sub(qAllJEnd, matMul(matMul(qAllJEnd, w), tawTimesWT));
            q = concat([slice(q, [0, 0], [m, j]), qTimesTau], 1);
          }
          return [w, r, q];
        });
        dispose([rTemp, wTemp, qTemp]);
      }
      if (!fullMatrices && m > n) {
        q = slice(q, [0, 0], [m, n]);
        r = slice(r, [0, 0], [n, n]);
      }
      return [q, r];
    });
  }
  const qr = op({qr_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/loss_ops_utils.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  var Reduction;
  (function(Reduction2) {
    Reduction2[Reduction2["NONE"] = 0] = "NONE";
    Reduction2[Reduction2["MEAN"] = 1] = "MEAN";
    Reduction2[Reduction2["SUM"] = 2] = "SUM";
    Reduction2[Reduction2["SUM_BY_NONZERO_WEIGHTS"] = 3] = "SUM_BY_NONZERO_WEIGHTS";
  })(Reduction || (Reduction = {}));

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/compute_weighted_loss.js
  function computeWeightedLoss_(losses2, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $losses = convertToTensor(losses2, "losses", "computeWeightedLoss");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "computeWeightedLoss");
    }
    const weightedLoss = $weights == null ? $losses : mul($losses, $weights);
    if (reduction === Reduction.NONE) {
      return weightedLoss;
    }
    if (reduction === Reduction.SUM) {
      return sum2(weightedLoss);
    }
    if (reduction === Reduction.MEAN) {
      if ($weights == null) {
        return mean(weightedLoss);
      } else {
        const broadcastFactor = $losses.size / $weights.size;
        const result = div(sum2(weightedLoss), sum2($weights));
        return broadcastFactor > 1 ? div(result, scalar(broadcastFactor)) : result;
      }
    }
    if (reduction === Reduction.SUM_BY_NONZERO_WEIGHTS) {
      if ($weights == null) {
        return div(sum2(weightedLoss), scalar($losses.size));
      } else {
        const broadcastedWeights = mul($weights, ones2($losses.shape));
        const numNonZeros = cast(sum2(notEqual(broadcastedWeights, scalar(0))), "float32");
        return div(sum2(weightedLoss), numNonZeros);
      }
    }
    throw Error(`Unknown reduction: ${reduction}`);
  }
  const computeWeightedLoss = op({computeWeightedLoss_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/absolute_difference.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function absoluteDifference_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $labels = convertToTensor(labels, "labels", "absoluteDifference");
    const $predictions = convertToTensor(predictions, "predictions", "absoluteDifference");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "absoluteDifference");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in absoluteDifference: ");
    const losses2 = abs(sub($labels, $predictions));
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const absoluteDifference = op({absoluteDifference_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/cosine_distance.js
  function cosineDistance_(labels, predictions, axis, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $labels = convertToTensor(labels, "labels", "cosineDistance");
    const $predictions = convertToTensor(predictions, "predictions", "cosineDistance");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "cosineDistance");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in cosineDistance: ");
    const one = scalar(1);
    const losses2 = sub(one, sum2(mul($labels, $predictions), axis, true));
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const cosineDistance = op({cosineDistance_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/hinge_loss.js
  function hingeLoss_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    let $labels = convertToTensor(labels, "labels", "hingeLoss");
    const $predictions = convertToTensor(predictions, "predictions", "hingeLoss");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "hingeLoss");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in hingeLoss: ");
    const one = scalar(1);
    $labels = sub(mul(scalar(2), $labels), one);
    const losses2 = relu(sub(one, mul($labels, $predictions)));
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const hingeLoss = op({hingeLoss_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/huber_loss.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function huberLoss_(labels, predictions, weights, delta = 1, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $labels = convertToTensor(labels, "labels", "huberLoss");
    const $predictions = convertToTensor(predictions, "predictions", "huberLoss");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "huberLoss");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in huberLoss: ");
    const deltaScalar = scalar(delta);
    const error = abs(sub($predictions, $labels));
    const quadratic = minimum(error, deltaScalar);
    const linear = sub(error, quadratic);
    const losses2 = add2(mul(scalar(0.5), square(quadratic)), mul(deltaScalar, linear));
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const huberLoss = op({huberLoss_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/log_loss.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function logLoss_(labels, predictions, weights, epsilon2 = 1e-7, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $labels = convertToTensor(labels, "labels", "logLoss");
    const $predictions = convertToTensor(predictions, "predictions", "logLoss");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "logLoss");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in logLoss: ");
    const one = scalar(1);
    const epsilonScalar = scalar(epsilon2);
    const l1 = neg(mul($labels, log(add2($predictions, epsilonScalar))));
    const l2 = mul(sub(one, $labels), log(add2(sub(one, $predictions), epsilonScalar)));
    const losses2 = sub(l1, l2);
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const logLoss = op({logLoss_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/mean_squared_error.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function meanSquaredError_(labels, predictions, weights, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    const $labels = convertToTensor(labels, "labels", "meanSquaredError");
    const $predictions = convertToTensor(predictions, "predictions", "meanSquaredError");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "meanSquaredError");
    }
    assertShapesMatch($labels.shape, $predictions.shape, "Error in meanSquaredError: ");
    const losses2 = squaredDifference($labels, $predictions);
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const meanSquaredError = op({meanSquaredError_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/sigmoid_cross_entropy.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function sigmoidCrossEntropyWithLogits_(labels, logits) {
    const $labels = convertToTensor(labels, "labels", "sigmoidCrossEntropyWithLogits");
    const $logits = convertToTensor(logits, "logits", "sigmoidCrossEntropyWithLogits");
    assertShapesMatch($labels.shape, $logits.shape, "Error in sigmoidCrossEntropyWithLogits: ");
    const maxOutput = relu($logits);
    const outputXTarget = mul($logits, $labels);
    const sigmoidOutput = log1p(exp(neg(abs($logits))));
    return add2(sub(maxOutput, outputXTarget), sigmoidOutput);
  }
  function sigmoidCrossEntropy_(multiClassLabels, logits, weights, labelSmoothing = 0, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    let $multiClassLabels = convertToTensor(multiClassLabels, "multiClassLabels", "sigmoidCrossEntropy");
    const $logits = convertToTensor(logits, "logits", "sigmoidCrossEntropy");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "sigmoidCrossEntropy");
    }
    assertShapesMatch($multiClassLabels.shape, $logits.shape, "Error in sigmoidCrossEntropy: ");
    if (labelSmoothing > 0) {
      const labelSmoothingScalar = scalar(labelSmoothing);
      const one = scalar(1);
      const half = scalar(0.5);
      $multiClassLabels = add2(mul($multiClassLabels, sub(one, labelSmoothingScalar)), mul(half, labelSmoothingScalar));
    }
    const losses2 = sigmoidCrossEntropyWithLogits_($multiClassLabels, $logits);
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const sigmoidCrossEntropy = op({sigmoidCrossEntropy_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/losses/softmax_cross_entropy.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function softmaxCrossEntropyWithLogits_(labels, logits, dim = -1) {
    if (dim === -1) {
      dim = logits.rank - 1;
    }
    if (dim !== logits.rank - 1) {
      throw Error(`Softmax cross entropy along a non-last dimension is not yet supported. Labels / logits was rank ${logits.rank} and dim was ${dim}`);
    }
    const customOp = customGrad((labels2, logits2, save) => {
      const keepDims = true;
      const lse = logSumExp(logits2, [dim], keepDims);
      const logResult = sub(cast(logits2, "float32"), lse);
      save([labels2, logResult]);
      const costVector = neg(mul(logResult, labels2));
      const value = sum2(costVector, [dim]);
      const gradFunc = (dy, saved) => {
        const [labels3, logResult2] = saved;
        const dyShape = expandShapeToKeepDim(dy.shape, [dim]);
        return [
          mul(reshape(dy, dyShape), sub(cast(labels3, "float32"), exp(logResult2))),
          mul(reshape(dy, dyShape), sub(exp(logResult2), cast(labels3, "float32")))
        ];
      };
      return {value, gradFunc};
    });
    return customOp(labels, logits);
  }
  function softmaxCrossEntropy_(onehotLabels, logits, weights, labelSmoothing = 0, reduction = Reduction.SUM_BY_NONZERO_WEIGHTS) {
    let $onehotLabels = convertToTensor(onehotLabels, "onehotLabels", "softmaxCrossEntropy");
    const $logits = convertToTensor(logits, "logits", "softmaxCrossEntropy");
    let $weights = null;
    if (weights != null) {
      $weights = convertToTensor(weights, "weights", "softmaxCrossEntropy");
    }
    assertShapesMatch($onehotLabels.shape, $logits.shape, "Error in softmaxCrossEntropy: ");
    if (labelSmoothing > 0) {
      const labelSmoothingScalar = scalar(labelSmoothing);
      const one = scalar(1);
      const numClasses = scalar($onehotLabels.shape[1]);
      $onehotLabels = add2(mul($onehotLabels, sub(one, labelSmoothingScalar)), div(labelSmoothingScalar, numClasses));
    }
    const losses2 = softmaxCrossEntropyWithLogits_($onehotLabels, $logits);
    return computeWeightedLoss(losses2, $weights, reduction);
  }
  const softmaxCrossEntropy = op({softmaxCrossEntropy_});

  // node_modules/@tensorflow/tfjs-core/dist/ops/ops.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const spectral = {
    fft,
    ifft,
    rfft,
    irfft
  };
  const signal = {
    hammingWindow,
    hannWindow,
    frame,
    stft
  };
  const image = {
    flipLeftRight,
    resizeNearestNeighbor,
    resizeBilinear,
    rotateWithOffset,
    cropAndResize,
    nonMaxSuppression,
    nonMaxSuppressionAsync,
    nonMaxSuppressionWithScore,
    nonMaxSuppressionWithScoreAsync,
    nonMaxSuppressionPadded,
    nonMaxSuppressionPaddedAsync
  };
  const linalg = {
    bandPart,
    gramSchmidt,
    qr
  };
  const losses = {
    absoluteDifference,
    computeWeightedLoss,
    cosineDistance,
    hingeLoss,
    huberLoss,
    logLoss,
    meanSquaredError,
    sigmoidCrossEntropy,
    softmaxCrossEntropy
  };

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class Optimizer extends Serializable {
    minimize(f, returnCost = false, varList) {
      const {value, grads: grads2} = this.computeGradients(f, varList);
      if (varList != null) {
        const gradArray = varList.map((v) => ({name: v.name, tensor: grads2[v.name]}));
        this.applyGradients(gradArray);
      } else {
        this.applyGradients(grads2);
      }
      dispose(grads2);
      if (returnCost) {
        return value;
      } else {
        value.dispose();
        return null;
      }
    }
    get iterations() {
      if (this.iterations_ == null) {
        this.iterations_ = 0;
      }
      return this.iterations_;
    }
    incrementIterations() {
      this.iterations_ = this.iterations + 1;
    }
    computeGradients(f, varList) {
      return variableGrads(f, varList);
    }
    dispose() {
      if (this.iterations_ != null) {
        dispose(this.iterations_);
      }
    }
    async saveIterations() {
      if (this.iterations_ == null) {
        this.iterations_ = 0;
      }
      return {
        name: "iter",
        tensor: scalar(this.iterations_, "int32")
      };
    }
    async getWeights() {
      throw new Error("getWeights() is not implemented for this optimizer yet.");
    }
    async setWeights(weightValues) {
      throw new Error(`setWeights() is not implemented for this optimizer class ${this.getClassName()}`);
    }
    async extractIterations(weightValues) {
      this.iterations_ = (await weightValues[0].tensor.data())[0];
      return weightValues.slice(1);
    }
  }
  Object.defineProperty(Optimizer, Symbol.hasInstance, {
    value: (instance) => {
      return instance.minimize != null && instance.computeGradients != null && instance.applyGradients != null;
    }
  });

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/adadelta_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class AdadeltaOptimizer extends Optimizer {
    constructor(learningRate, rho, epsilon2 = null) {
      super();
      this.learningRate = learningRate;
      this.rho = rho;
      this.epsilon = epsilon2;
      this.accumulatedGrads = [];
      this.accumulatedUpdates = [];
      if (epsilon2 == null) {
        this.epsilon = ENGINE.backend.epsilon();
      }
    }
    applyGradients(variableGradients) {
      const variableNames = Array.isArray(variableGradients) ? variableGradients.map((item) => item.name) : Object.keys(variableGradients);
      variableNames.forEach((name, i) => {
        const value = ENGINE.registeredVariables[name];
        const trainable = false;
        if (this.accumulatedGrads[i] == null) {
          this.accumulatedGrads[i] = {
            originalName: `${name}/accum_grad`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        if (this.accumulatedUpdates[i] == null) {
          this.accumulatedUpdates[i] = {
            originalName: `${name}/accum_var`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
        if (gradient == null) {
          return;
        }
        const accumulatedGrad = this.accumulatedGrads[i].variable;
        const accumulatedUpdate = this.accumulatedUpdates[i].variable;
        tidy(() => {
          const newAccumulatedGrad = add2(mul(accumulatedGrad, this.rho), mul(square(gradient), 1 - this.rho));
          const updates = mul(div(sqrt(add2(accumulatedUpdate, this.epsilon)), sqrt(add2(accumulatedGrad, this.epsilon))), gradient);
          const newAccumulatedUpdate = add2(mul(accumulatedUpdate, this.rho), mul(square(updates), 1 - this.rho));
          accumulatedGrad.assign(newAccumulatedGrad);
          accumulatedUpdate.assign(newAccumulatedUpdate);
          const newValue = add2(mul(updates, -this.learningRate), value);
          value.assign(newValue);
        });
      });
      this.incrementIterations();
    }
    dispose() {
      if (this.accumulatedUpdates != null) {
        dispose(this.accumulatedGrads.map((v) => v.variable));
        dispose(this.accumulatedUpdates.map((v) => v.variable));
      }
    }
    async getWeights() {
      const variables = [...this.accumulatedGrads, ...this.accumulatedUpdates];
      return [await this.saveIterations()].concat(variables.map((v) => ({name: v.originalName, tensor: v.variable})));
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      const variableCount = weightValues.length / 2;
      const trainable = false;
      this.accumulatedGrads = weightValues.slice(0, variableCount).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
      this.accumulatedUpdates = weightValues.slice(variableCount, variableCount * 2).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        rho: this.rho,
        epsilon: this.epsilon
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["rho"], config2["epsilon"]);
    }
  }
  AdadeltaOptimizer.className = "Adadelta";
  registerClass(AdadeltaOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/adagrad_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class AdagradOptimizer extends Optimizer {
    constructor(learningRate, initialAccumulatorValue = 0.1) {
      super();
      this.learningRate = learningRate;
      this.initialAccumulatorValue = initialAccumulatorValue;
      this.accumulatedGrads = [];
    }
    applyGradients(variableGradients) {
      const variableNames = Array.isArray(variableGradients) ? variableGradients.map((item) => item.name) : Object.keys(variableGradients);
      variableNames.forEach((name, i) => {
        const value = ENGINE.registeredVariables[name];
        if (this.accumulatedGrads[i] == null) {
          const trainable = false;
          this.accumulatedGrads[i] = {
            originalName: `${name}/accumulator`,
            variable: tidy(() => fill(value.shape, this.initialAccumulatorValue).variable(trainable))
          };
        }
        const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
        if (gradient == null) {
          return;
        }
        const accumulatedGrad = this.accumulatedGrads[i].variable;
        tidy(() => {
          const newAccumulatedGrad = add2(accumulatedGrad, square(gradient));
          accumulatedGrad.assign(newAccumulatedGrad);
          const newValue = add2(mul(div(gradient, sqrt(add2(newAccumulatedGrad, ENGINE.backend.epsilon()))), -this.learningRate), value);
          value.assign(newValue);
        });
      });
      this.incrementIterations();
    }
    dispose() {
      if (this.accumulatedGrads != null) {
        dispose(this.accumulatedGrads.map((v) => v.variable));
      }
    }
    async getWeights() {
      return [await this.saveIterations()].concat(this.accumulatedGrads.map((v) => ({name: v.originalName, tensor: v.variable})));
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      const trainable = false;
      this.accumulatedGrads = weightValues.map((v) => ({originalName: v.name, variable: v.tensor.variable(trainable)}));
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        initialAccumulatorValue: this.initialAccumulatorValue
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["initialAccumulatorValue"]);
    }
  }
  AdagradOptimizer.className = "Adagrad";
  registerClass(AdagradOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/adam_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class AdamOptimizer extends Optimizer {
    constructor(learningRate, beta1, beta2, epsilon2 = null) {
      super();
      this.learningRate = learningRate;
      this.beta1 = beta1;
      this.beta2 = beta2;
      this.epsilon = epsilon2;
      this.accumulatedFirstMoment = [];
      this.accumulatedSecondMoment = [];
      tidy(() => {
        this.accBeta1 = scalar(beta1).variable();
        this.accBeta2 = scalar(beta2).variable();
      });
      if (epsilon2 == null) {
        this.epsilon = ENGINE.backend.epsilon();
      }
    }
    applyGradients(variableGradients) {
      const varNames = Array.isArray(variableGradients) ? variableGradients.map((v) => v.name) : Object.keys(variableGradients);
      tidy(() => {
        const oneMinusAccBeta1 = sub(1, this.accBeta1);
        const oneMinusAccBeta2 = sub(1, this.accBeta2);
        varNames.forEach((name, i) => {
          const value = ENGINE.registeredVariables[name];
          const trainable = false;
          if (this.accumulatedFirstMoment[i] == null) {
            this.accumulatedFirstMoment[i] = {
              originalName: `${name}/m`,
              variable: tidy(() => zerosLike(value).variable(trainable))
            };
          }
          if (this.accumulatedSecondMoment[i] == null) {
            this.accumulatedSecondMoment[i] = {
              originalName: `${name}/v`,
              variable: tidy(() => zerosLike(value).variable(trainable))
            };
          }
          const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
          if (gradient == null) {
            return;
          }
          const firstMoment = this.accumulatedFirstMoment[i].variable;
          const secondMoment = this.accumulatedSecondMoment[i].variable;
          const newFirstMoment = add2(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
          const newSecondMoment = add2(mul(secondMoment, this.beta2), mul(square(gradient), 1 - this.beta2));
          const biasCorrectedFirstMoment = div(newFirstMoment, oneMinusAccBeta1);
          const biasCorrectedSecondMoment = div(newSecondMoment, oneMinusAccBeta2);
          firstMoment.assign(newFirstMoment);
          secondMoment.assign(newSecondMoment);
          const newValue = add2(mul(div(biasCorrectedFirstMoment, add2(sqrt(biasCorrectedSecondMoment), this.epsilon)), -this.learningRate), value);
          value.assign(newValue);
        });
        this.accBeta1.assign(mul(this.accBeta1, this.beta1));
        this.accBeta2.assign(mul(this.accBeta2, this.beta2));
      });
      this.incrementIterations();
    }
    dispose() {
      this.accBeta1.dispose();
      this.accBeta2.dispose();
      if (this.accumulatedFirstMoment != null) {
        dispose(this.accumulatedFirstMoment.map((v) => v.variable));
      }
      if (this.accumulatedSecondMoment != null) {
        dispose(this.accumulatedSecondMoment.map((v) => v.variable));
      }
    }
    async getWeights() {
      const variables = [...this.accumulatedFirstMoment, ...this.accumulatedSecondMoment];
      return [await this.saveIterations()].concat(variables.map((v) => ({name: v.originalName, tensor: v.variable})));
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      tidy(() => {
        this.accBeta1.assign(pow(this.beta1, this.iterations_ + 1));
        this.accBeta2.assign(pow(this.beta2, this.iterations_ + 1));
      });
      const variableCount = weightValues.length / 2;
      const trainable = false;
      this.accumulatedFirstMoment = weightValues.slice(0, variableCount).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
      this.accumulatedSecondMoment = weightValues.slice(variableCount, variableCount * 2).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        beta1: this.beta1,
        beta2: this.beta2,
        epsilon: this.epsilon
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["beta1"], config2["beta2"], config2["epsilon"]);
    }
  }
  AdamOptimizer.className = "Adam";
  registerClass(AdamOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/adamax_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class AdamaxOptimizer extends Optimizer {
    constructor(learningRate, beta1, beta2, epsilon2 = null, decay = 0) {
      super();
      this.learningRate = learningRate;
      this.beta1 = beta1;
      this.beta2 = beta2;
      this.epsilon = epsilon2;
      this.decay = decay;
      this.accumulatedFirstMoment = [];
      this.accumulatedWeightedInfNorm = [];
      tidy(() => {
        this.iteration = scalar(0).variable();
        this.accBeta1 = scalar(beta1).variable();
      });
      if (epsilon2 == null) {
        this.epsilon = ENGINE.backend.epsilon();
      }
    }
    applyGradients(variableGradients) {
      const variableNames = Array.isArray(variableGradients) ? variableGradients.map((item) => item.name) : Object.keys(variableGradients);
      tidy(() => {
        const oneMinusAccBeta1 = sub(1, this.accBeta1);
        const lr = div(-this.learningRate, add2(mul(this.iteration, this.decay), 1));
        variableNames.forEach((name, i) => {
          const value = ENGINE.registeredVariables[name];
          const trainable = false;
          if (this.accumulatedFirstMoment[i] == null) {
            this.accumulatedFirstMoment[i] = {
              originalName: `${name}/m`,
              variable: zerosLike(value).variable(trainable)
            };
          }
          if (this.accumulatedWeightedInfNorm[i] == null) {
            this.accumulatedWeightedInfNorm[i] = {
              originalName: `${name}/v`,
              variable: zerosLike(value).variable(trainable)
            };
          }
          const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
          if (gradient == null) {
            return;
          }
          const firstMoment = this.accumulatedFirstMoment[i].variable;
          const weightedInfNorm = this.accumulatedWeightedInfNorm[i].variable;
          const newFirstMoment = add2(mul(firstMoment, this.beta1), mul(gradient, 1 - this.beta1));
          const ut0 = mul(weightedInfNorm, this.beta2);
          const ut1 = abs(gradient);
          const newWeightedInfNorm = maximum(ut0, ut1);
          firstMoment.assign(newFirstMoment);
          weightedInfNorm.assign(newWeightedInfNorm);
          const newValue = add2(mul(div(lr, oneMinusAccBeta1), div(newFirstMoment, add2(newWeightedInfNorm, this.epsilon))), value);
          value.assign(newValue);
        });
        this.iteration.assign(add2(this.iteration, 1));
        this.accBeta1.assign(mul(this.accBeta1, this.beta1));
      });
      this.incrementIterations();
    }
    dispose() {
      this.accBeta1.dispose();
      this.iteration.dispose();
      if (this.accumulatedFirstMoment != null) {
        dispose(this.accumulatedFirstMoment.map((v) => v.variable));
      }
      if (this.accumulatedWeightedInfNorm != null) {
        dispose(this.accumulatedWeightedInfNorm.map((v) => v.variable));
      }
    }
    async getWeights() {
      throw new Error("getWeights() is not implemented for Adamax yet.");
    }
    async setWeights(weightValues) {
      throw new Error("setWeights() is not implemented for Adamax yet.");
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        beta1: this.beta1,
        beta2: this.beta2,
        epsilon: this.epsilon,
        decay: this.decay
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["beta1"], config2["beta2"], config2["epsilon"], config2["decay"]);
    }
  }
  AdamaxOptimizer.className = "Adamax";
  registerClass(AdamaxOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/sgd_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class SGDOptimizer extends Optimizer {
    constructor(learningRate) {
      super();
      this.learningRate = learningRate;
      this.setLearningRate(learningRate);
    }
    applyGradients(variableGradients) {
      const varNames = Array.isArray(variableGradients) ? variableGradients.map((v) => v.name) : Object.keys(variableGradients);
      varNames.forEach((name, i) => {
        const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
        if (gradient == null) {
          return;
        }
        const value = ENGINE.registeredVariables[name];
        tidy(() => {
          const newValue = add2(mul(this.c, gradient), value);
          value.assign(newValue);
        });
      });
      this.incrementIterations();
    }
    setLearningRate(learningRate) {
      this.learningRate = learningRate;
      if (this.c != null) {
        this.c.dispose();
      }
      this.c = keep(scalar(-learningRate));
    }
    dispose() {
      this.c.dispose();
    }
    async getWeights() {
      return [await this.saveIterations()];
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      if (weightValues.length !== 0) {
        throw new Error("SGD optimizer does not have settable weights.");
      }
    }
    getConfig() {
      return {learningRate: this.learningRate};
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"]);
    }
  }
  SGDOptimizer.className = "SGD";
  registerClass(SGDOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/momentum_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class MomentumOptimizer extends SGDOptimizer {
    constructor(learningRate, momentum, useNesterov = false) {
      super(learningRate);
      this.learningRate = learningRate;
      this.momentum = momentum;
      this.useNesterov = useNesterov;
      this.accumulations = [];
      this.m = scalar(this.momentum);
    }
    applyGradients(variableGradients) {
      const variableNames = Array.isArray(variableGradients) ? variableGradients.map((item) => item.name) : Object.keys(variableGradients);
      variableNames.forEach((name, i) => {
        const value = ENGINE.registeredVariables[name];
        if (this.accumulations[i] == null) {
          const trainable = false;
          this.accumulations[i] = {
            originalName: `${name}/momentum`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        const accumulation = this.accumulations[i].variable;
        const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
        if (gradient == null) {
          return;
        }
        tidy(() => {
          let newValue;
          const newAccumulation = add2(mul(this.m, accumulation), gradient);
          if (this.useNesterov) {
            newValue = add2(mul(this.c, add2(gradient, mul(newAccumulation, this.m))), value);
          } else {
            newValue = add2(mul(this.c, newAccumulation), value);
          }
          accumulation.assign(newAccumulation);
          value.assign(newValue);
        });
      });
      this.incrementIterations();
    }
    dispose() {
      this.m.dispose();
      if (this.accumulations != null) {
        dispose(this.accumulations.map((v) => v.variable));
      }
    }
    setMomentum(momentum) {
      this.momentum = momentum;
    }
    async getWeights() {
      return [await this.saveIterations()].concat(this.accumulations.map((v) => ({name: v.originalName, tensor: v.variable})));
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      const trainable = false;
      this.accumulations = weightValues.map((v) => ({originalName: v.name, variable: v.tensor.variable(trainable)}));
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        momentum: this.momentum,
        useNesterov: this.useNesterov
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["momentum"], config2["useNesterov"]);
    }
  }
  MomentumOptimizer.className = "Momentum";
  registerClass(MomentumOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/rmsprop_optimizer.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class RMSPropOptimizer extends Optimizer {
    constructor(learningRate, decay = 0.9, momentum = 0, epsilon2 = null, centered = false) {
      super();
      this.learningRate = learningRate;
      this.decay = decay;
      this.momentum = momentum;
      this.epsilon = epsilon2;
      this.accumulatedMeanSquares = [];
      this.accumulatedMoments = [];
      this.accumulatedMeanGrads = [];
      this.centered = centered;
      if (epsilon2 == null) {
        this.epsilon = ENGINE.backend.epsilon();
      }
      if (learningRate == null) {
        throw new Error(`learningRate for RMSPropOptimizer must be defined.`);
      }
    }
    applyGradients(variableGradients) {
      const variableNames = Array.isArray(variableGradients) ? variableGradients.map((item) => item.name) : Object.keys(variableGradients);
      variableNames.forEach((name, i) => {
        const value = ENGINE.registeredVariables[name];
        const trainable = false;
        if (this.accumulatedMeanSquares[i] == null) {
          this.accumulatedMeanSquares[i] = {
            originalName: `${name}/rms`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        if (this.accumulatedMoments[i] == null) {
          this.accumulatedMoments[i] = {
            originalName: `${name}/momentum`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        if (this.accumulatedMeanGrads[i] == null && this.centered) {
          this.accumulatedMeanGrads[i] = {
            originalName: `${name}/mg`,
            variable: tidy(() => zerosLike(value).variable(trainable))
          };
        }
        const gradient = Array.isArray(variableGradients) ? variableGradients[i].tensor : variableGradients[name];
        if (gradient == null) {
          return;
        }
        const accumulatedMeanSquare = this.accumulatedMeanSquares[i].variable;
        const accumulatedMoments = this.accumulatedMoments[i].variable;
        tidy(() => {
          const newAccumulatedMeanSquare = add2(mul(accumulatedMeanSquare, this.decay), mul(square(gradient), 1 - this.decay));
          if (this.centered) {
            const accumulatedMeanGrad = this.accumulatedMeanGrads[i].variable;
            const newAccumulatedMeanGrad = add2(mul(accumulatedMeanGrad, this.decay), mul(gradient, 1 - this.decay));
            const gradContribution = div(mul(gradient, this.learningRate), sqrt(sub(newAccumulatedMeanSquare, add2(square(newAccumulatedMeanGrad), this.epsilon))));
            const newAccumulatedMoments = add2(mul(accumulatedMoments, this.momentum), gradContribution);
            accumulatedMeanSquare.assign(newAccumulatedMeanSquare);
            accumulatedMeanGrad.assign(newAccumulatedMeanGrad);
            accumulatedMoments.assign(newAccumulatedMoments);
            const newValue = sub(value, newAccumulatedMoments);
            value.assign(newValue);
          } else {
            const newAccumulatedMeanSquare2 = add2(mul(accumulatedMeanSquare, this.decay), mul(square(gradient), 1 - this.decay));
            const newAccumulatedMoments = add2(mul(accumulatedMoments, this.momentum), div(mul(gradient, this.learningRate), sqrt(add2(newAccumulatedMeanSquare2, this.epsilon))));
            accumulatedMeanSquare.assign(newAccumulatedMeanSquare2);
            accumulatedMoments.assign(newAccumulatedMoments);
            const newValue = sub(value, newAccumulatedMoments);
            value.assign(newValue);
          }
        });
      });
      this.incrementIterations();
    }
    dispose() {
      if (this.accumulatedMeanSquares != null) {
        dispose(this.accumulatedMeanSquares.map((v) => v.variable));
      }
      if (this.accumulatedMeanGrads != null && this.centered) {
        dispose(this.accumulatedMeanGrads.map((v) => v.variable));
      }
      if (this.accumulatedMoments != null) {
        dispose(this.accumulatedMoments.map((v) => v.variable));
      }
    }
    async getWeights() {
      const variables = [...this.accumulatedMeanSquares, ...this.accumulatedMoments];
      if (this.centered) {
        variables.push(...this.accumulatedMeanGrads);
      }
      return [await this.saveIterations()].concat(variables.map((v) => ({name: v.originalName, tensor: v.variable})));
    }
    async setWeights(weightValues) {
      weightValues = await this.extractIterations(weightValues);
      const variableCount = this.centered ? weightValues.length / 3 : weightValues.length / 2;
      const trainable = false;
      this.accumulatedMeanSquares = weightValues.slice(0, variableCount).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
      this.accumulatedMoments = weightValues.slice(variableCount, variableCount * 2).map((v) => ({
        originalName: v.name,
        variable: v.tensor.variable(trainable)
      }));
      if (this.centered) {
        this.accumulatedMeanGrads = weightValues.slice(variableCount * 2, variableCount * 3).map((v) => ({
          originalName: v.name,
          variable: v.tensor.variable(trainable)
        }));
      }
    }
    getConfig() {
      return {
        learningRate: this.learningRate,
        decay: this.decay,
        momentum: this.momentum,
        epsilon: this.epsilon,
        centered: this.centered
      };
    }
    static fromConfig(cls, config2) {
      return new cls(config2["learningRate"], config2["decay"], config2["momentum"], config2["epsilon"], config2["centered"]);
    }
  }
  RMSPropOptimizer.className = "RMSProp";
  registerClass(RMSPropOptimizer);

  // node_modules/@tensorflow/tfjs-core/dist/optimizers/optimizer_constructors.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  class OptimizerConstructors {
    static sgd(learningRate) {
      return new SGDOptimizer(learningRate);
    }
    static momentum(learningRate, momentum, useNesterov = false) {
      return new MomentumOptimizer(learningRate, momentum, useNesterov);
    }
    static rmsprop(learningRate, decay = 0.9, momentum = 0, epsilon2 = null, centered = false) {
      return new RMSPropOptimizer(learningRate, decay, momentum, epsilon2, centered);
    }
    static adam(learningRate = 1e-3, beta1 = 0.9, beta2 = 0.999, epsilon2 = null) {
      return new AdamOptimizer(learningRate, beta1, beta2, epsilon2);
    }
    static adadelta(learningRate = 1e-3, rho = 0.95, epsilon2 = null) {
      return new AdadeltaOptimizer(learningRate, rho, epsilon2);
    }
    static adamax(learningRate = 2e-3, beta1 = 0.9, beta2 = 0.999, epsilon2 = null, decay = 0) {
      return new AdamaxOptimizer(learningRate, beta1, beta2, epsilon2, decay);
    }
    static adagrad(learningRate, initialAccumulatorValue = 0.1) {
      return new AdagradOptimizer(learningRate, initialAccumulatorValue);
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/train.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  [
    MomentumOptimizer,
    SGDOptimizer,
    AdadeltaOptimizer,
    AdagradOptimizer,
    RMSPropOptimizer,
    AdamaxOptimizer,
    AdamOptimizer
  ];
  const train = {
    sgd: OptimizerConstructors.sgd,
    momentum: OptimizerConstructors.momentum,
    adadelta: OptimizerConstructors.adadelta,
    adagrad: OptimizerConstructors.adagrad,
    rmsprop: OptimizerConstructors.rmsprop,
    adamax: OptimizerConstructors.adamax,
    adam: OptimizerConstructors.adam
  };

  // node_modules/@tensorflow/tfjs-core/dist/browser_util.js
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const delayCallback = (() => {
    if (typeof requestAnimationFrame !== "undefined") {
      return requestAnimationFrame;
    } else if (typeof setImmediate !== "undefined") {
      return setImmediate;
    }
    return (f) => f();
  })();
  function nextFrame() {
    return new Promise((resolve) => delayCallback(() => resolve()));
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/rotate_util.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getImageCenter(center, imageHeight, imageWidth) {
    const centerX = imageWidth * (typeof center === "number" ? center : center[0]);
    const centerY = imageHeight * (typeof center === "number" ? center : center[1]);
    return [centerX, centerY];
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/array_ops_util.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function getReshaped(inputShape, blockShape, prod3, batchToSpace = true) {
    let reshaped = [];
    if (batchToSpace) {
      reshaped = reshaped.concat(blockShape.slice(0));
      reshaped.push(inputShape[0] / prod3);
      reshaped = reshaped.concat(inputShape.slice(1));
    } else {
      reshaped = reshaped.concat(inputShape[0]);
      const spatialLength = blockShape.length;
      for (let i = 0; i < spatialLength; ++i) {
        reshaped = reshaped.concat([inputShape[i + 1] / blockShape[i], blockShape[i]]);
      }
      reshaped = reshaped.concat(inputShape.slice(spatialLength + 1));
    }
    return reshaped;
  }
  function getPermuted(reshapedRank, blockShapeRank, batchToSpace = true) {
    const permuted = [];
    if (batchToSpace) {
      permuted.push(blockShapeRank);
      for (let i = blockShapeRank + 1; i < reshapedRank; ++i) {
        if (i <= 2 * blockShapeRank) {
          permuted.push(i);
          permuted.push(i - (blockShapeRank + 1));
        } else {
          permuted.push(i);
        }
      }
    } else {
      const permutedBeforeBatch = [];
      const permutedAfterBatch = [];
      for (let i = 1; i < reshapedRank; ++i) {
        if (i >= blockShapeRank * 2 + 1 || i % 2 === 1) {
          permutedAfterBatch.push(i);
        } else {
          permutedBeforeBatch.push(i);
        }
      }
      permuted.push(...permutedBeforeBatch);
      permuted.push(0);
      permuted.push(...permutedAfterBatch);
    }
    return permuted;
  }
  function getReshapedPermuted(inputShape, blockShape, prod3, batchToSpace = true) {
    const reshapedPermuted = [];
    if (batchToSpace) {
      reshapedPermuted.push(inputShape[0] / prod3);
    } else {
      reshapedPermuted.push(inputShape[0] * prod3);
    }
    for (let i = 1; i < inputShape.length; ++i) {
      if (i <= blockShape.length) {
        if (batchToSpace) {
          reshapedPermuted.push(blockShape[i - 1] * inputShape[i]);
        } else {
          reshapedPermuted.push(inputShape[i] / blockShape[i - 1]);
        }
      } else {
        reshapedPermuted.push(inputShape[i]);
      }
    }
    return reshapedPermuted;
  }
  function getSliceBeginCoords(crops, blockShape) {
    const sliceBeginCoords = [0];
    for (let i = 0; i < blockShape; ++i) {
      sliceBeginCoords.push(crops[i][0]);
    }
    return sliceBeginCoords;
  }
  function getSliceSize(uncroppedShape, crops, blockShape) {
    const sliceSize = uncroppedShape.slice(0, 1);
    for (let i = 0; i < blockShape; ++i) {
      sliceSize.push(uncroppedShape[i + 1] - crops[i][0] - crops[i][1]);
    }
    return sliceSize;
  }

  // node_modules/@tensorflow/tfjs-core/dist/ops/selu_util.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const SELU_SCALEALPHA = 1.7580993408473768;
  const SELU_SCALE = 1.0507009873554805;

  // node_modules/@tensorflow/tfjs-core/dist/ops/erf_util.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const ERF_P = 0.3275911;
  const ERF_A1 = 0.254829592;
  const ERF_A2 = -0.284496736;
  const ERF_A3 = 1.421413741;
  const ERF_A4 = -1.453152027;
  const ERF_A5 = 1.061405429;

  // node_modules/@tensorflow/tfjs-core/dist/log.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function warn(...msg) {
    if (!env().getBool("IS_TEST")) {
      console.warn(...msg);
    }
  }
  function log6(...msg) {
    if (!env().getBool("IS_TEST")) {
      console.log(...msg);
    }
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/complex_util.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function mergeRealAndImagArrays(real6, imag6) {
    if (real6.length !== imag6.length) {
      throw new Error(`Cannot merge real and imag arrays of different lengths. real:${real6.length}, imag: ${imag6.length}.`);
    }
    const result = new Float32Array(real6.length * 2);
    for (let i = 0; i < result.length; i += 2) {
      result[i] = real6[i / 2];
      result[i + 1] = imag6[i / 2];
    }
    return result;
  }
  function splitRealAndImagArrays(complex9) {
    const real6 = new Float32Array(complex9.length / 2);
    const imag6 = new Float32Array(complex9.length / 2);
    for (let i = 0; i < complex9.length; i += 2) {
      real6[i / 2] = complex9[i];
      imag6[i / 2] = complex9[i + 1];
    }
    return {real: real6, imag: imag6};
  }
  function complexWithEvenIndex(complex9) {
    const len = Math.ceil(complex9.length / 4);
    const real6 = new Float32Array(len);
    const imag6 = new Float32Array(len);
    for (let i = 0; i < complex9.length; i += 4) {
      real6[Math.floor(i / 4)] = complex9[i];
      imag6[Math.floor(i / 4)] = complex9[i + 1];
    }
    return {real: real6, imag: imag6};
  }
  function complexWithOddIndex(complex9) {
    const len = Math.floor(complex9.length / 4);
    const real6 = new Float32Array(len);
    const imag6 = new Float32Array(len);
    for (let i = 2; i < complex9.length; i += 4) {
      real6[Math.floor(i / 4)] = complex9[i];
      imag6[Math.floor(i / 4)] = complex9[i + 1];
    }
    return {real: real6, imag: imag6};
  }
  function getComplexWithIndex(complex9, index) {
    const real6 = complex9[index * 2];
    const imag6 = complex9[index * 2 + 1];
    return {real: real6, imag: imag6};
  }
  function assignToTypedArray(data, real6, imag6, index) {
    data[index * 2] = real6;
    data[index * 2 + 1] = imag6;
  }
  function exponents(n, inverse) {
    const real6 = new Float32Array(n / 2);
    const imag6 = new Float32Array(n / 2);
    for (let i = 0; i < Math.ceil(n / 2); i++) {
      const x = (inverse ? 2 : -2) * Math.PI * (i / n);
      real6[i] = Math.cos(x);
      imag6[i] = Math.sin(x);
    }
    return {real: real6, imag: imag6};
  }
  function exponent(k, n, inverse) {
    const x = (inverse ? 2 : -2) * Math.PI * (k / n);
    const real6 = Math.cos(x);
    const imag6 = Math.sin(x);
    return {real: real6, imag: imag6};
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/backend_util.js
  const backend_util_exports = {};
  __export(backend_util_exports, {
    ERF_A1: () => ERF_A1,
    ERF_A2: () => ERF_A2,
    ERF_A3: () => ERF_A3,
    ERF_A4: () => ERF_A4,
    ERF_A5: () => ERF_A5,
    ERF_P: () => ERF_P,
    PARALLELIZE_THRESHOLD: () => PARALLELIZE_THRESHOLD,
    SELU_SCALE: () => SELU_SCALE,
    SELU_SCALEALPHA: () => SELU_SCALEALPHA,
    applyActivation: () => applyActivation,
    assertAndGetBroadcastShape: () => assertAndGetBroadcastShape,
    assertAxesAreInnerMostDims: () => assertAxesAreInnerMostDims,
    assertParamsConsistent: () => assertParamsConsistent,
    assignToTypedArray: () => assignToTypedArray,
    axesAreInnerMostDims: () => axesAreInnerMostDims,
    calculateShapes: () => calculateShapes,
    castTensor: () => castTensor,
    combineLocations: () => combineLocations,
    complexWithEvenIndex: () => complexWithEvenIndex,
    complexWithOddIndex: () => complexWithOddIndex,
    computeConv2DInfo: () => computeConv2DInfo,
    computeConv3DInfo: () => computeConv3DInfo,
    computeDefaultPad: () => computeDefaultPad,
    computeDilation2DInfo: () => computeDilation2DInfo,
    computeOptimalWindowSize: () => computeOptimalWindowSize,
    computeOutAndReduceShapes: () => computeOutAndReduceShapes,
    computeOutShape: () => computeOutShape2,
    computePool2DInfo: () => computePool2DInfo,
    computePool3DInfo: () => computePool3DInfo,
    convertConv2DDataFormat: () => convertConv2DDataFormat,
    eitherStridesOrDilationsAreOne: () => eitherStridesOrDilationsAreOne,
    expandShapeToKeepDim: () => expandShapeToKeepDim,
    exponent: () => exponent,
    exponents: () => exponents,
    getAxesPermutation: () => getAxesPermutation,
    getBroadcastDims: () => getBroadcastDims,
    getComplexWithIndex: () => getComplexWithIndex,
    getFusedBiasGradient: () => getFusedBiasGradient,
    getFusedDyActivation: () => getFusedDyActivation,
    getImageCenter: () => getImageCenter,
    getInnerMostAxes: () => getInnerMostAxes,
    getPermuted: () => getPermuted,
    getReductionAxes: () => getReductionAxes,
    getReshaped: () => getReshaped,
    getReshapedPermuted: () => getReshapedPermuted,
    getSliceBeginCoords: () => getSliceBeginCoords,
    getSliceSize: () => getSliceSize,
    getUndoAxesPermutation: () => getUndoAxesPermutation,
    linspaceImpl: () => linspaceImpl,
    log: () => log6,
    mergeRealAndImagArrays: () => mergeRealAndImagArrays,
    prepareAndValidate: () => prepareAndValidate,
    prepareSplitSize: () => prepareSplitSize,
    reshapeTensor: () => reshapeTensor,
    segment_util: () => segment_util_exports,
    shouldFuse: () => shouldFuse,
    slice_util: () => slice_util_exports,
    splitRealAndImagArrays: () => splitRealAndImagArrays,
    tupleValuesAreOne: () => tupleValuesAreOne,
    upcastType: () => upcastType,
    validateInput: () => validateInput,
    validateUpdateShape: () => validateUpdateShape,
    warn: () => warn
  });
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function castTensor(x, dtype, backend2) {
    if (dtype === "complex64") {
      if (x.dtype === "complex64") {
        return x.clone();
      }
      const zerosTensor = zeros(x.shape);
      const floatX = cast(x, "float32");
      const result = backend2.complex(floatX, zerosTensor);
      zerosTensor.dispose();
      floatX.dispose();
      return result;
    }
    if (!hasEncodingLoss(x.dtype, dtype)) {
      return ENGINE.makeTensorFromDataId(x.dataId, x.shape, dtype);
    }
    if (x.dtype === "complex64") {
      const real6 = backend2.real(x);
      const result = cast(real6, dtype);
      real6.dispose();
      return result;
    }
    if (dtype === "int32") {
      return backend2.int(x);
    } else if (dtype === "bool") {
      const zero = scalar(0, x.dtype);
      const result = backend2.notEqual(x, zero);
      zero.dispose();
      return result;
    } else {
      throw new Error(`Error in Cast: failed to cast ${x.dtype} to ${dtype}`);
    }
  }
  function reshapeTensor(x, shape) {
    return ENGINE.makeTensorFromDataId(x.dataId, shape, x.dtype);
  }
  function linspaceImpl(start, stop, num) {
    const step7 = (stop - start) / (num - 1);
    const values = makeZerosTypedArray(num, "float32");
    values[0] = start;
    for (let i = 1; i < values.length; i++) {
      values[i] = values[i - 1] + step7;
    }
    return tensor1d(values, "float32");
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/split_shared.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function split5(x, sizeSplits, axis) {
    const begin = new Array(x.rank).fill(0);
    const size = x.shape.slice();
    return sizeSplits.map((s) => {
      const sliceSize = [...size];
      sliceSize[axis] = s;
      const sliceT = slice(x, begin, sliceSize);
      begin[axis] += s;
      return sliceT;
    });
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/tile_impl.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function tile4(xBuf, reps) {
    const newShape = new Array(xBuf.rank);
    for (let i = 0; i < newShape.length; i++) {
      newShape[i] = xBuf.shape[i] * reps[i];
    }
    const result = buffer(newShape, xBuf.dtype);
    for (let i = 0; i < result.values.length; ++i) {
      const newLoc = result.indexToLoc(i);
      const originalLoc = new Array(xBuf.rank);
      for (let j = 0; j < originalLoc.length; j++) {
        originalLoc[j] = newLoc[j] % xBuf.shape[j];
      }
      const originalIndex = xBuf.locToIndex(originalLoc);
      result.values[i] = xBuf.values[originalIndex];
    }
    return result.toTensor();
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/topk_impl.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function topkImpl(x, xShape, xDtype, k, sorted) {
    const lastDim = xShape[xShape.length - 1];
    const [batch, size] = [x.length / lastDim, lastDim];
    const allTopKVals = getTypedArrayFromDType(xDtype, batch * k);
    const allTopKIndices = getTypedArrayFromDType("int32", batch * k);
    for (let b = 0; b < batch; b++) {
      const offset = b * size;
      const vals = x.subarray(offset, offset + size);
      const valAndInd = [];
      for (let i = 0; i < vals.length; i++) {
        valAndInd.push({value: vals[i], index: i});
      }
      valAndInd.sort((a, b2) => b2.value - a.value);
      const outOffset = b * k;
      const topKVals = allTopKVals.subarray(outOffset, outOffset + k);
      const topKIndices = allTopKIndices.subarray(outOffset, outOffset + k);
      for (let i = 0; i < k; i++) {
        topKVals[i] = valAndInd[i].value;
        topKIndices[i] = valAndInd[i].index;
      }
    }
    const outputShape = xShape.slice();
    outputShape[outputShape.length - 1] = k;
    return [
      tensor4(allTopKVals, outputShape, xDtype),
      tensor4(allTopKIndices, outputShape, "int32")
    ];
  }

  // node_modules/@tensorflow/tfjs-core/dist/backends/kernel_impls.js
  const kernel_impls_exports = {};
  __export(kernel_impls_exports, {
    nonMaxSuppressionV3Impl: () => nonMaxSuppressionV3Impl,
    nonMaxSuppressionV4Impl: () => nonMaxSuppressionV4Impl,
    nonMaxSuppressionV5Impl: () => nonMaxSuppressionV5Impl,
    split: () => split5,
    tile: () => tile4,
    topkImpl: () => topkImpl,
    whereImpl: () => whereImpl
  });
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */

  // node_modules/@tensorflow/tfjs-core/dist/backends/backend.js
  /**
   * @license
   * Copyright 2018 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const EPSILON_FLOAT32 = 1e-7;
  const EPSILON_FLOAT16 = 1e-4;
  class DataStorage {
    constructor(backend2, dataMover) {
      this.backend = backend2;
      this.dataMover = dataMover;
      this.data = new WeakMap();
      this.dataIdsCount = 0;
    }
    get(dataId) {
      if (!this.data.has(dataId)) {
        this.dataMover.moveData(this.backend, dataId);
      }
      return this.data.get(dataId);
    }
    set(dataId, value) {
      this.dataIdsCount++;
      this.data.set(dataId, value);
    }
    has(dataId) {
      return this.data.has(dataId);
    }
    delete(dataId) {
      this.dataIdsCount--;
      return this.data.delete(dataId);
    }
    numDataIds() {
      return this.dataIdsCount;
    }
  }
  class KernelBackend {
    time(f) {
      return notYetImplemented("time");
    }
    read(dataId) {
      return notYetImplemented("read");
    }
    readSync(dataId) {
      return notYetImplemented("readSync");
    }
    numDataIds() {
      return notYetImplemented("numDataIds");
    }
    disposeData(dataId) {
      return notYetImplemented("disposeData");
    }
    write(values, shape, dtype) {
      return notYetImplemented("write");
    }
    move(dataId, values, shape, dtype) {
      return notYetImplemented("move");
    }
    memory() {
      return notYetImplemented("memory");
    }
    floatPrecision() {
      return notYetImplemented("floatPrecision");
    }
    epsilon() {
      return this.floatPrecision() === 32 ? EPSILON_FLOAT32 : EPSILON_FLOAT16;
    }
    batchMatMul(a, b, transposeA, transposeB) {
      return notYetImplemented("batchMatMul");
    }
    fusedBatchMatMul({a, b, transposeA, transposeB, bias, activation, preluActivationWeights}) {
      return notYetImplemented("fusedBatchMatMul");
    }
    slice(x, begin, size) {
      return notYetImplemented("slice");
    }
    stridedSlice(x, begin, end, strides) {
      return notYetImplemented("stridedSlice");
    }
    unstack(x, axis) {
      return notYetImplemented("unstack");
    }
    reverse(a, axis) {
      return notYetImplemented("reverse");
    }
    concat(tensors, axis) {
      return notYetImplemented("concat");
    }
    neg(a) {
      return notYetImplemented("neg");
    }
    add(a, b) {
      return notYetImplemented("add");
    }
    addN(tensors) {
      return notYetImplemented("addN");
    }
    subtract(a, b) {
      return notYetImplemented("subtract");
    }
    multiply(a, b) {
      return notYetImplemented("multiply");
    }
    realDivide(a, b) {
      return notYetImplemented("realDivide");
    }
    floorDiv(a, b) {
      return notYetImplemented("floorDiv");
    }
    sum(x, axes) {
      return notYetImplemented("sum");
    }
    prod(x, axes) {
      return notYetImplemented("prod");
    }
    unsortedSegmentSum(x, segmentIds, numSegments) {
      return notYetImplemented("unsortedSegmentSum");
    }
    argMin(x, axis) {
      return notYetImplemented("argMin");
    }
    argMax(x, axis) {
      return notYetImplemented("argMax");
    }
    equal(a, b) {
      return notYetImplemented("equal");
    }
    notEqual(a, b) {
      return notYetImplemented("notEqual");
    }
    less(a, b) {
      return notYetImplemented("less");
    }
    lessEqual(a, b) {
      return notYetImplemented("lessEqual");
    }
    greater(a, b) {
      return notYetImplemented("greater");
    }
    greaterEqual(a, b) {
      return notYetImplemented("greaterEqual");
    }
    logicalNot(a) {
      return notYetImplemented("logicalNot");
    }
    logicalAnd(a, b) {
      return notYetImplemented("logicalAnd");
    }
    logicalOr(a, b) {
      return notYetImplemented("logicalOr");
    }
    where(condition) {
      return notYetImplemented("where");
    }
    select(condition, a, b) {
      return notYetImplemented("select");
    }
    topk(x, k, sorted) {
      return notYetImplemented("topk");
    }
    min(x, axes) {
      return notYetImplemented("min");
    }
    minimum(a, b) {
      return notYetImplemented("minimum");
    }
    mod(a, b) {
      return notYetImplemented("mod");
    }
    max(x, axes) {
      return notYetImplemented("max");
    }
    maximum(a, b) {
      return notYetImplemented("maximum");
    }
    all(x, axes) {
      return notYetImplemented("all");
    }
    any(x, axes) {
      return notYetImplemented("any");
    }
    squaredDifference(a, b) {
      return notYetImplemented("squaredDifference");
    }
    ceil(x) {
      return notYetImplemented("ceil");
    }
    floor(x) {
      return notYetImplemented("floor");
    }
    round(x) {
      return notYetImplemented("round");
    }
    sign(x) {
      return notYetImplemented("sign");
    }
    isNaN(x) {
      return notYetImplemented("isNaN");
    }
    isInf(x) {
      return notYetImplemented("isInf");
    }
    isFinite(x) {
      return notYetImplemented("isFinite");
    }
    pow(a, b) {
      return notYetImplemented("pow");
    }
    exp(x) {
      return notYetImplemented("exp");
    }
    expm1(x) {
      return notYetImplemented("expm1");
    }
    softmax(x, dim) {
      return notYetImplemented("softmax");
    }
    log(x) {
      return notYetImplemented("log");
    }
    log1p(x) {
      return notYetImplemented("log1p");
    }
    sqrt(x) {
      return notYetImplemented("sqrt");
    }
    rsqrt(x) {
      return notYetImplemented("rsqrt");
    }
    square(x) {
      return notYetImplemented("square");
    }
    reciprocal(x) {
      return notYetImplemented("reciprocal");
    }
    relu(x) {
      return notYetImplemented("relu");
    }
    relu6(x) {
      return notYetImplemented("relu6");
    }
    prelu(x, a) {
      return notYetImplemented("prelu");
    }
    elu(x) {
      return notYetImplemented("elu");
    }
    eluDer(dy, y) {
      return notYetImplemented("eluDer");
    }
    selu(x) {
      return notYetImplemented("selu");
    }
    int(x) {
      return notYetImplemented("int");
    }
    clip(x, min4, max6) {
      return notYetImplemented("clip");
    }
    abs(x) {
      return notYetImplemented("abs");
    }
    complexAbs(x) {
      return notYetImplemented("complexAbs");
    }
    sigmoid(x) {
      return notYetImplemented("sigmoid");
    }
    softplus(x) {
      return notYetImplemented("softplus");
    }
    sin(x) {
      return notYetImplemented("sin");
    }
    cos(x) {
      return notYetImplemented("cos");
    }
    tan(x) {
      return notYetImplemented("tan");
    }
    asin(x) {
      return notYetImplemented("asin");
    }
    acos(x) {
      return notYetImplemented("acos");
    }
    atan(x) {
      return notYetImplemented("atan");
    }
    atan2(a, b) {
      return notYetImplemented("atan2");
    }
    sinh(x) {
      return notYetImplemented("sinh");
    }
    cosh(x) {
      return notYetImplemented("cosh");
    }
    tanh(x) {
      return notYetImplemented("tanh");
    }
    asinh(x) {
      return notYetImplemented("asinh");
    }
    acosh(x) {
      return notYetImplemented("acosh");
    }
    atanh(x) {
      return notYetImplemented("atanh");
    }
    erf(x) {
      return notYetImplemented("erf");
    }
    step(x, alpha) {
      return notYetImplemented("step");
    }
    fusedConv2d({input, filter, convInfo, bias, activation, preluActivationWeights}) {
      return notYetImplemented("fusedConv2d");
    }
    conv2d(x, filter, convInfo) {
      return notYetImplemented("conv2d");
    }
    conv2dDerInput(dy, filter, convInfo) {
      return notYetImplemented("conv2dDerInput");
    }
    conv2dDerFilter(x, dY, convInfo) {
      return notYetImplemented("conv2dDerFilter");
    }
    fusedDepthwiseConv2D({input, filter, convInfo, bias, activation, preluActivationWeights}) {
      return notYetImplemented("fusedDepthwiseConv2D");
    }
    depthwiseConv2D(input, filter, convInfo) {
      return notYetImplemented("depthwiseConv2D");
    }
    depthwiseConv2DDerInput(dy, filter, convInfo) {
      return notYetImplemented("depthwiseConv2DDerInput");
    }
    depthwiseConv2DDerFilter(x, dY, convInfo) {
      return notYetImplemented("depthwiseConv2DDerFilter");
    }
    conv3d(x, filter, convInfo) {
      return notYetImplemented("conv3d");
    }
    conv3dDerInput(dy, filter, convInfo) {
      return notYetImplemented("conv3dDerInput");
    }
    conv3dDerFilter(x, dY, convInfo) {
      return notYetImplemented("conv3dDerFilter");
    }
    maxPool(x, convInfo) {
      return notYetImplemented("maxPool");
    }
    maxPoolBackprop(dy, x, y, convInfo) {
      return notYetImplemented("maxPoolBackprop");
    }
    avgPool(x, convInfo) {
      return notYetImplemented("avgPool");
    }
    avgPoolBackprop(dy, x, convInfo) {
      return notYetImplemented("avgPoolBackprop");
    }
    avgPool3d(x, convInfo) {
      return notYetImplemented("avgPool3d");
    }
    avgPool3dBackprop(dy, x, convInfo) {
      return notYetImplemented("avgPool3dBackprop");
    }
    maxPool3d(x, convInfo) {
      return notYetImplemented("maxPool3d");
    }
    maxPool3dBackprop(dy, x, y, convInfo) {
      return notYetImplemented("maxPool3dBackprop");
    }
    reshape(x, shape) {
      return notYetImplemented("reshape");
    }
    cast(x, dtype) {
      return notYetImplemented("cast");
    }
    tile(x, reps) {
      return notYetImplemented("tile");
    }
    pad(x, paddings, constantValue) {
      return notYetImplemented("pad");
    }
    transpose(x, perm) {
      return notYetImplemented("transpose");
    }
    gather(x, indices, axis) {
      return notYetImplemented("gather");
    }
    gatherND(x, indices) {
      return notYetImplemented("gatherND");
    }
    scatterND(indices, updates, shape) {
      return notYetImplemented("scatterND");
    }
    batchToSpaceND(x, blockShape, crops) {
      return notYetImplemented("batchToSpaceND");
    }
    spaceToBatchND(x, blockShape, paddings) {
      return notYetImplemented("spaceToBatchND");
    }
    resizeBilinear(x, newHeight, newWidth, alignCorners) {
      return notYetImplemented("resizeBilinear");
    }
    resizeBilinearBackprop(dy, x, alignCorners) {
      return notYetImplemented("resizeBilinearBackprop");
    }
    resizeNearestNeighbor(x, newHEight, newWidth, alignCorners) {
      return notYetImplemented("resizeNearestNeighbor");
    }
    resizeNearestNeighborBackprop(dy, x, alignCorners) {
      return notYetImplemented("resizeNearestNeighborBackprop");
    }
    batchNorm(x, mean5, variance, offset, scale2, varianceEpsilon) {
      return notYetImplemented("batchNorm");
    }
    localResponseNormalization4D(x, radius, bias, alpha, beta) {
      return notYetImplemented("localResponseNormalization4D");
    }
    LRNGrad(dy, inputImage, outputImage, radius, bias, alpha, beta) {
      return notYetImplemented("LRNGrad");
    }
    multinomial(logits, normalized, numSamples, seed) {
      return notYetImplemented("multinomial");
    }
    oneHot(indices, depth, onValue, offValue) {
      return notYetImplemented("oneHot");
    }
    cumsum(x, axis, exclusive, reverse9) {
      return notYetImplemented("cumsum");
    }
    nonMaxSuppression(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
      return notYetImplemented("nonMaxSuppression");
    }
    fft(x) {
      return notYetImplemented("fft");
    }
    ifft(x) {
      return notYetImplemented("ifft");
    }
    complex(real6, imag6) {
      return notYetImplemented("complex");
    }
    real(input) {
      return notYetImplemented("real");
    }
    imag(input) {
      return notYetImplemented("imag");
    }
    cropAndResize(image2, boxes, boxIndex, cropSize, method, extrapolationValue) {
      return notYetImplemented("cropAndResize");
    }
    depthToSpace(x, blockSize, dataFormat) {
      return notYetImplemented("depthToSpace");
    }
    split(value, sizeSplits, axis) {
      return notYetImplemented("split");
    }
    sparseToDense(sparseIndices, sparseValues, outputShape, defaultValue) {
      return notYetImplemented("sparseToDense");
    }
    diag(x) {
      return notYetImplemented("diag");
    }
    fill(shape, value, dtype) {
      return notYetImplemented("fill");
    }
    onesLike(x) {
      return notYetImplemented("onesLike");
    }
    zerosLike(x) {
      return notYetImplemented("zerosLike");
    }
    linspace(start, stop, num) {
      return notYetImplemented("linspace");
    }
    dispose() {
      return notYetImplemented("dispose");
    }
  }
  function notYetImplemented(kernelName) {
    throw new Error(`'${kernelName}' not yet implemented or not found in the registry. Did you forget to import the kernel?`);
  }

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Abs_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const absGradConfig = {
    kernelName: Abs,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(dy, step(cast(x, "float32"), -1))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Acos_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const acosGradConfig = {
    kernelName: Acos,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {
        x: () => {
          const a = square(cast(x, "float32"));
          const b = sqrt(sub(scalar(1), a));
          return neg(div(dy, b));
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Acosh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const acoshGradConfig = {
    kernelName: Acosh,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {
        x: () => {
          const a = sqrt(sub(square(cast(x, "float32")), 1));
          return div(dy, a);
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Add_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const addGradConfig = {
    kernelName: Add,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        let res = dy;
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, a.shape);
      };
      const derB = () => {
        let res = dy;
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, b.shape);
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/AddN_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const addNGradConfig = {
    kernelName: AddN,
    saveAllInputs: true,
    gradFunc: (dy, saved) => {
      const ders = {};
      saved.forEach((_, i) => {
        ders[i] = () => dy.clone();
      });
      return ders;
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ArgMax_grad.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const argMaxGradConfig = {
    kernelName: ArgMax,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => zerosLike(x)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ArgMin_grad.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const argMinGradConfig = {
    kernelName: ArgMin,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => zerosLike(x)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Asin_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const asinGradConfig = {
    kernelName: Asin,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, sqrt(sub(scalar(1), square(cast(x, "float32")))))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Asinh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const asinhGradConfig = {
    kernelName: Asinh,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {
        x: () => {
          const a = sqrt(add2(scalar(1), square(cast(x, "float32"))));
          return div(dy, a);
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Atan2_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const atan2GradConfig = {
    kernelName: Atan2,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        const d = add2(square(a), square(b));
        let res = mul(dy, div(b, d));
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, a.shape);
      };
      const derB = () => {
        const d = add2(square(a), square(b));
        let res = neg(mul(dy, div(a, d)));
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, b.shape);
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Atan_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const atanGradConfig = {
    kernelName: Atan,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, add2(square(cast(x, "float32")), 1))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Atanh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const atanhGradConfig = {
    kernelName: Atanh,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, sub(scalar(1), square(cast(x, "float32"))))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_3d_backprop.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function avgPool3dBackprop_(dy, input, filterSize, strides, dilations = [1, 1, 1], pad8, dimRoundingMode) {
    const $dy = convertToTensor(dy, "dy", "avgPool3dBackprop");
    const $input = convertToTensor(input, "input", "avgPool3dBackprop");
    let dy5D = $dy;
    let input5D = $input;
    let reshapedTo5D = false;
    if ($input.rank === 4) {
      reshapedTo5D = true;
      dy5D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
      input5D = reshape($input, [
        1,
        $input.shape[0],
        $input.shape[1],
        $input.shape[2],
        $input.shape[3]
      ]);
    }
    assert(dy5D.rank === 5, () => `Error in avgPool3dBackprop: dy must be rank 5 but got rank ${dy5D.rank}.`);
    assert(input5D.rank === 5, () => `Error in avgPool3dBackprop: input must be rank 5 but got rank ${input5D.rank}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in avgPool3dBackprop: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in maxPool3dBackprop: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2) => {
      const convInfo = computePool3DInfo(input5D.shape, filterSize, strides, dilations, pad8, dimRoundingMode);
      return backend2.avgPool3dBackprop(dy5D, input5D, convInfo);
    };
    const inputs = {dy: dy5D, input: input5D};
    const attrs = {filterSize, strides, dilations, pad: pad8, dimRoundingMode};
    const res = ENGINE.runKernelFunc(forward, inputs, null, AvgPool3DBackprop, attrs);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const avgPool3dBackprop = op({avgPool3dBackprop_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/AvgPool3D_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const avgPool3DGradConfig = {
    kernelName: AvgPool3D,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {filterSize, strides, dilations, pad: pad8, dimRoundingMode} = attrs;
      const $dilations = dilations == null ? [1, 1, 1] : dilations;
      return {
        x: () => avgPool3dBackprop(dy, x, filterSize, strides, $dilations, pad8, dimRoundingMode)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/avg_pool_backprop.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function avgPoolBackprop_(dy, input, filterSize, strides, pad8) {
    const $dy = convertToTensor(dy, "dy", "avgPoolBackprop");
    const $input = convertToTensor(input, "input", "avgPoolBackprop");
    assert($input.rank === $dy.rank, () => `Rank of input (${$input.rank}) does not match rank of dy (${$dy.rank})`);
    let input4D = $input;
    let dy4D = $dy;
    let reshapedTo4D = false;
    if ($input.rank === 3) {
      reshapedTo4D = true;
      input4D = reshape($input, [1, $input.shape[0], $input.shape[1], $input.shape[2]]);
      dy4D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2]]);
    }
    assert(dy4D.rank === 4, () => `Error in avgPoolBackprop: dy must be rank 4 but got rank ${dy4D.rank}.`);
    assert(input4D.rank === 4, () => `Error in avgPoolBackprop: input must be rank 4 but got rank ${input4D.rank}.`);
    const forward = (backend2) => {
      const convInfo = computePool2DInfo(input4D.shape, filterSize, strides, 1, pad8);
      return backend2.avgPoolBackprop(dy4D, input4D, convInfo);
    };
    const inputs = {dy: dy4D, input: input4D};
    const attrs = {filterSize, strides, pad: pad8};
    const res = ENGINE.runKernelFunc(forward, inputs, null, AvgPoolBackprop, attrs);
    if (reshapedTo4D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3]]);
    }
    return res;
  }
  const avgPoolBackprop = op({avgPoolBackprop_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/AvgPool_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const avgPoolGradConfig = {
    kernelName: AvgPool,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {filterSize, strides, pad: pad8} = attrs;
      return {
        x: () => avgPoolBackprop(dy, x, filterSize, strides, pad8)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/BatchMatMul_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const batchMatMulGradConfig = {
    kernelName: BatchMatMul,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved, attrs) => {
      const [a, b] = saved;
      const {transposeA, transposeB} = attrs;
      if (!transposeA && !transposeB) {
        return {
          a: () => matMul(dy, b, false, true),
          b: () => matMul(a, dy, true, false)
        };
      } else if (!transposeA && transposeB) {
        return {
          a: () => matMul(dy, b, false, false),
          b: () => matMul(dy, a, true, false)
        };
      } else if (transposeA && !transposeB) {
        return {
          a: () => matMul(b, dy, false, true),
          b: () => matMul(a, dy, false, false)
        };
      } else {
        return {
          a: () => matMul(b, dy, true, true),
          b: () => matMul(dy, a, true, true)
        };
      }
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/BatchToSpaceND_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const batchToSpaceNDGradConfig = {
    kernelName: BatchToSpaceND,
    gradFunc: (dy, saved, attrs) => {
      const {blockShape, crops} = attrs;
      return {x: () => spaceToBatchND(dy, blockShape, crops)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/BroadcastTo_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const broadcastToGradConfig = {
    kernelName: BroadcastTo,
    gradFunc: (dy, saved, attrs) => {
      const broadCastToAttrs = attrs;
      const inputShape = broadCastToAttrs.inputShape;
      const outputShape = broadCastToAttrs.shape;
      const reps = Array.from(outputShape);
      for (let i = inputShape.length - 1; i >= 0; i--) {
        if (inputShape[i] === outputShape[i]) {
          reps[i] = 1;
        } else if (inputShape[i] !== 1) {
          throw new Error(`broadcastTo(): [${inputShape}] cannot be broadcast to [${outputShape}].`);
        }
      }
      const axes = [];
      for (let i = 0; i < reps.length; i++) {
        if (reps[i] > 1) {
          axes.push(i);
        }
      }
      return {x: () => sum2(dy, axes, true)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Cast_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const castGradConfig = {
    kernelName: Cast,
    gradFunc: (dy) => {
      return {x: () => dy.clone()};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Ceil_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const ceilGradConfig = {
    kernelName: Ceil,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ClipByValue_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const clipByValueGradConfig = {
    kernelName: ClipByValue,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {clipValueMin, clipValueMax} = attrs;
      return {
        x: () => where(logicalAnd(greaterEqual(x, clipValueMin), lessEqual(x, clipValueMax)), dy, zerosLike(dy))
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Concat_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const concatGradConfig = {
    kernelName: Concat,
    saveAllInputs: true,
    gradFunc: (dy, saved, attrs) => {
      const shapes = saved.map((t) => t.shape);
      const {axis} = attrs;
      const $axis = parseAxisParam(axis, saved[0].shape)[0];
      const sizeSplits = shapes.map((s) => s[$axis]);
      const derTensors = split(dy, sizeSplits, $axis);
      return derTensors.map((t) => () => t);
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Conv2D_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const conv2DGradConfig = {
    kernelName: Conv2D,
    inputsToSave: ["x", "filter"],
    gradFunc: (dy, saved, attrs) => {
      const [x4D, $filter] = saved;
      const {dilations, strides, pad: pad8, dataFormat} = attrs;
      assert(tupleValuesAreOne(dilations), () => `Error in gradient of conv2D: dilation rates greater than 1 are not yet supported in gradients. Got dilations '${dilations}'`);
      return {
        x: () => conv2DBackpropInput(x4D.shape, dy, $filter, strides, pad8, dataFormat),
        filter: () => conv2DBackpropFilter(x4D, dy, $filter.shape, strides, pad8, dataFormat)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Conv2DBackpropInput_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const conv2DBackpropInputGradConfig = {
    kernelName: Conv2DBackpropInput,
    inputsToSave: ["dy", "filter"],
    gradFunc: (ddx, saved, attrs) => {
      const [dy, filter] = saved;
      const {strides, pad: pad8, dataFormat, dimRoundingMode} = attrs;
      return {
        dy: () => conv2d(ddx, filter, strides, pad8, dataFormat, 1, dimRoundingMode),
        filter: () => conv2DBackpropFilter(ddx, dy, filter.shape, strides, pad8, dataFormat, dimRoundingMode)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/conv3d_backprop_filter.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function conv3DBackpropFilter_(x, dy, filterShape, strides, pad8) {
    let x5D = x;
    if (x.rank === 4) {
      x5D = reshape(x, [1, x.shape[0], x.shape[1], x.shape[2], x.shape[3]]);
    }
    let dy5D = dy;
    if (dy5D.rank === 4) {
      dy5D = reshape(dy, [1, dy.shape[0], dy.shape[1], dy.shape[2], dy.shape[3]]);
    }
    assert(x5D.rank === 5, () => `Error in conv3dDerFilter: input must be rank 5, but got shape ${x5D.shape}.`);
    assert(dy5D.rank === 5, () => `Error in conv3dDerFilter: dy must be rank 5, but got shape ${dy5D.shape}.`);
    assert(filterShape.length === 5, () => `Error in conv3dDerFilter: filterShape must be length 5, but got ${filterShape}.`);
    assert(x5D.shape[4] === filterShape[3], () => `Error in conv3dDerFilter: depth of input ${x5D.shape[4]}) must match input depth in filter (${filterShape[3]}.`);
    assert(dy5D.shape[4] === filterShape[4], () => `Error in conv3dDerFilter: depth of dy (${dy5D.shape[4]}) must match output depth for filter (${filterShape[4]}).`);
    const forward = (backend2) => {
      const dilations = 1;
      const convInfo = computeConv3DInfo(x5D.shape, filterShape, strides, dilations, pad8);
      return backend2.conv3dDerFilter(x5D, dy5D, convInfo);
    };
    const inputs = {x: x5D, y: dy5D};
    const attrs = {strides, pad: pad8};
    return ENGINE.runKernelFunc(forward, inputs, null, Conv3DBackpropFilterV2, attrs);
  }
  const conv3DBackpropFilter = op({conv3DBackpropFilter_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Conv3D_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const conv3DGradConfig = {
    kernelName: Conv3D,
    inputsToSave: ["x", "filter"],
    gradFunc: (dy, saved, attrs) => {
      const {dilations, strides, pad: pad8} = attrs;
      assert(tupleValuesAreOne(dilations), () => `Error in gradient of conv3D: dilation rates greater than 1 are not yet supported in gradients. Got dilations '${dilations}'`);
      const [x5D, $filter] = saved;
      return {
        x: () => conv3DBackpropInput(x5D.shape, dy, $filter, strides, pad8),
        filter: () => conv3DBackpropFilter(x5D, dy, $filter.shape, strides, pad8)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Cos_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const cosGradConfig = {
    kernelName: Cos,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(neg(sin(cast(x, "float32"))), dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Cosh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const coshGradConfig = {
    kernelName: Cosh,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(sinh(cast(x, "float32")), dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Cumsum_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const cumsumGradConfig = {
    kernelName: Cumsum,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {axis, exclusive, reverse: reverse9} = attrs;
      return {
        x: () => {
          const permutation = getAxesPermutation([axis], x.rank);
          let out = cumsum(dy, axis, exclusive, !reverse9);
          if (permutation != null) {
            out = transpose(out, permutation);
          }
          return out;
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/DepthwiseConv2dNative_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const depthwiseConv2dNativeGradConfig = {
    kernelName: DepthwiseConv2dNative,
    inputsToSave: ["x", "filter"],
    gradFunc: (dy, saved, attrs) => {
      const {dilations, strides, pad: pad8, dimRoundingMode} = attrs;
      const $dilations = dilations == null ? [1, 1] : dilations;
      assert(tupleValuesAreOne($dilations), () => `Error in gradient of depthwiseConv2dNative: dilation rates greater than 1 are not yet supported. Got dilations '${$dilations}'`);
      const [x, filter] = saved;
      assert(x.rank === 4, () => `Error in gradient of depthwiseConv2dNative: input must be rank 4, but got rank ${x.rank}.`);
      assert(filter.rank === 4, () => `Error in gradient of depthwiseConv2dNative: filter must be rank 4, but got rank ${filter.rank}.`);
      assert(x.shape[3] === filter.shape[2], () => `Error in gradient of depthwiseConv2d: number of input channels (${x.shape[3]}) must match the inChannels dimension in filter ${filter.shape[2]}.`);
      assert(eitherStridesOrDilationsAreOne(strides, $dilations), () => `Error in gradient of depthwiseConv2d: Either strides or dilations must be  1. Got strides ${strides} and dilations '${$dilations}'.`);
      if (dimRoundingMode != null) {
        assert(isInt(pad8), () => `Error in depthwiseConv2d: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
      }
      const convInfo = computeConv2DInfo(x.shape, filter.shape, strides, $dilations, pad8, dimRoundingMode, true);
      return {
        x: () => depthwiseConv2dNativeBackpropInput(x.shape, dy, filter, convInfo),
        filter: () => depthwiseConv2dNativeBackpropFilter(x, dy, filter.shape, convInfo)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Dilation2D_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const dilation2dGradConfig = {
    kernelName: Dilation2D,
    inputsToSave: ["x", "filter"],
    gradFunc: (dy, saved, attrs) => {
      const [x, filter] = saved;
      const inputInputs = {x, filter, dy};
      const filterInputs = {x, filter, dy};
      return {
        x: () => ENGINE.runKernel(Dilation2DBackpropInput, inputInputs, attrs),
        filter: () => ENGINE.runKernel(Dilation2DBackpropFilter, filterInputs, attrs)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Div_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const divGradConfig = {
    kernelName: Div,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        const res = div(dy, cast(b, "float32"));
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(res, reduceAxes), a.shape);
        }
        return res;
      };
      const derB = () => {
        let res = mul(dy, cast(a, "float32"));
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          res = reshape(sum2(res, reduceAxes), b.shape);
        }
        const tmp = square(b);
        return neg(div(res, cast(tmp, "float32")));
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Elu_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const eluGradConfig = {
    kernelName: Elu,
    outputsToSave: [true],
    gradFunc: (dy, saved) => {
      const [y] = saved;
      const backPropKernelFunc = (backend2) => {
        return backend2.eluDer(dy, y);
      };
      const inputs = {dy, y};
      return {
        x: () => ENGINE.runKernelFunc(backPropKernelFunc, inputs, null, EluGrad)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Erf_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const erfGradConfig = {
    kernelName: Erf,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      const a = mul(exp(neg(square(x))), 2 / Math.sqrt(Math.PI));
      return {x: () => mul(dy, a)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Exp_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const expGradConfig = {
    kernelName: Exp,
    outputsToSave: [true],
    gradFunc: (dy, saved) => {
      const [y] = saved;
      return {x: () => mul(dy, y)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Expm1_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const expm1GradConfig = {
    kernelName: Expm1,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(dy, exp(x))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Floor_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const floorGradConfig = {
    kernelName: Floor,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/FloorDiv_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const floorDivGradConfig = {
    kernelName: FloorDiv,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        const res = div(dy, cast(b, "float32"));
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(res, reduceAxes), a.shape);
        }
        return res;
      };
      const derB = () => {
        let res = mul(dy, cast(a, "float32"));
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          res = reshape(sum2(res, reduceAxes), b.shape);
        }
        const tmp = square(b);
        return neg(div(res, cast(tmp, "float32")));
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/FusedBatchNorm_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const fusedBatchNormGradConfig = {
    kernelName: FusedBatchNorm,
    inputsToSave: ["x", "mean", "variance", "scale"],
    gradFunc: (dy, saved, attrs) => {
      const {varianceEpsilon} = attrs;
      const [x, mean5, variance, scale2] = saved;
      const scaleValue = scale2 == null ? scalar(1) : scale2;
      const reductionAxes = getReductionAxes(mean5.shape, x.shape);
      const tileShape = [];
      if (mean5.rank === 1) {
        for (let i = 0; i < x.shape.length - 1; ++i) {
          tileShape.push(x.shape[i]);
        }
        tileShape.push(1);
      }
      const xMinusMean = sub(x, mean5);
      const dyTimesScaleValue = mul(dy, scaleValue);
      const oneOverSqrtVariance = rsqrt(add2(variance, scalar(varianceEpsilon)));
      const minusHalfRCube = mul(mul(mul(oneOverSqrtVariance, oneOverSqrtVariance), oneOverSqrtVariance), scalar(-0.5));
      const derX = () => {
        if (mean5.rank === 1) {
          return reshape(mul(mul(dy, tile(reshape(oneOverSqrtVariance, [1, 1, 1, mean5.shape[0]]), tileShape)), scaleValue), x.shape);
        } else {
          return reshape(mul(mul(dy, oneOverSqrtVariance), scaleValue), x.shape);
        }
      };
      const derMean = () => {
        let meanDer = mul(mul(oneOverSqrtVariance, scalar(-1)), dyTimesScaleValue);
        if (mean5.rank === 1) {
          meanDer = sum2(meanDer, reductionAxes);
        }
        return reshape(meanDer, mean5.shape);
      };
      const derVariance = () => {
        let varianceDer = mul(mul(minusHalfRCube, xMinusMean), dyTimesScaleValue);
        if (mean5.rank === 1) {
          varianceDer = sum2(varianceDer, reductionAxes);
        }
        return reshape(varianceDer, mean5.shape);
      };
      const derScale = () => {
        const xMinusMean2TimesRsqrt = mul(xMinusMean, oneOverSqrtVariance);
        let scaleDer = mul(dy, xMinusMean2TimesRsqrt);
        if (mean5.rank === 1) {
          scaleDer = sum2(scaleDer, reductionAxes);
        }
        return reshape(scaleDer, mean5.shape);
      };
      const derOffset = () => {
        let offsetDer = dy;
        if (mean5.rank === 1) {
          offsetDer = sum2(offsetDer, reductionAxes);
        }
        return reshape(offsetDer, mean5.shape);
      };
      return {
        x: derX,
        mean: derMean,
        variance: derVariance,
        scale: derScale,
        offset: derOffset
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/GatherV2_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const gatherGradConfig = {
    kernelName: GatherV2,
    inputsToSave: ["x", "indices"],
    gradFunc: (dy, saved, attrs) => {
      const [x, indices] = saved;
      const {axis} = attrs;
      const parsedAxis = parseAxisParam(axis, x.shape)[0];
      const derX = () => {
        const paramsShape = x.shape;
        const indicesSize = indices.size;
        const outerShape = paramsShape.slice(0, parsedAxis);
        const outerDims = outerShape.length;
        const innerShape = paramsShape.slice(axis, paramsShape.length).slice(1);
        const innerDims = innerShape.length;
        const outerAxesIndices = arrayRange(0, outerDims);
        const innerAxesIndices = arrayRange(outerDims + 1, outerDims + 1 + innerDims);
        const valuesShape = arrayConcat([outerShape, [indicesSize], innerShape]);
        const values = reshape(dy, valuesShape);
        const reshapedIndices = reshape(indices, [indicesSize]);
        const transposeDims = arrayConcat([[outerDims], outerAxesIndices, innerAxesIndices]);
        const valuesTranspose = transpose(values, transposeDims);
        let paramsGrad = unsortedSegmentSum(valuesTranspose, reshapedIndices, x.shape[parsedAxis]);
        const invertTransposeDims = getUndoAxesPermutation(transposeDims);
        paramsGrad = transpose(paramsGrad, invertTransposeDims);
        return paramsGrad;
      };
      return {x: derX, indices: () => indices};
    }
  };
  function arrayRange(start, stop) {
    const result = [];
    for (let i = start; i < stop; ++i) {
      result.push(i);
    }
    return result;
  }
  function arrayConcat(arrays) {
    const result = [];
    for (let i = 0; i < arrays.length; ++i) {
      for (let j = 0; j < arrays[i].length; ++j) {
        result.push(arrays[i][j]);
      }
    }
    return result;
  }

  // node_modules/@tensorflow/tfjs-core/dist/gradients/GreaterEqual_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const greaterEqualGradConfig = {
    kernelName: GreaterEqual,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      return {a: () => zerosLike(a), b: () => zerosLike(b)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Identity_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const identityGradConfig = {
    kernelName: Identity,
    gradFunc: (dy) => {
      return {x: () => cast(dy, "float32")};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/IsFinite_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const isFiniteGradConfig = {
    kernelName: IsFinite,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/IsInf_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const isInfGradConfig = {
    kernelName: IsInf,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/IsNan_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const isNanGradConfig = {
    kernelName: IsNan,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Log1p_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const log1pGradConfig = {
    kernelName: Log1p,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, add2(x, 1))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Log_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const logGradConfig = {
    kernelName: Log,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, cast(x, "float32"))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/LogSoftmax_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const logSoftmaxGradConfig = {
    kernelName: LogSoftmax,
    inputsToSave: [],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const [value] = saved;
      const {axis} = attrs;
      return {
        logits: () => {
          const keepDims = true;
          const softmax3 = exp(value);
          return sub(dy, mul(sum2(dy, axis, keepDims), softmax3));
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/local_response_normalization_backprop.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function localResponseNormalizationBackprop_(x, y, dy, depthRadius = 5, bias = 1, alpha = 1, beta = 0.5) {
    const forward = (backend2) => backend2.LRNGrad(dy, x, y, depthRadius, bias, alpha, beta);
    const inputs = {x, y, dy};
    const attrs = {depthRadius, bias, alpha, beta};
    return ENGINE.runKernelFunc(forward, inputs, null, LRNBackprop, attrs);
  }
  const localResponseNormalizationBackprop = op({localResponseNormalizationBackprop_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/LRN_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const lrnGradConfig = {
    kernelName: LRN,
    inputsToSave: ["x"],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const [x, y] = saved;
      const {depthRadius, bias, alpha, beta} = attrs;
      return {
        x: () => localResponseNormalizationBackprop(x, y, dy, depthRadius, bias, alpha, beta)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/min_max_grad_util.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function gradForMinAndMax(dy, y, xOrig, origAxes, permutedAxes) {
    if (y.rank < xOrig.rank) {
      y = reshape(y, expandShapeToKeepDim(y.shape, origAxes));
    }
    if (dy.rank < xOrig.rank) {
      dy = reshape(dy, expandShapeToKeepDim(dy.shape, origAxes));
    }
    return {
      x: () => {
        const dx = mul(dy, cast(equal(xOrig, y), dy.dtype));
        return permutedAxes == null ? dx : transpose(dx, permutedAxes);
      }
    };
  }

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Max_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const maxGradConfig = {
    kernelName: Max,
    inputsToSave: ["x"],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const maxAttrs = attrs;
      const {reductionIndices} = maxAttrs;
      const [x, y] = saved;
      const origAxes = parseAxisParam(reductionIndices, x.shape);
      const permutedAxes = getAxesPermutation(origAxes, x.rank);
      const maxGrad = gradForMinAndMax(dy, y, x, origAxes, permutedAxes);
      return {
        x: () => {
          let out = maxGrad["x"]();
          if (permutedAxes != null) {
            out = transpose(out);
          }
          return out;
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Maximum_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const maximumGradConfig = {
    kernelName: Maximum,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const derA = () => mul(dy, cast(greaterEqual(a, b), "float32"));
      const derB = () => mul(dy, cast(less(a, b), "float32"));
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_3d_backprop.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maxPool3dBackprop_(dy, input, output, filterSize, strides, dilations = [1, 1, 1], pad8, dimRoundingMode) {
    const $dy = convertToTensor(dy, "dy", "maxPool3dBackprop");
    const $input = convertToTensor(input, "input", "maxPool3dBackprop");
    const $output = convertToTensor(output, "output", "maxPool3dBackprop");
    let dy5D = $dy;
    let input5D = $input;
    let output5D = $output;
    let reshapedTo5D = false;
    if ($input.rank === 4) {
      reshapedTo5D = true;
      dy5D = reshape($dy, [1, $dy.shape[0], $dy.shape[1], $dy.shape[2], $dy.shape[3]]);
      input5D = reshape($input, [
        1,
        $input.shape[0],
        $input.shape[1],
        $input.shape[2],
        $input.shape[3]
      ]);
      output5D = reshape($output, [
        1,
        $output.shape[0],
        $output.shape[1],
        $output.shape[2],
        $output.shape[3]
      ]);
    }
    assert(dy5D.rank === 5, () => `Error in maxPool3dBackprop: dy must be rank 5 but got rank ${dy5D.rank}.`);
    assert(input5D.rank === 5, () => `Error in maxPool3dBackprop: input must be rank 5 but got rank ${input5D.rank}.`);
    assert(output5D.rank === 5, () => `Error in maxPool3dBackprop: output must be rank 5 but got rank ${output5D.rank}.`);
    assert(eitherStridesOrDilationsAreOne(strides, dilations), () => `Error in maxPool3dBackprop: Either strides or dilations must be 1. Got strides ${strides} and dilations '${dilations}'`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in maxPool3dBackprop: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2) => {
      const convInfo = computePool3DInfo(input5D.shape, filterSize, strides, dilations, pad8, dimRoundingMode);
      return backend2.maxPool3dBackprop(dy5D, input5D, output5D, convInfo);
    };
    const inputs = {dy: dy5D, input: input5D, output: output5D};
    const attrs = {filterSize, strides, dilations, pad: pad8, dimRoundingMode};
    const res = ENGINE.runKernelFunc(forward, inputs, null, MaxPool3DBackprop, attrs);
    if (reshapedTo5D) {
      return reshape(res, [res.shape[1], res.shape[2], res.shape[3], res.shape[4]]);
    }
    return res;
  }
  const maxPool3dBackprop = op({maxPool3dBackprop_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/MaxPool3D_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const maxPool3DGradConfig = {
    kernelName: MaxPool3D,
    inputsToSave: ["x"],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const [x, y] = saved;
      const {filterSize, strides, dilations, pad: pad8, dimRoundingMode} = attrs;
      const $dilations = dilations == null ? [1, 1, 1] : dilations;
      return {
        x: () => maxPool3dBackprop(dy, x, y, filterSize, strides, $dilations, pad8, dimRoundingMode)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/ops/max_pool_backprop.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  function maxPoolBackprop_(dy, input, output, filterSize, strides, pad8, dimRoundingMode) {
    const $dy = convertToTensor(dy, "dy", "maxPoolBackprop");
    const $input = convertToTensor(input, "input", "maxPoolBackprop");
    const $output = convertToTensor(output, "output", "maxPoolBackprop");
    assert($input.rank === $dy.rank, () => `Rank of input (${$input.rank}) does not match rank of dy (${$dy.rank})`);
    assert($dy.rank === 4, () => `Error in maxPoolBackprop: dy must be rank 4 but got rank ${$dy.rank}.`);
    assert($input.rank === 4, () => `Error in maxPoolBackprop: input must be rank 4 but got rank ${$input.rank}.`);
    if (dimRoundingMode != null) {
      assert(isInt(pad8), () => `Error in maxPoolBackprop: pad must be an integer when using, dimRoundingMode ${dimRoundingMode} but got pad ${pad8}.`);
    }
    const forward = (backend2) => {
      const convInfo = computePool2DInfo($input.shape, filterSize, strides, 1, pad8, dimRoundingMode);
      return backend2.maxPoolBackprop($dy, $input, $output, convInfo);
    };
    const inputs = {dy: $dy, input: $input, output: $output};
    const attrs = {filterSize, strides, pad: pad8, dimRoundingMode};
    return ENGINE.runKernelFunc(forward, inputs, null, MaxPoolBackprop, attrs);
  }
  const maxPoolBackprop = op({maxPoolBackprop_});

  // node_modules/@tensorflow/tfjs-core/dist/gradients/MaxPool_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const maxPoolGradConfig = {
    kernelName: MaxPool,
    inputsToSave: ["x"],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const [x, y] = saved;
      const {filterSize, strides, pad: pad8} = attrs;
      return {
        x: () => maxPoolBackprop(dy, x, y, filterSize, strides, pad8)
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Min_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const minGradConfig = {
    kernelName: Min,
    inputsToSave: ["x"],
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const minAttrs = attrs;
      const {axis} = minAttrs;
      const [x, y] = saved;
      const origAxes = parseAxisParam(axis, x.shape);
      const permutedAxes = getAxesPermutation(origAxes, x.rank);
      const minGrad = gradForMinAndMax(dy, y, x, origAxes, permutedAxes);
      return {
        x: () => {
          let out = minGrad["x"]();
          if (permutedAxes != null) {
            out = transpose(out);
          }
          return out;
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Minimum_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const minimumGradConfig = {
    kernelName: Minimum,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const derA = () => mul(dy, cast(lessEqual(a, b), "float32"));
      const derB = () => mul(dy, cast(greater(a, b), "float32"));
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Mod_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const modGradConfig = {
    kernelName: Mod,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(dy, reduceAxes), a.shape);
        }
        return dy;
      };
      const derB = () => {
        const res = mul(dy, neg(floor(div(a, b))));
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(res, reduceAxes), b.shape);
        }
        return res;
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Multiply_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const multiplyGradConfig = {
    kernelName: Multiply,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        const res = mul(dy, cast(b, "float32"));
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(res, reduceAxes), a.shape);
        }
        return res;
      };
      const derB = () => {
        const res = mul(dy, cast(a, "float32"));
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          return reshape(sum2(res, reduceAxes), b.shape);
        }
        return res;
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Negate_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const negateGradConfig = {
    kernelName: Negate,
    gradFunc: (dy) => {
      return {x: () => neg(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/OneHot_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const oneHotGradConfig = {
    kernelName: OneHot,
    inputsToSave: ["indices"],
    gradFunc: (dy, saved) => {
      const indices = saved[0];
      return {indices: () => zeros(indices.shape, "float32")};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/OnesLike_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const onesLikeGradConfig = {
    kernelName: OnesLike,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/PadV2_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const padV2GradConfig = {
    kernelName: PadV2,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const x = saved[0];
      const {paddings} = attrs;
      const begin = paddings.map((p) => p[0]);
      return {x: () => slice(dy, begin, x.shape)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Pow_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const powGradConfig = {
    kernelName: Pow,
    inputsToSave: ["a", "b"],
    outputsToSave: [true],
    gradFunc: (dy, saved) => {
      const [a, b, y] = saved;
      const base = a;
      const exp11 = b;
      const outShape = assertAndGetBroadcastShape(base.shape, exp11.shape);
      const derBase = () => {
        const expFloat = cast(exp11, "float32");
        let res = mul(dy, mul(expFloat, pow(base, sub(expFloat, scalar(1)))));
        const reduceAxes = getReductionAxes(base.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, base.shape);
      };
      const derExp = () => {
        const condition = greater(base, 0);
        const logBase = where(condition, log(base), zerosLike(base));
        let res = mul(dy, mul(y, logBase));
        const reduceAxes = getReductionAxes(exp11.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, exp11.shape);
      };
      return {a: derBase, b: derExp};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Prelu_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const preluGradConfig = {
    kernelName: Prelu,
    inputsToSave: ["x", "alpha"],
    gradFunc: (dy, saved) => {
      const [x, alpha] = saved;
      const mask = greater(x, 0);
      return {
        x: () => where(mask, dy, mul(dy, alpha)),
        alpha: () => {
          let res = where(mask, zerosLike(dy), mul(dy, x));
          const reduceAxes = getReductionAxes(alpha.shape, dy.shape);
          if (reduceAxes.length > 0) {
            res = sum2(res, reduceAxes);
          }
          return reshape(res, alpha.shape);
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Reciprocal_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const reciprocalGradConfig = {
    kernelName: Reciprocal,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, neg(square(x)))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Relu6_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const relu6GradConfig = {
    kernelName: Relu6,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      const mask = mul(lessEqual(x, 6), step(x));
      return {x: () => mul(dy, cast(mask, "float32"))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Relu_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const reluGradConfig = {
    kernelName: Relu,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(dy, cast(step(x), "float32"))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Reshape_grad.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const reshapeGradConfig = {
    kernelName: Reshape,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => reshape(dy, x.shape)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ResizeBilinear_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const resizeBilinearGradConfig = {
    kernelName: ResizeBilinear,
    inputsToSave: ["images"],
    gradFunc: (dy, saved, attrs) => {
      const [images] = saved;
      const backPropKernelFunc = (backend2) => {
        const {alignCorners} = attrs;
        return backend2.resizeBilinearBackprop(dy, images, alignCorners);
      };
      const inputs = {images};
      const imagesDer = () => ENGINE.runKernelFunc(backPropKernelFunc, inputs, null, ResizeBilinearGrad, attrs);
      return {images: imagesDer};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ResizeNearestNeighbor_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const resizeNearestNeighborGradConfig = {
    kernelName: ResizeNearestNeighbor,
    inputsToSave: ["images"],
    gradFunc: (dy, saved, attrs) => {
      const [images] = saved;
      const backPropKernelFunc = (backend2) => {
        const {alignCorners} = attrs;
        return backend2.resizeNearestNeighborBackprop(dy, images, alignCorners);
      };
      const inputs = {images};
      const imagesDer = () => ENGINE.runKernelFunc(backPropKernelFunc, inputs, null, ResizeNearestNeighborGrad, attrs);
      return {images: imagesDer};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Reverse_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const reverseGradConfig = {
    kernelName: Reverse,
    gradFunc: (dy, saved, attrs) => {
      const {dims} = attrs;
      const axes = parseAxisParam(dims, dy.shape);
      return {x: () => reverse(dy, axes)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Round_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const roundGradConfig = {
    kernelName: Round,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Rsqrt_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const rsqrtGradConfig = {
    kernelName: Rsqrt,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => neg(div(dy, mul(pow(x, 1.5), 2)))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/SelectV2_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const selectV2PoolGradConfig = {
    kernelName: SelectV2,
    inputsToSave: ["condition"],
    gradFunc: (dy, saved) => {
      const [condition] = saved;
      return {
        condition: () => cast(zerosLike(condition), "float32"),
        t: () => mul(dy, cast(condition, dy.dtype)),
        e: () => mul(dy, cast(logicalNot(condition), dy.dtype))
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Selu_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const seluGradConfig = {
    kernelName: Selu,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {
        x: () => {
          const mask = greater(x, scalar(0));
          const scaleAlpha = scalar(SELU_SCALEALPHA);
          const scale2 = scalar(SELU_SCALE);
          const greaterThanZeroDer = mul(dy, scale2);
          const lessEqualZeroDer = mul(mul(dy, scaleAlpha), exp(cast(x, "float32")));
          return where(mask, greaterThanZeroDer, lessEqualZeroDer);
        }
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sigmoid_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sigmoidGradConfig = {
    kernelName: Sigmoid,
    outputsToSave: [true],
    gradFunc: (dy, saved) => {
      const [y] = saved;
      return {x: () => mul(dy, mul(y, sub(scalar(1), y)))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sign_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const signGradConfig = {
    kernelName: Sign,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sin_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sinGradConfig = {
    kernelName: Sin,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(cos(cast(x, "float32")), dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sinh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sinhGradConfig = {
    kernelName: Sinh,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(cosh(cast(x, "float32")), dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Slice_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sliceGradConfig = {
    kernelName: Slice,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {begin, size} = attrs;
      const inputShape = x.shape;
      const [begin_, size_] = parseSliceParams(x, begin, size);
      const paddings = [];
      for (let i = 0; i < dy.rank; i++) {
        paddings.push([begin_[i], inputShape[i] - begin_[i] - size_[i]]);
      }
      return {x: () => pad(dy, paddings)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Softmax_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const softmaxGradConfig = {
    kernelName: Softmax,
    outputsToSave: [true],
    gradFunc: (dy, saved, attrs) => {
      const [y] = saved;
      const {dim} = attrs;
      const keepDims = true;
      const dyTimesY = mul(dy, y);
      return {
        logits: () => sub(dyTimesY, mul(sum2(dyTimesY, [dim], keepDims), y))
      };
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Softplus_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const softplusGradConfig = {
    kernelName: Softplus,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(dy, sigmoid(x))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/SpaceToBatchND_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const spaceToBatchNDGradConfig = {
    kernelName: SpaceToBatchND,
    gradFunc: (dy, saved, attrs) => {
      const {blockShape, paddings} = attrs;
      return {x: () => batchToSpaceND(dy, blockShape, paddings)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/SplitV_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const splitVGradConfig = {
    kernelName: SplitV,
    gradFunc: (dy, saved, attrs) => {
      const {axis} = attrs;
      return {x: () => concat(dy, axis)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sqrt_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sqrtGradConfig = {
    kernelName: Sqrt,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, mul(sqrt(cast(x, "float32")), 2))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Square_grad.js
  /**
   * @license
   * Copyright 2019 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const squareGradConfig = {
    kernelName: Square,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => mul(dy, mul(cast(x, "float32"), 2))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/SquaredDifference_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const squaredDifferenceGradConfig = {
    kernelName: SquaredDifference,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const two = scalar(2);
      const derA = () => mul(dy, mul(two, sub(a, b)));
      const derB = () => mul(dy, mul(two, sub(b, a)));
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Step_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const stepGradConfig = {
    kernelName: Step,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sub_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const subGradConfig = {
    kernelName: Sub,
    inputsToSave: ["a", "b"],
    gradFunc: (dy, saved) => {
      const [a, b] = saved;
      const outShape = assertAndGetBroadcastShape(a.shape, b.shape);
      const derA = () => {
        let res = dy;
        const reduceAxes = getReductionAxes(a.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(res, a.shape);
      };
      const derB = () => {
        let res = dy;
        const reduceAxes = getReductionAxes(b.shape, outShape);
        if (reduceAxes.length > 0) {
          res = sum2(res, reduceAxes);
        }
        return reshape(neg(res), b.shape);
      };
      return {a: derA, b: derB};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Sum_grad.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const sumGradConfig = {
    kernelName: Sum,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const expandedDyShape = x.shape.slice();
      const {axis} = attrs;
      const axes = parseAxisParam(axis, x.shape);
      axes.forEach((axis2) => {
        expandedDyShape[axis2] = 1;
      });
      const expandedDy = reshape(dy, expandedDyShape);
      const derX = mul(expandedDy, ones2(x.shape, "float32"));
      return {x: () => derX};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Tan_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const tanGradConfig = {
    kernelName: Tan,
    inputsToSave: ["x"],
    gradFunc: (dy, saved) => {
      const [x] = saved;
      return {x: () => div(dy, square(cos(x)))};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Tanh_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const tanhGradConfig = {
    kernelName: Tanh,
    outputsToSave: [true],
    gradFunc: (dy, saved) => {
      const [y] = saved;
      return {x: () => mul(sub(scalar(1), square(y)), dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Tile_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const tileGradConfig = {
    kernelName: Tile,
    inputsToSave: ["x"],
    gradFunc: (dy, saved, attrs) => {
      const [x] = saved;
      const {reps} = attrs;
      const derX = () => {
        let xGrad = zerosLike(x);
        if (x.rank === 1) {
          for (let i = 0; i < reps[0]; ++i) {
            xGrad = add2(xGrad, slice(dy, [i * x.shape[0]], [x.shape[0]]));
          }
        } else if (x.rank === 2) {
          for (let i = 0; i < reps[0]; ++i) {
            for (let j = 0; j < reps[1]; ++j) {
              xGrad = add2(xGrad, slice(dy, [i * x.shape[0], j * x.shape[1]], [
                x.shape[0],
                x.shape[1]
              ]));
            }
          }
        } else if (x.rank === 3) {
          for (let i = 0; i < reps[0]; ++i) {
            for (let j = 0; j < reps[1]; ++j) {
              for (let k = 0; k < reps[2]; ++k) {
                xGrad = add2(xGrad, slice(dy, [i * x.shape[0], j * x.shape[1], k * x.shape[2]], [x.shape[0], x.shape[1], x.shape[2]]));
              }
            }
          }
        } else if (x.rank === 4) {
          for (let i = 0; i < reps[0]; ++i) {
            for (let j = 0; j < reps[1]; ++j) {
              for (let k = 0; k < reps[2]; ++k) {
                for (let l = 0; l < reps[3]; ++l) {
                  xGrad = add2(xGrad, slice(dy, [
                    i * x.shape[0],
                    j * x.shape[1],
                    k * x.shape[2],
                    l * x.shape[3]
                  ], [x.shape[0], x.shape[1], x.shape[2], x.shape[3]]));
                }
              }
            }
          }
        } else {
          throw new Error(`Gradient for tile operation is not implemented for rank-${x.rank} tensors yet.`);
        }
        return xGrad;
      };
      return {x: derX};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Transpose_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const transposeGradConfig = {
    kernelName: Transpose,
    gradFunc: (dy, saved, attrs) => {
      const transposeAttrs = attrs;
      const {perm} = transposeAttrs;
      const undoPerm = getUndoAxesPermutation(perm);
      return {x: () => transpose(dy, undoPerm)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/Unpack_grad.js
  /**
   * @license
   * Copyright 2020 Google Inc. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const unpackGradConfig = {
    kernelName: Unpack,
    gradFunc: (dy, saved, attrs) => {
      const unpackAttrs = attrs;
      const {axis} = unpackAttrs;
      return {value: () => stack(dy, axis)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/gradients/UnsortedSegmentSum_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const unsortedSegmentSumGradConfig = {
    kernelName: UnsortedSegmentSum,
    inputsToSave: ["segmentIds"],
    gradFunc: (dy, saved) => {
      const [segmentIds] = saved;
      const derX = () => {
        return gatherDropNegatives(dy, segmentIds);
      };
      return {x: derX};
    }
  };
  function gatherDropNegatives(x, indices) {
    const zeroClippedIndices = maximum(indices, zerosLike(indices));
    const gathered = gather(x, zeroClippedIndices);
    let isPositive = greaterEqual(indices, scalar(0, "int32"));
    const numIters = gathered.rank - isPositive.rank;
    for (let i = 0; i < numIters; ++i) {
      isPositive = expandDims(isPositive, i + 1);
    }
    isPositive = logicalAnd(isPositive, ones2(gathered.shape, "bool"));
    const zeroSlice = zerosLike(gathered);
    return where(isPositive, gathered, zeroSlice);
  }

  // node_modules/@tensorflow/tfjs-core/dist/gradients/ZerosLike_grad.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const zerosLikeGradConfig = {
    kernelName: ZerosLike,
    gradFunc: (dy) => {
      return {x: () => zerosLike(dy)};
    }
  };

  // node_modules/@tensorflow/tfjs-core/dist/register_all_gradients.js
  /**
   * @license
   * Copyright 2020 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */
  const gradConfigs = [
    absGradConfig,
    acosGradConfig,
    acoshGradConfig,
    addGradConfig,
    addNGradConfig,
    argMaxGradConfig,
    argMinGradConfig,
    asinGradConfig,
    asinhGradConfig,
    atan2GradConfig,
    atanGradConfig,
    atanhGradConfig,
    avgPool3DGradConfig,
    avgPoolGradConfig,
    batchMatMulGradConfig,
    batchToSpaceNDGradConfig,
    broadcastToGradConfig,
    castGradConfig,
    ceilGradConfig,
    clipByValueGradConfig,
    concatGradConfig,
    conv2DBackpropInputGradConfig,
    conv2DGradConfig,
    conv3DGradConfig,
    cosGradConfig,
    coshGradConfig,
    cumsumGradConfig,
    depthwiseConv2dNativeGradConfig,
    dilation2dGradConfig,
    divGradConfig,
    eluGradConfig,
    erfGradConfig,
    expGradConfig,
    expm1GradConfig,
    floorDivGradConfig,
    floorGradConfig,
    fusedBatchNormGradConfig,
    gatherGradConfig,
    greaterEqualGradConfig,
    identityGradConfig,
    isFiniteGradConfig,
    isInfGradConfig,
    isNanGradConfig,
    log1pGradConfig,
    logGradConfig,
    logSoftmaxGradConfig,
    lrnGradConfig,
    maxGradConfig,
    maxGradConfig,
    maximumGradConfig,
    maxPool3DGradConfig,
    maxPoolGradConfig,
    minGradConfig,
    minimumGradConfig,
    modGradConfig,
    multiplyGradConfig,
    negateGradConfig,
    oneHotGradConfig,
    onesLikeGradConfig,
    padV2GradConfig,
    padV2GradConfig,
    powGradConfig,
    preluGradConfig,
    reciprocalGradConfig,
    relu6GradConfig,
    reluGradConfig,
    reshapeGradConfig,
    resizeBilinearGradConfig,
    resizeNearestNeighborGradConfig,
    reverseGradConfig,
    roundGradConfig,
    rsqrtGradConfig,
    selectV2PoolGradConfig,
    seluGradConfig,
    sigmoidGradConfig,
    signGradConfig,
    sinGradConfig,
    sinhGradConfig,
    sliceGradConfig,
    softmaxGradConfig,
    softplusGradConfig,
    spaceToBatchNDGradConfig,
    spaceToBatchNDGradConfig,
    splitVGradConfig,
    splitVGradConfig,
    sqrtGradConfig,
    squaredDifferenceGradConfig,
    squareGradConfig,
    stepGradConfig,
    subGradConfig,
    sumGradConfig,
    tanGradConfig,
    tanhGradConfig,
    tileGradConfig,
    transposeGradConfig,
    unpackGradConfig,
    unsortedSegmentSumGradConfig,
    zerosLikeGradConfig
  ];
  for (const gradientConfig of gradConfigs) {
    registerGradient(gradientConfig);
  }

  // node_modules/@tensorflow/tfjs-core/dist/index.js
  const dist_exports = {};
  __export(dist_exports, {
    Abs: () => Abs,
    Acos: () => Acos,
    Acosh: () => Acosh,
    AdadeltaOptimizer: () => AdadeltaOptimizer,
    AdagradOptimizer: () => AdagradOptimizer,
    AdamOptimizer: () => AdamOptimizer,
    AdamaxOptimizer: () => AdamaxOptimizer,
    Add: () => Add,
    AddN: () => AddN,
    All: () => All,
    Any: () => Any,
    ArgMax: () => ArgMax,
    ArgMin: () => ArgMin,
    Asin: () => Asin,
    Asinh: () => Asinh,
    Atan: () => Atan,
    Atan2: () => Atan2,
    Atanh: () => Atanh,
    AvgPool: () => AvgPool,
    AvgPool3D: () => AvgPool3D,
    AvgPool3DBackprop: () => AvgPool3DBackprop,
    AvgPoolBackprop: () => AvgPoolBackprop,
    BatchMatMul: () => BatchMatMul,
    BatchToSpaceND: () => BatchToSpaceND,
    BroadcastTo: () => BroadcastTo,
    Cast: () => Cast,
    Ceil: () => Ceil,
    ClipByValue: () => ClipByValue,
    Complex: () => Complex,
    Concat: () => Concat,
    Conv2D: () => Conv2D,
    Conv2DBackpropFilter: () => Conv2DBackpropFilter,
    Conv2DBackpropInput: () => Conv2DBackpropInput,
    Conv3D: () => Conv3D,
    Conv3DBackpropFilterV2: () => Conv3DBackpropFilterV2,
    Conv3DBackpropInputV2: () => Conv3DBackpropInputV2,
    Cos: () => Cos,
    Cosh: () => Cosh,
    CropAndResize: () => CropAndResize,
    Cumsum: () => Cumsum,
    DataStorage: () => DataStorage,
    DepthToSpace: () => DepthToSpace,
    DepthwiseConv2dNative: () => DepthwiseConv2dNative,
    DepthwiseConv2dNativeBackpropFilter: () => DepthwiseConv2dNativeBackpropFilter,
    DepthwiseConv2dNativeBackpropInput: () => DepthwiseConv2dNativeBackpropInput,
    Diag: () => Diag,
    Dilation2D: () => Dilation2D,
    Dilation2DBackpropFilter: () => Dilation2DBackpropFilter,
    Dilation2DBackpropInput: () => Dilation2DBackpropInput,
    Div: () => Div,
    ENV: () => ENV,
    Elu: () => Elu,
    EluGrad: () => EluGrad,
    Environment: () => Environment,
    Equal: () => Equal,
    Erf: () => Erf,
    Exp: () => Exp,
    Expm1: () => Expm1,
    FFT: () => FFT,
    Fill: () => Fill,
    FlipLeftRight: () => FlipLeftRight,
    Floor: () => Floor,
    FloorDiv: () => FloorDiv,
    FromPixels: () => FromPixels,
    FusedBatchNorm: () => FusedBatchNorm,
    FusedConv2D: () => FusedConv2D,
    FusedDepthwiseConv2D: () => FusedDepthwiseConv2D,
    GatherNd: () => GatherNd,
    GatherV2: () => GatherV2,
    Greater: () => Greater,
    GreaterEqual: () => GreaterEqual,
    IFFT: () => IFFT,
    Identity: () => Identity,
    Imag: () => Imag,
    IsFinite: () => IsFinite,
    IsInf: () => IsInf,
    IsNan: () => IsNan,
    KernelBackend: () => KernelBackend,
    LRN: () => LRN,
    LRNBackprop: () => LRNBackprop,
    Less: () => Less,
    LessEqual: () => LessEqual,
    LinSpace: () => LinSpace,
    Log: () => Log,
    Log1p: () => Log1p,
    LogSoftmax: () => LogSoftmax,
    LogicalAnd: () => LogicalAnd,
    LogicalNot: () => LogicalNot,
    LogicalOr: () => LogicalOr,
    Max: () => Max,
    MaxPool: () => MaxPool,
    MaxPool3D: () => MaxPool3D,
    MaxPool3DBackprop: () => MaxPool3DBackprop,
    MaxPoolBackprop: () => MaxPoolBackprop,
    MaxPoolWithArgmax: () => MaxPoolWithArgmax,
    Maximum: () => Maximum,
    Mean: () => Mean,
    Min: () => Min,
    Minimum: () => Minimum,
    Mod: () => Mod,
    MomentumOptimizer: () => MomentumOptimizer,
    Multiply: () => Multiply,
    Negate: () => Negate,
    NonMaxSuppressionV3: () => NonMaxSuppressionV3,
    NonMaxSuppressionV4: () => NonMaxSuppressionV4,
    NonMaxSuppressionV5: () => NonMaxSuppressionV5,
    NotEqual: () => NotEqual,
    OP_SCOPE_SUFFIX: () => OP_SCOPE_SUFFIX,
    OneHot: () => OneHot,
    OnesLike: () => OnesLike,
    Optimizer: () => Optimizer,
    PadV2: () => PadV2,
    Pool: () => Pool,
    Pow: () => Pow,
    Prelu: () => Prelu,
    Prod: () => Prod,
    RMSPropOptimizer: () => RMSPropOptimizer,
    Range: () => Range,
    Rank: () => Rank,
    Real: () => Real,
    Reciprocal: () => Reciprocal,
    Reduction: () => Reduction,
    Relu: () => Relu,
    Relu6: () => Relu6,
    Reshape: () => Reshape,
    ResizeBilinear: () => ResizeBilinear,
    ResizeBilinearGrad: () => ResizeBilinearGrad,
    ResizeNearestNeighbor: () => ResizeNearestNeighbor,
    ResizeNearestNeighborGrad: () => ResizeNearestNeighborGrad,
    Reverse: () => Reverse,
    RotateWithOffset: () => RotateWithOffset,
    Round: () => Round,
    Rsqrt: () => Rsqrt,
    SGDOptimizer: () => SGDOptimizer,
    ScatterNd: () => ScatterNd,
    SelectV2: () => SelectV2,
    Selu: () => Selu,
    Sigmoid: () => Sigmoid,
    Sign: () => Sign,
    Sin: () => Sin,
    Sinh: () => Sinh,
    Slice: () => Slice,
    Softmax: () => Softmax,
    Softplus: () => Softplus,
    SpaceToBatchND: () => SpaceToBatchND,
    SparseToDense: () => SparseToDense,
    SplitV: () => SplitV,
    Sqrt: () => Sqrt,
    Square: () => Square,
    SquaredDifference: () => SquaredDifference,
    Step: () => Step,
    StridedSlice: () => StridedSlice,
    Sub: () => Sub,
    Sum: () => Sum,
    Tan: () => Tan,
    Tanh: () => Tanh,
    Tensor: () => Tensor,
    TensorBuffer: () => TensorBuffer,
    Tile: () => Tile,
    TopK: () => TopK,
    Transpose: () => Transpose,
    Unpack: () => Unpack,
    UnsortedSegmentSum: () => UnsortedSegmentSum,
    Variable: () => Variable,
    ZerosLike: () => ZerosLike,
    _FusedMatMul: () => _FusedMatMul,
    abs: () => abs,
    acos: () => acos,
    acosh: () => acosh,
    add: () => add2,
    addN: () => addN,
    addStrict: () => addStrict,
    all: () => all,
    any: () => any,
    argMax: () => argMax,
    argMin: () => argMin,
    asin: () => asin,
    asinh: () => asinh,
    atan: () => atan,
    atan2: () => atan2,
    atanh: () => atanh,
    avgPool: () => avgPool,
    avgPool3d: () => avgPool3d,
    backend: () => backend,
    backend_util: () => backend_util_exports,
    basicLSTMCell: () => basicLSTMCell,
    batchNorm: () => batchNorm,
    batchNorm2d: () => batchNorm2d,
    batchNorm3d: () => batchNorm3d,
    batchNorm4d: () => batchNorm4d,
    batchToSpaceND: () => batchToSpaceND,
    booleanMaskAsync: () => booleanMaskAsync,
    broadcastTo: () => broadcastTo,
    browser: () => browser_exports,
    buffer: () => buffer,
    cast: () => cast,
    ceil: () => ceil,
    clipByValue: () => clipByValue,
    clone: () => clone,
    complex: () => complex,
    concat: () => concat,
    concat1d: () => concat1d,
    concat2d: () => concat2d,
    concat3d: () => concat3d,
    concat4d: () => concat4d,
    conv1d: () => conv1d,
    conv2d: () => conv2d,
    conv2dTranspose: () => conv2dTranspose,
    conv3d: () => conv3d,
    conv3dTranspose: () => conv3dTranspose,
    cos: () => cos,
    cosh: () => cosh,
    cosineWindow: () => cosineWindow,
    cumsum: () => cumsum,
    customGrad: () => customGrad,
    deprecationWarn: () => deprecationWarn,
    depthToSpace: () => depthToSpace,
    depthwiseConv2d: () => depthwiseConv2d,
    device_util: () => device_util_exports,
    diag: () => diag,
    dilation2d: () => dilation2d,
    disableDeprecationWarnings: () => disableDeprecationWarnings,
    dispose: () => dispose,
    disposeVariables: () => disposeVariables,
    div: () => div,
    divNoNan: () => divNoNan,
    divStrict: () => divStrict,
    dot: () => dot,
    dropout: () => dropout,
    elu: () => elu,
    enableDebugMode: () => enableDebugMode,
    enableProdMode: () => enableProdMode,
    enclosingPowerOfTwo: () => enclosingPowerOfTwo,
    engine: () => engine15,
    env: () => env,
    equal: () => equal,
    equalStrict: () => equalStrict,
    erf: () => erf,
    exp: () => exp,
    expandDims: () => expandDims,
    expm1: () => expm1,
    eye: () => eye,
    fft: () => fft,
    fill: () => fill,
    findBackend: () => findBackend,
    findBackendFactory: () => findBackendFactory,
    floor: () => floor,
    floorDiv: () => floorDiv,
    fused: () => fused_ops_exports,
    gather: () => gather,
    gatherND: () => gatherND,
    gather_util: () => gather_nd_util_exports,
    getBackend: () => getBackend,
    getGradient: () => getGradient,
    getKernel: () => getKernel,
    getKernelsForBackend: () => getKernelsForBackend,
    grad: () => grad,
    grads: () => grads,
    greater: () => greater,
    greaterEqual: () => greaterEqual,
    greaterEqualStrict: () => greaterEqualStrict,
    greaterStrict: () => greaterStrict,
    ifft: () => ifft,
    imag: () => imag,
    image: () => image,
    inTopKAsync: () => inTopKAsync,
    io: () => io_exports,
    irfft: () => irfft,
    isFinite: () => isFinite2,
    isInf: () => isInf,
    isNaN: () => isNaN2,
    keep: () => keep,
    kernel_impls: () => kernel_impls_exports,
    leakyRelu: () => leakyRelu,
    less: () => less,
    lessEqual: () => lessEqual,
    lessEqualStrict: () => lessEqualStrict,
    lessStrict: () => lessStrict,
    linalg: () => linalg,
    linspace: () => linspace,
    localResponseNormalization: () => localResponseNormalization,
    log: () => log,
    log1p: () => log1p,
    logSigmoid: () => logSigmoid,
    logSoftmax: () => logSoftmax,
    logSumExp: () => logSumExp,
    logicalAnd: () => logicalAnd,
    logicalNot: () => logicalNot,
    logicalOr: () => logicalOr,
    logicalXor: () => logicalXor,
    losses: () => losses,
    matMul: () => matMul,
    math: () => math_exports,
    max: () => max,
    maxPool: () => maxPool,
    maxPool3d: () => maxPool3d,
    maxPoolWithArgmax: () => maxPoolWithArgmax,
    maximum: () => maximum,
    maximumStrict: () => maximumStrict,
    mean: () => mean,
    memory: () => memory,
    min: () => min,
    minimum: () => minimum,
    minimumStrict: () => minimumStrict,
    mod: () => mod,
    modStrict: () => modStrict,
    moments: () => moments,
    movingAverage: () => movingAverage,
    mul: () => mul,
    mulStrict: () => mulStrict,
    multiRNNCell: () => multiRNNCell,
    multinomial: () => multinomial,
    neg: () => neg,
    nextFrame: () => nextFrame,
    norm: () => norm,
    notEqual: () => notEqual,
    notEqualStrict: () => notEqualStrict,
    oneHot: () => oneHot,
    ones: () => ones2,
    onesLike: () => onesLike,
    op: () => op,
    outerProduct: () => outerProduct,
    pad: () => pad,
    pad1d: () => pad1d,
    pad2d: () => pad2d,
    pad3d: () => pad3d,
    pad4d: () => pad4d,
    pool: () => pool,
    pow: () => pow,
    powStrict: () => powStrict,
    prelu: () => prelu,
    print: () => print,
    prod: () => prod,
    profile: () => profile,
    rand: () => rand,
    randomGamma: () => randomGamma,
    randomNormal: () => randomNormal,
    randomUniform: () => randomUniform,
    range: () => range,
    ready: () => ready,
    real: () => real,
    reciprocal: () => reciprocal,
    registerBackend: () => registerBackend,
    registerGradient: () => registerGradient,
    registerKernel: () => registerKernel,
    relu: () => relu,
    relu6: () => relu6,
    removeBackend: () => removeBackend,
    reshape: () => reshape,
    reverse: () => reverse,
    reverse1d: () => reverse1d,
    reverse2d: () => reverse2d,
    reverse3d: () => reverse3d,
    reverse4d: () => reverse4d,
    rfft: () => rfft,
    round: () => round,
    rsqrt: () => rsqrt,
    scalar: () => scalar,
    scatterND: () => scatterND,
    scatter_util: () => scatter_nd_util_exports,
    selu: () => selu,
    separableConv2d: () => separableConv2d,
    serialization: () => serialization_exports,
    setBackend: () => setBackend,
    setPlatform: () => setPlatform,
    setdiff1dAsync: () => setdiff1dAsync,
    sigmoid: () => sigmoid,
    sign: () => sign,
    signal: () => signal,
    sin: () => sin,
    sinh: () => sinh,
    slice: () => slice,
    slice1d: () => slice1d,
    slice2d: () => slice2d,
    slice3d: () => slice3d,
    slice4d: () => slice4d,
    slice_util: () => slice_util_exports,
    softmax: () => softmax,
    softplus: () => softplus,
    spaceToBatchND: () => spaceToBatchND,
    sparseToDense: () => sparseToDense,
    spectral: () => spectral,
    split: () => split,
    sqrt: () => sqrt,
    square: () => square,
    squaredDifference: () => squaredDifference,
    squaredDifferenceStrict: () => squaredDifferenceStrict,
    squeeze: () => squeeze,
    stack: () => stack,
    step: () => step,
    stridedSlice: () => stridedSlice,
    sub: () => sub,
    subStrict: () => subStrict,
    sum: () => sum2,
    sumOutType: () => sumOutType,
    tan: () => tan,
    tanh: () => tanh2,
    tensor: () => tensor4,
    tensor1d: () => tensor1d,
    tensor2d: () => tensor2d,
    tensor3d: () => tensor3d,
    tensor4d: () => tensor4d,
    tensor5d: () => tensor5d,
    tensor6d: () => tensor6d,
    tensor_util: () => tensor_util_exports,
    test_util: () => test_util_exports,
    tidy: () => tidy,
    tile: () => tile,
    time: () => time,
    topk: () => topk,
    train: () => train,
    transpose: () => transpose,
    truncatedNormal: () => truncatedNormal,
    unregisterGradient: () => unregisterGradient,
    unregisterKernel: () => unregisterKernel,
    unsortedSegmentSum: () => unsortedSegmentSum,
    unstack: () => unstack,
    upcastType: () => upcastType,
    util: () => util_exports,
    valueAndGrad: () => valueAndGrad,
    valueAndGrads: () => valueAndGrads,
    variable: () => variable,
    variableGrads: () => variableGrads,
    version_core: () => version,
    where: () => where,
    whereAsync: () => whereAsync,
    zeros: () => zeros,
    zerosLike: () => zerosLike
  });
  /**
   * @license
   * Copyright 2017 Google LLC. All Rights Reserved.
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   * =============================================================================
   */

  // build/src/draw/drawContour.js
  function drawContour(ctx, points, isClosed = false) {
    ctx.beginPath();
    points.slice(1).forEach(({x, y}, prevIdx) => {
      const from = points[prevIdx];
      ctx.moveTo(from.x, from.y);
      ctx.lineTo(x, y);
    });
    if (isClosed) {
      const from = points[points.length - 1];
      const to = points[0];
      if (!from || !to) {
        return;
      }
      ctx.moveTo(from.x, from.y);
      ctx.lineTo(to.x, to.y);
    }
    ctx.stroke();
  }

  // build/src/classes/Dimensions.js
  class Dimensions {
    constructor(width, height) {
      if (!isValidNumber(width) || !isValidNumber(height)) {
        throw new Error(`Dimensions.constructor - expected width and height to be valid numbers, instead have ${JSON.stringify({width, height})}`);
      }
      this._width = width;
      this._height = height;
    }
    get width() {
      return this._width;
    }
    get height() {
      return this._height;
    }
    reverse() {
      return new Dimensions(1 / this.width, 1 / this.height);
    }
  }

  // build/src/utils/index.js
  const utils_exports = {};
  __export(utils_exports, {
    computeReshapedDimensions: () => computeReshapedDimensions,
    getCenterPoint: () => getCenterPoint,
    isDimensions: () => isDimensions,
    isEven: () => isEven,
    isFloat: () => isFloat,
    isTensor: () => isTensor,
    isTensor1D: () => isTensor1D,
    isTensor2D: () => isTensor2D,
    isTensor3D: () => isTensor3D,
    isTensor4D: () => isTensor4D,
    isValidNumber: () => isValidNumber,
    isValidProbablitiy: () => isValidProbablitiy,
    range: () => range4,
    round: () => round3
  });
  function isTensor(tensor17, dim) {
    return tensor17 instanceof Tensor && tensor17.shape.length === dim;
  }
  function isTensor1D(tensor17) {
    return isTensor(tensor17, 1);
  }
  function isTensor2D(tensor17) {
    return isTensor(tensor17, 2);
  }
  function isTensor3D(tensor17) {
    return isTensor(tensor17, 3);
  }
  function isTensor4D(tensor17) {
    return isTensor(tensor17, 4);
  }
  function isFloat(num) {
    return num % 1 !== 0;
  }
  function isEven(num) {
    return num % 2 === 0;
  }
  function round3(num, prec = 2) {
    const f = Math.pow(10, prec);
    return Math.floor(num * f) / f;
  }
  function isDimensions(obj) {
    return obj && obj.width && obj.height;
  }
  function computeReshapedDimensions({width, height}, inputSize) {
    const scale2 = inputSize / Math.max(height, width);
    return new Dimensions(Math.round(width * scale2), Math.round(height * scale2));
  }
  function getCenterPoint(pts) {
    return pts.reduce((sum26, pt) => sum26.add(pt), new Point(0, 0)).div(new Point(pts.length, pts.length));
  }
  function range4(num, start, step7) {
    return Array(num).fill(0).map((_, i) => start + i * step7);
  }
  function isValidNumber(num) {
    return !!num && num !== Infinity && num !== -Infinity && !isNaN(num) || num === 0;
  }
  function isValidProbablitiy(num) {
    return isValidNumber(num) && 0 <= num && num <= 1;
  }

  // build/src/classes/Point.js
  class Point {
    constructor(x, y) {
      this._x = x;
      this._y = y;
    }
    get x() {
      return this._x;
    }
    get y() {
      return this._y;
    }
    add(pt) {
      return new Point(this.x + pt.x, this.y + pt.y);
    }
    sub(pt) {
      return new Point(this.x - pt.x, this.y - pt.y);
    }
    mul(pt) {
      return new Point(this.x * pt.x, this.y * pt.y);
    }
    div(pt) {
      return new Point(this.x / pt.x, this.y / pt.y);
    }
    abs() {
      return new Point(Math.abs(this.x), Math.abs(this.y));
    }
    magnitude() {
      return Math.sqrt(Math.pow(this.x, 2) + Math.pow(this.y, 2));
    }
    floor() {
      return new Point(Math.floor(this.x), Math.floor(this.y));
    }
  }

  // build/src/classes/Box.js
  class Box {
    constructor(_box, allowNegativeDimensions = true) {
      const box = _box || {};
      const isBbox = [box.left, box.top, box.right, box.bottom].every(isValidNumber);
      const isRect = [box.x, box.y, box.width, box.height].every(isValidNumber);
      if (!isRect && !isBbox) {
        throw new Error(`Box.constructor - expected box to be IBoundingBox | IRect, instead have ${JSON.stringify(box)}`);
      }
      const [x, y, width, height] = isRect ? [box.x, box.y, box.width, box.height] : [box.left, box.top, box.right - box.left, box.bottom - box.top];
      Box.assertIsValidBox({x, y, width, height}, "Box.constructor", allowNegativeDimensions);
      this._x = x;
      this._y = y;
      this._width = width;
      this._height = height;
    }
    static isRect(rect) {
      return !!rect && [rect.x, rect.y, rect.width, rect.height].every(isValidNumber);
    }
    static assertIsValidBox(box, callee, allowNegativeDimensions = false) {
      if (!Box.isRect(box)) {
        throw new Error(`${callee} - invalid box: ${JSON.stringify(box)}, expected object with properties x, y, width, height`);
      }
      if (!allowNegativeDimensions && (box.width < 0 || box.height < 0)) {
        throw new Error(`${callee} - width (${box.width}) and height (${box.height}) must be positive numbers`);
      }
    }
    get x() {
      return this._x;
    }
    get y() {
      return this._y;
    }
    get width() {
      return this._width;
    }
    get height() {
      return this._height;
    }
    get left() {
      return this.x;
    }
    get top() {
      return this.y;
    }
    get right() {
      return this.x + this.width;
    }
    get bottom() {
      return this.y + this.height;
    }
    get area() {
      return this.width * this.height;
    }
    get topLeft() {
      return new Point(this.left, this.top);
    }
    get topRight() {
      return new Point(this.right, this.top);
    }
    get bottomLeft() {
      return new Point(this.left, this.bottom);
    }
    get bottomRight() {
      return new Point(this.right, this.bottom);
    }
    round() {
      const [x, y, width, height] = [this.x, this.y, this.width, this.height].map((val) => Math.round(val));
      return new Box({x, y, width, height});
    }
    floor() {
      const [x, y, width, height] = [this.x, this.y, this.width, this.height].map((val) => Math.floor(val));
      return new Box({x, y, width, height});
    }
    toSquare() {
      let {x, y, width, height} = this;
      const diff = Math.abs(width - height);
      if (width < height) {
        x -= diff / 2;
        width += diff;
      }
      if (height < width) {
        y -= diff / 2;
        height += diff;
      }
      return new Box({x, y, width, height});
    }
    rescale(s) {
      const scaleX = isDimensions(s) ? s.width : s;
      const scaleY = isDimensions(s) ? s.height : s;
      return new Box({
        x: this.x * scaleX,
        y: this.y * scaleY,
        width: this.width * scaleX,
        height: this.height * scaleY
      });
    }
    pad(padX, padY) {
      let [x, y, width, height] = [
        this.x - padX / 2,
        this.y - padY / 2,
        this.width + padX,
        this.height + padY
      ];
      return new Box({x, y, width, height});
    }
    clipAtImageBorders(imgWidth, imgHeight) {
      const {x, y, right, bottom} = this;
      const clippedX = Math.max(x, 0);
      const clippedY = Math.max(y, 0);
      const newWidth = right - clippedX;
      const newHeight = bottom - clippedY;
      const clippedWidth = Math.min(newWidth, imgWidth - clippedX);
      const clippedHeight = Math.min(newHeight, imgHeight - clippedY);
      return new Box({x: clippedX, y: clippedY, width: clippedWidth, height: clippedHeight}).floor();
    }
    shift(sx, sy) {
      const {width, height} = this;
      const x = this.x + sx;
      const y = this.y + sy;
      return new Box({x, y, width, height});
    }
    padAtBorders(imageHeight, imageWidth) {
      const w = this.width + 1;
      const h = this.height + 1;
      let dx = 1;
      let dy = 1;
      let edx = w;
      let edy = h;
      let x = this.left;
      let y = this.top;
      let ex = this.right;
      let ey = this.bottom;
      if (ex > imageWidth) {
        edx = -ex + imageWidth + w;
        ex = imageWidth;
      }
      if (ey > imageHeight) {
        edy = -ey + imageHeight + h;
        ey = imageHeight;
      }
      if (x < 1) {
        edy = 2 - x;
        x = 1;
      }
      if (y < 1) {
        edy = 2 - y;
        y = 1;
      }
      return {dy, edy, dx, edx, y, ey, x, ex, w, h};
    }
    calibrate(region) {
      return new Box({
        left: this.left + region.left * this.width,
        top: this.top + region.top * this.height,
        right: this.right + region.right * this.width,
        bottom: this.bottom + region.bottom * this.height
      }).toSquare().round();
    }
  }

  // build/src/classes/BoundingBox.js
  class BoundingBox extends Box {
    constructor(left, top, right, bottom, allowNegativeDimensions = false) {
      super({left, top, right, bottom}, allowNegativeDimensions);
    }
  }

  // build/src/classes/ObjectDetection.js
  class ObjectDetection {
    constructor(score, classScore, className, relativeBox, imageDims) {
      this._imageDims = new Dimensions(imageDims.width, imageDims.height);
      this._score = score;
      this._classScore = classScore;
      this._className = className;
      this._box = new Box(relativeBox).rescale(this._imageDims);
    }
    get score() {
      return this._score;
    }
    get classScore() {
      return this._classScore;
    }
    get className() {
      return this._className;
    }
    get box() {
      return this._box;
    }
    get imageDims() {
      return this._imageDims;
    }
    get imageWidth() {
      return this.imageDims.width;
    }
    get imageHeight() {
      return this.imageDims.height;
    }
    get relativeBox() {
      return new Box(this._box).rescale(this.imageDims.reverse());
    }
    forSize(width, height) {
      return new ObjectDetection(this.score, this.classScore, this.className, this.relativeBox, {width, height});
    }
  }

  // build/src/classes/FaceDetection.js
  class FaceDetection extends ObjectDetection {
    constructor(score, relativeBox, imageDims) {
      super(score, score, "", relativeBox, imageDims);
    }
    forSize(width, height) {
      const {score, relativeBox, imageDims} = super.forSize(width, height);
      return new FaceDetection(score, relativeBox, imageDims);
    }
  }

  // build/src/ops/iou.js
  function iou(box1, box2, isIOU = true) {
    const width = Math.max(0, Math.min(box1.right, box2.right) - Math.max(box1.left, box2.left));
    const height = Math.max(0, Math.min(box1.bottom, box2.bottom) - Math.max(box1.top, box2.top));
    const interSection = width * height;
    return isIOU ? interSection / (box1.area + box2.area - interSection) : interSection / Math.min(box1.area, box2.area);
  }

  // build/src/ops/minBbox.js
  function minBbox(pts) {
    const xs = pts.map((pt) => pt.x);
    const ys = pts.map((pt) => pt.y);
    const minX = xs.reduce((min4, x) => x < min4 ? x : min4, Infinity);
    const minY = ys.reduce((min4, y) => y < min4 ? y : min4, Infinity);
    const maxX = xs.reduce((max6, x) => max6 < x ? x : max6, 0);
    const maxY = ys.reduce((max6, y) => max6 < y ? y : max6, 0);
    return new BoundingBox(minX, minY, maxX, maxY);
  }

  // build/src/ops/nonMaxSuppression.js
  function nonMaxSuppression2(boxes, scores, iouThreshold, isIOU = true) {
    let indicesSortedByScore = scores.map((score, boxIndex) => ({score, boxIndex})).sort((c1, c2) => c1.score - c2.score).map((c) => c.boxIndex);
    const pick = [];
    while (indicesSortedByScore.length > 0) {
      const curr = indicesSortedByScore.pop();
      pick.push(curr);
      const indices = indicesSortedByScore;
      const outputs = [];
      for (let i = 0; i < indices.length; i++) {
        const idx = indices[i];
        const currBox = boxes[curr];
        const idxBox = boxes[idx];
        outputs.push(iou(currBox, idxBox, isIOU));
      }
      indicesSortedByScore = indicesSortedByScore.filter((_, j) => outputs[j] <= iouThreshold);
    }
    return pick;
  }

  // build/src/ops/normalize.js
  function normalize(x, meanRgb) {
    return tidy(() => {
      const [r, g, b] = meanRgb;
      const avg_r = fill([...x.shape.slice(0, 3), 1], r);
      const avg_g = fill([...x.shape.slice(0, 3), 1], g);
      const avg_b = fill([...x.shape.slice(0, 3), 1], b);
      const avg_rgb = concat([avg_r, avg_g, avg_b], 3);
      return sub(x, avg_rgb);
    });
  }

  // build/src/ops/padToSquare.js
  function padToSquare(imgTensor, isCenterImage = false) {
    return tidy(() => {
      const [height, width] = imgTensor.shape.slice(1);
      if (height === width) {
        return imgTensor;
      }
      const dimDiff = Math.abs(height - width);
      const paddingAmount = Math.round(dimDiff * (isCenterImage ? 0.5 : 1));
      const paddingAxis = height > width ? 2 : 1;
      const createPaddingTensor = (paddingAmount2) => {
        const paddingTensorShape = imgTensor.shape.slice();
        paddingTensorShape[paddingAxis] = paddingAmount2;
        return fill(paddingTensorShape, 0);
      };
      const paddingTensorAppend = createPaddingTensor(paddingAmount);
      const remainingPaddingAmount = dimDiff - paddingTensorAppend.shape[paddingAxis];
      const paddingTensorPrepend = isCenterImage && remainingPaddingAmount ? createPaddingTensor(remainingPaddingAmount) : null;
      const tensorsToStack = [
        paddingTensorPrepend,
        imgTensor,
        paddingTensorAppend
      ].filter((t) => !!t).map((t) => cast(t, "float32"));
      return concat(tensorsToStack, paddingAxis);
    });
  }

  // build/src/ops/shuffleArray.js
  function shuffleArray(inputArray) {
    const array = inputArray.slice();
    for (let i = array.length - 1; i > 0; i--) {
      const j = Math.floor(Math.random() * (i + 1));
      const x = array[i];
      array[i] = array[j];
      array[j] = x;
    }
    return array;
  }

  // build/src/ops/index.js
  function sigmoid6(x) {
    return 1 / (1 + Math.exp(-x));
  }
  function inverseSigmoid(x) {
    return Math.log(x / (1 - x));
  }

  // build/src/classes/Rect.js
  class Rect extends Box {
    constructor(x, y, width, height, allowNegativeDimensions = false) {
      super({x, y, width, height}, allowNegativeDimensions);
    }
  }

  // build/src/classes/FaceLandmarks.js
  const relX = 0.5;
  const relY = 0.43;
  const relScale = 0.45;
  class FaceLandmarks {
    constructor(relativeFaceLandmarkPositions, imgDims, shift = new Point(0, 0)) {
      const {width, height} = imgDims;
      this._imgDims = new Dimensions(width, height);
      this._shift = shift;
      this._positions = relativeFaceLandmarkPositions.map((pt) => pt.mul(new Point(width, height)).add(shift));
    }
    get shift() {
      return new Point(this._shift.x, this._shift.y);
    }
    get imageWidth() {
      return this._imgDims.width;
    }
    get imageHeight() {
      return this._imgDims.height;
    }
    get positions() {
      return this._positions;
    }
    get relativePositions() {
      return this._positions.map((pt) => pt.sub(this._shift).div(new Point(this.imageWidth, this.imageHeight)));
    }
    forSize(width, height) {
      return new this.constructor(this.relativePositions, {width, height});
    }
    shiftBy(x, y) {
      return new this.constructor(this.relativePositions, this._imgDims, new Point(x, y));
    }
    shiftByPoint(pt) {
      return this.shiftBy(pt.x, pt.y);
    }
    align(detection, options = {}) {
      if (detection) {
        const box = detection instanceof FaceDetection ? detection.box.floor() : new Box(detection);
        return this.shiftBy(box.x, box.y).align(null, options);
      }
      const {useDlibAlignment, minBoxPadding} = Object.assign({}, {useDlibAlignment: false, minBoxPadding: 0.2}, options);
      if (useDlibAlignment) {
        return this.alignDlib();
      }
      return this.alignMinBbox(minBoxPadding);
    }
    alignDlib() {
      const centers = this.getRefPointsForAlignment();
      const [leftEyeCenter, rightEyeCenter, mouthCenter] = centers;
      const distToMouth = (pt) => mouthCenter.sub(pt).magnitude();
      const eyeToMouthDist = (distToMouth(leftEyeCenter) + distToMouth(rightEyeCenter)) / 2;
      const size = Math.floor(eyeToMouthDist / relScale);
      const refPoint = getCenterPoint(centers);
      const x = Math.floor(Math.max(0, refPoint.x - relX * size));
      const y = Math.floor(Math.max(0, refPoint.y - relY * size));
      return new Rect(x, y, Math.min(size, this.imageWidth + x), Math.min(size, this.imageHeight + y));
    }
    alignMinBbox(padding) {
      const box = minBbox(this.positions);
      return box.pad(box.width * padding, box.height * padding);
    }
    getRefPointsForAlignment() {
      throw new Error("getRefPointsForAlignment not implemented by base class");
    }
  }

  // build/src/classes/FaceLandmarks5.js
  class FaceLandmarks5 extends FaceLandmarks {
    getRefPointsForAlignment() {
      const pts = this.positions;
      return [
        pts[0],
        pts[1],
        getCenterPoint([pts[3], pts[4]])
      ];
    }
  }

  // build/src/classes/FaceLandmarks68.js
  class FaceLandmarks68 extends FaceLandmarks {
    getJawOutline() {
      return this.positions.slice(0, 17);
    }
    getLeftEyeBrow() {
      return this.positions.slice(17, 22);
    }
    getRightEyeBrow() {
      return this.positions.slice(22, 27);
    }
    getNose() {
      return this.positions.slice(27, 36);
    }
    getLeftEye() {
      return this.positions.slice(36, 42);
    }
    getRightEye() {
      return this.positions.slice(42, 48);
    }
    getMouth() {
      return this.positions.slice(48, 68);
    }
    getRefPointsForAlignment() {
      return [
        this.getLeftEye(),
        this.getRightEye(),
        this.getMouth()
      ].map(getCenterPoint);
    }
  }

  // build/src/classes/FaceMatch.js
  class FaceMatch {
    constructor(label, distance) {
      this._label = label;
      this._distance = distance;
    }
    get label() {
      return this._label;
    }
    get distance() {
      return this._distance;
    }
    toString(withDistance = true) {
      return `${this.label}${withDistance ? ` (${round3(this.distance)})` : ""}`;
    }
  }

  // build/src/classes/LabeledBox.js
  class LabeledBox extends Box {
    constructor(box, label) {
      super(box);
      this._label = label;
    }
    static assertIsValidLabeledBox(box, callee) {
      Box.assertIsValidBox(box, callee);
      if (!isValidNumber(box.label)) {
        throw new Error(`${callee} - expected property label (${box.label}) to be a number`);
      }
    }
    get label() {
      return this._label;
    }
  }

  // build/src/classes/LabeledFaceDescriptors.js
  class LabeledFaceDescriptors {
    constructor(label, descriptors) {
      if (!(typeof label === "string")) {
        throw new Error("LabeledFaceDescriptors - constructor expected label to be a string");
      }
      if (!Array.isArray(descriptors) || descriptors.some((desc) => !(desc instanceof Float32Array))) {
        throw new Error("LabeledFaceDescriptors - constructor expected descriptors to be an array of Float32Array");
      }
      this._label = label;
      this._descriptors = descriptors;
    }
    get label() {
      return this._label;
    }
    get descriptors() {
      return this._descriptors;
    }
    toJSON() {
      return {
        label: this.label,
        descriptors: this.descriptors.map((d) => Array.from(d))
      };
    }
    static fromJSON(json) {
      const descriptors = json.descriptors.map((d) => {
        return new Float32Array(d);
      });
      return new LabeledFaceDescriptors(json.label, descriptors);
    }
  }

  // build/src/classes/PredictedBox.js
  class PredictedBox extends LabeledBox {
    constructor(box, label, score, classScore) {
      super(box, label);
      this._score = score;
      this._classScore = classScore;
    }
    static assertIsValidPredictedBox(box, callee) {
      LabeledBox.assertIsValidLabeledBox(box, callee);
      if (!isValidProbablitiy(box.score) || !isValidProbablitiy(box.classScore)) {
        throw new Error(`${callee} - expected properties score (${box.score}) and (${box.classScore}) to be a number between [0, 1]`);
      }
    }
    get score() {
      return this._score;
    }
    get classScore() {
      return this._classScore;
    }
  }

  // build/src/classes/index.js

  // build/src/factories/WithFaceDetection.js
  function isWithFaceDetection(obj) {
    return obj["detection"] instanceof FaceDetection;
  }
  function extendWithFaceDetection(sourceObj, detection) {
    const extension = {detection};
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/env/createBrowserEnv.js
  function createBrowserEnv() {
    const fetch3 = window["fetch"] || function() {
      throw new Error("fetch - missing fetch implementation for browser environment");
    };
    const readFile = function() {
      throw new Error("readFile - filesystem not available for browser environment");
    };
    return {
      Canvas: HTMLCanvasElement,
      CanvasRenderingContext2D,
      Image: HTMLImageElement,
      ImageData,
      Video: HTMLVideoElement,
      createCanvasElement: () => document.createElement("canvas"),
      createImageElement: () => document.createElement("img"),
      fetch: fetch3,
      readFile
    };
  }

  // build/src/env/createFileSystem.js
  function createFileSystem(fs) {
    let requireFsError = "";
    if (!fs) {
      try {
        fs = require("fs");
      } catch (err) {
        requireFsError = err.toString();
      }
    }
    const readFile = fs ? function(filePath) {
      return new Promise((res, rej) => {
        fs.readFile(filePath, function(err, buffer11) {
          return err ? rej(err) : res(buffer11);
        });
      });
    } : function() {
      throw new Error(`readFile - failed to require fs in nodejs environment with error: ${requireFsError}`);
    };
    return {
      readFile
    };
  }

  // build/src/env/createNodejsEnv.js
  function createNodejsEnv() {
    const Canvas = global["Canvas"] || global["HTMLCanvasElement"];
    const Image = global["Image"] || global["HTMLImageElement"];
    const createCanvasElement = function() {
      if (Canvas) {
        return new Canvas();
      }
      throw new Error("createCanvasElement - missing Canvas implementation for nodejs environment");
    };
    const createImageElement = function() {
      if (Image) {
        return new Image();
      }
      throw new Error("createImageElement - missing Image implementation for nodejs environment");
    };
    const fetch3 = global["fetch"] || function() {
      throw new Error("fetch - missing fetch implementation for nodejs environment");
    };
    const fileSystem = createFileSystem();
    return __assign({
      Canvas: Canvas || class {
      },
      CanvasRenderingContext2D: global["CanvasRenderingContext2D"] || class {
      },
      Image: Image || class {
      },
      ImageData: global["ImageData"] || class {
      },
      Video: global["HTMLVideoElement"] || class {
      },
      createCanvasElement,
      createImageElement,
      fetch: fetch3
    }, fileSystem);
  }

  // build/src/env/isBrowser.js
  function isBrowser2() {
    return typeof window === "object" && typeof document !== "undefined" && typeof HTMLImageElement !== "undefined" && typeof HTMLCanvasElement !== "undefined" && typeof HTMLVideoElement !== "undefined" && typeof ImageData !== "undefined" && typeof CanvasRenderingContext2D !== "undefined";
  }

  // build/src/env/types.js

  // build/src/env/index.js
  const isNodejs = __toModule(require_isNodejs());
  let environment11;
  function getEnv() {
    if (!environment11) {
      throw new Error("getEnv - environment is not defined, check isNodejs() and isBrowser()");
    }
    return environment11;
  }
  function setEnv(env17) {
    environment11 = env17;
  }
  function initialize() {
    if (isBrowser2()) {
      return setEnv(createBrowserEnv());
    }
    if (isNodejs.isNodejs()) {
      return setEnv(createNodejsEnv());
    }
  }
  function monkeyPatch(env17) {
    if (!environment11) {
      initialize();
    }
    if (!environment11) {
      throw new Error("monkeyPatch - environment is not defined, check isNodejs() and isBrowser()");
    }
    const {Canvas = environment11.Canvas, Image = environment11.Image} = env17;
    environment11.Canvas = Canvas;
    environment11.Image = Image;
    environment11.createCanvasElement = env17.createCanvasElement || (() => new Canvas());
    environment11.createImageElement = env17.createImageElement || (() => new Image());
    environment11.ImageData = env17.ImageData || environment11.ImageData;
    environment11.Video = env17.Video || environment11.Video;
    environment11.fetch = env17.fetch || environment11.fetch;
    environment11.readFile = env17.readFile || environment11.readFile;
  }
  const env2 = {
    getEnv,
    setEnv,
    initialize,
    createBrowserEnv,
    createFileSystem,
    createNodejsEnv,
    monkeyPatch,
    isBrowser: isBrowser2,
    isNodejs: isNodejs.isNodejs
  };
  initialize();

  // build/src/dom/resolveInput.js
  function resolveInput(arg) {
    if (!env2.isNodejs() && typeof arg === "string") {
      return document.getElementById(arg);
    }
    return arg;
  }

  // build/src/dom/getContext2dOrThrow.js
  function getContext2dOrThrow(canvasArg) {
    const {Canvas, CanvasRenderingContext2D: CanvasRenderingContext2D2} = env2.getEnv();
    if (canvasArg instanceof CanvasRenderingContext2D2) {
      return canvasArg;
    }
    const canvas = resolveInput(canvasArg);
    if (!(canvas instanceof Canvas)) {
      throw new Error("resolveContext2d - expected canvas to be of instance of Canvas");
    }
    const ctx = canvas.getContext("2d");
    if (!ctx) {
      throw new Error("resolveContext2d - canvas 2d context is null");
    }
    return ctx;
  }

  // build/src/draw/DrawTextField.js
  var AnchorPosition;
  (function(AnchorPosition2) {
    AnchorPosition2["TOP_LEFT"] = "TOP_LEFT";
    AnchorPosition2["TOP_RIGHT"] = "TOP_RIGHT";
    AnchorPosition2["BOTTOM_LEFT"] = "BOTTOM_LEFT";
    AnchorPosition2["BOTTOM_RIGHT"] = "BOTTOM_RIGHT";
  })(AnchorPosition || (AnchorPosition = {}));
  class DrawTextFieldOptions {
    constructor(options = {}) {
      const {anchorPosition, backgroundColor, fontColor, fontSize, fontStyle, padding} = options;
      this.anchorPosition = anchorPosition || AnchorPosition.TOP_LEFT;
      this.backgroundColor = backgroundColor || "rgba(0, 0, 0, 0.5)";
      this.fontColor = fontColor || "rgba(255, 255, 255, 1)";
      this.fontSize = fontSize || 14;
      this.fontStyle = fontStyle || "Georgia";
      this.padding = padding || 4;
    }
  }
  class DrawTextField {
    constructor(text, anchor, options = {}) {
      this.text = typeof text === "string" ? [text] : text instanceof DrawTextField ? text.text : text;
      this.anchor = anchor;
      this.options = new DrawTextFieldOptions(options);
    }
    measureWidth(ctx) {
      const {padding} = this.options;
      return this.text.map((l) => ctx.measureText(l).width).reduce((w0, w1) => w0 < w1 ? w1 : w0, 0) + 2 * padding;
    }
    measureHeight() {
      const {fontSize, padding} = this.options;
      return this.text.length * fontSize + 2 * padding;
    }
    getUpperLeft(ctx, canvasDims) {
      const {anchorPosition} = this.options;
      const isShiftLeft = anchorPosition === AnchorPosition.BOTTOM_RIGHT || anchorPosition === AnchorPosition.TOP_RIGHT;
      const isShiftTop = anchorPosition === AnchorPosition.BOTTOM_LEFT || anchorPosition === AnchorPosition.BOTTOM_RIGHT;
      const textFieldWidth = this.measureWidth(ctx);
      const textFieldHeight = this.measureHeight();
      const x = isShiftLeft ? this.anchor.x - textFieldWidth : this.anchor.x;
      const y = isShiftTop ? this.anchor.y - textFieldHeight : this.anchor.y;
      if (canvasDims) {
        const {width, height} = canvasDims;
        const newX = Math.max(Math.min(x, width - textFieldWidth), 0);
        const newY = Math.max(Math.min(y, height - textFieldHeight), 0);
        return {x: newX, y: newY};
      }
      return {x, y};
    }
    draw(canvasArg) {
      const canvas = resolveInput(canvasArg);
      const ctx = getContext2dOrThrow(canvas);
      const {backgroundColor, fontColor, fontSize, fontStyle, padding} = this.options;
      ctx.font = `${fontSize}px ${fontStyle}`;
      const maxTextWidth = this.measureWidth(ctx);
      const textHeight = this.measureHeight();
      ctx.fillStyle = backgroundColor;
      const upperLeft = this.getUpperLeft(ctx, canvas);
      ctx.fillRect(upperLeft.x, upperLeft.y, maxTextWidth, textHeight);
      ctx.fillStyle = fontColor;
      this.text.forEach((textLine, i) => {
        const x = padding + upperLeft.x;
        const y = padding + upperLeft.y + (i + 1) * fontSize;
        ctx.fillText(textLine, x, y);
      });
    }
  }

  // build/src/draw/DrawBox.js
  class DrawBoxOptions {
    constructor(options = {}) {
      const {boxColor, lineWidth, label, drawLabelOptions} = options;
      this.boxColor = boxColor || "rgba(0, 0, 255, 1)";
      this.lineWidth = lineWidth || 2;
      this.label = label;
      const defaultDrawLabelOptions = {
        anchorPosition: AnchorPosition.BOTTOM_LEFT,
        backgroundColor: this.boxColor
      };
      this.drawLabelOptions = new DrawTextFieldOptions(Object.assign({}, defaultDrawLabelOptions, drawLabelOptions));
    }
  }
  class DrawBox {
    constructor(box, options = {}) {
      this.box = new Box(box);
      this.options = new DrawBoxOptions(options);
    }
    draw(canvasArg) {
      const ctx = getContext2dOrThrow(canvasArg);
      const {boxColor, lineWidth} = this.options;
      const {x, y, width, height} = this.box;
      ctx.strokeStyle = boxColor;
      ctx.lineWidth = lineWidth;
      ctx.strokeRect(x, y, width, height);
      const {label} = this.options;
      if (label) {
        new DrawTextField([label], {x: x - lineWidth / 2, y}, this.options.drawLabelOptions).draw(canvasArg);
      }
    }
  }

  // build/src/draw/drawDetections.js
  function drawDetections(canvasArg, detections) {
    const detectionsArray = Array.isArray(detections) ? detections : [detections];
    detectionsArray.forEach((det) => {
      const score = det instanceof FaceDetection ? det.score : isWithFaceDetection(det) ? det.detection.score : void 0;
      const box = det instanceof FaceDetection ? det.box : isWithFaceDetection(det) ? det.detection.box : new Box(det);
      const label = score ? `${round3(score)}` : void 0;
      new DrawBox(box, {label}).draw(canvasArg);
    });
  }

  // build/src/dom/isMediaLoaded.js
  function isMediaLoaded(media) {
    const {Image, Video} = env2.getEnv();
    return media instanceof Image && media.complete || media instanceof Video && media.readyState >= 3;
  }

  // build/src/dom/awaitMediaLoaded.js
  function awaitMediaLoaded(media) {
    return new Promise((resolve, reject) => {
      if (media instanceof env2.getEnv().Canvas || isMediaLoaded(media)) {
        return resolve(null);
      }
      function onLoad(e) {
        if (!e.currentTarget)
          return;
        e.currentTarget.removeEventListener("load", onLoad);
        e.currentTarget.removeEventListener("error", onError);
        resolve(e);
      }
      function onError(e) {
        if (!e.currentTarget)
          return;
        e.currentTarget.removeEventListener("load", onLoad);
        e.currentTarget.removeEventListener("error", onError);
        reject(e);
      }
      media.addEventListener("load", onLoad);
      media.addEventListener("error", onError);
    });
  }

  // build/src/dom/bufferToImage.js
  function bufferToImage(buf) {
    return new Promise((resolve, reject) => {
      if (!(buf instanceof Blob)) {
        return reject("bufferToImage - expected buf to be of type: Blob");
      }
      const reader = new FileReader();
      reader.onload = () => {
        if (typeof reader.result !== "string") {
          return reject("bufferToImage - expected reader.result to be a string, in onload");
        }
        const img = env2.getEnv().createImageElement();
        img.onload = () => resolve(img);
        img.onerror = reject;
        img.src = reader.result;
      };
      reader.onerror = reject;
      reader.readAsDataURL(buf);
    });
  }

  // build/src/dom/getMediaDimensions.js
  function getMediaDimensions(input) {
    const {Image, Video} = env2.getEnv();
    if (input instanceof Image) {
      return new Dimensions(input.naturalWidth, input.naturalHeight);
    }
    if (input instanceof Video) {
      return new Dimensions(input.videoWidth, input.videoHeight);
    }
    return new Dimensions(input.width, input.height);
  }

  // build/src/dom/createCanvas.js
  function createCanvas({width, height}) {
    const {createCanvasElement} = env2.getEnv();
    const canvas = createCanvasElement();
    canvas.width = width;
    canvas.height = height;
    return canvas;
  }
  function createCanvasFromMedia(media, dims) {
    const {ImageData: ImageData2} = env2.getEnv();
    if (!(media instanceof ImageData2) && !isMediaLoaded(media)) {
      throw new Error("createCanvasFromMedia - media has not finished loading yet");
    }
    const {width, height} = dims || getMediaDimensions(media);
    const canvas = createCanvas({width, height});
    if (media instanceof ImageData2) {
      getContext2dOrThrow(canvas).putImageData(media, 0, 0);
    } else {
      getContext2dOrThrow(canvas).drawImage(media, 0, 0, width, height);
    }
    return canvas;
  }

  // build/src/dom/imageTensorToCanvas.js
  async function imageTensorToCanvas(imgTensor, canvas) {
    const targetCanvas = canvas || env2.getEnv().createCanvasElement();
    const [height, width, numChannels] = imgTensor.shape.slice(isTensor4D(imgTensor) ? 1 : 0);
    const imgTensor3D = tidy(() => imgTensor.as3D(height, width, numChannels).toInt());
    await browser_exports.toPixels(imgTensor3D, targetCanvas);
    imgTensor3D.dispose();
    return targetCanvas;
  }

  // build/src/dom/isMediaElement.js
  function isMediaElement(input) {
    const {Image, Canvas, Video} = env2.getEnv();
    return input instanceof Image || input instanceof Canvas || input instanceof Video;
  }

  // build/src/dom/imageToSquare.js
  function imageToSquare(input, inputSize, centerImage = false) {
    const {Image, Canvas} = env2.getEnv();
    if (!(input instanceof Image || input instanceof Canvas)) {
      throw new Error("imageToSquare - expected arg0 to be HTMLImageElement | HTMLCanvasElement");
    }
    const dims = getMediaDimensions(input);
    const scale2 = inputSize / Math.max(dims.height, dims.width);
    const width = scale2 * dims.width;
    const height = scale2 * dims.height;
    const targetCanvas = createCanvas({width: inputSize, height: inputSize});
    const inputCanvas = input instanceof Canvas ? input : createCanvasFromMedia(input);
    const offset = Math.abs(width - height) / 2;
    const dx = centerImage && width < height ? offset : 0;
    const dy = centerImage && height < width ? offset : 0;
    getContext2dOrThrow(targetCanvas).drawImage(inputCanvas, dx, dy, width, height);
    return targetCanvas;
  }

  // build/src/dom/NetInput.js
  class NetInput {
    constructor(inputs, treatAsBatchInput = false) {
      this._imageTensors = [];
      this._canvases = [];
      this._treatAsBatchInput = false;
      this._inputDimensions = [];
      if (!Array.isArray(inputs)) {
        throw new Error(`NetInput.constructor - expected inputs to be an Array of TResolvedNetInput or to be instanceof tf.Tensor4D, instead have ${inputs}`);
      }
      this._treatAsBatchInput = treatAsBatchInput;
      this._batchSize = inputs.length;
      inputs.forEach((input, idx) => {
        if (isTensor3D(input)) {
          this._imageTensors[idx] = input;
          this._inputDimensions[idx] = input.shape;
          return;
        }
        if (isTensor4D(input)) {
          const batchSize = input.shape[0];
          if (batchSize !== 1) {
            throw new Error(`NetInput - tf.Tensor4D with batchSize ${batchSize} passed, but not supported in input array`);
          }
          this._imageTensors[idx] = input;
          this._inputDimensions[idx] = input.shape.slice(1);
          return;
        }
        const canvas = input instanceof env2.getEnv().Canvas ? input : createCanvasFromMedia(input);
        this._canvases[idx] = canvas;
        this._inputDimensions[idx] = [canvas.height, canvas.width, 3];
      });
    }
    get imageTensors() {
      return this._imageTensors;
    }
    get canvases() {
      return this._canvases;
    }
    get isBatchInput() {
      return this.batchSize > 1 || this._treatAsBatchInput;
    }
    get batchSize() {
      return this._batchSize;
    }
    get inputDimensions() {
      return this._inputDimensions;
    }
    get inputSize() {
      return this._inputSize;
    }
    get reshapedInputDimensions() {
      return range4(this.batchSize, 0, 1).map((_, batchIdx) => this.getReshapedInputDimensions(batchIdx));
    }
    getInput(batchIdx) {
      return this.canvases[batchIdx] || this.imageTensors[batchIdx];
    }
    getInputDimensions(batchIdx) {
      return this._inputDimensions[batchIdx];
    }
    getInputHeight(batchIdx) {
      return this._inputDimensions[batchIdx][0];
    }
    getInputWidth(batchIdx) {
      return this._inputDimensions[batchIdx][1];
    }
    getReshapedInputDimensions(batchIdx) {
      if (typeof this.inputSize !== "number") {
        throw new Error("getReshapedInputDimensions - inputSize not set, toBatchTensor has not been called yet");
      }
      const width = this.getInputWidth(batchIdx);
      const height = this.getInputHeight(batchIdx);
      return computeReshapedDimensions({width, height}, this.inputSize);
    }
    toBatchTensor(inputSize, isCenterInputs = true) {
      this._inputSize = inputSize;
      return tidy(() => {
        const inputTensors = range4(this.batchSize, 0, 1).map((batchIdx) => {
          const input = this.getInput(batchIdx);
          if (input instanceof Tensor) {
            let imgTensor = isTensor4D(input) ? input : input.expandDims();
            imgTensor = padToSquare(imgTensor, isCenterInputs);
            if (imgTensor.shape[1] !== inputSize || imgTensor.shape[2] !== inputSize) {
              imgTensor = image.resizeBilinear(imgTensor, [inputSize, inputSize]);
            }
            return imgTensor.as3D(inputSize, inputSize, 3);
          }
          if (input instanceof env2.getEnv().Canvas) {
            return browser_exports.fromPixels(imageToSquare(input, inputSize, isCenterInputs));
          }
          throw new Error(`toBatchTensor - at batchIdx ${batchIdx}, expected input to be instanceof tf.Tensor or instanceof HTMLCanvasElement, instead have ${input}`);
        });
        const batchTensor = stack(inputTensors.map((t) => cast(t, "float32"))).as4D(this.batchSize, inputSize, inputSize, 3);
        return batchTensor;
      });
    }
  }

  // build/src/dom/toNetInput.js
  async function toNetInput(inputs) {
    if (inputs instanceof NetInput) {
      return inputs;
    }
    let inputArgArray = Array.isArray(inputs) ? inputs : [inputs];
    if (!inputArgArray.length) {
      throw new Error("toNetInput - empty array passed as input");
    }
    const getIdxHint = (idx) => Array.isArray(inputs) ? ` at input index ${idx}:` : "";
    const inputArray = inputArgArray.map(resolveInput);
    inputArray.forEach((input, i) => {
      if (!isMediaElement(input) && !isTensor3D(input) && !isTensor4D(input)) {
        if (typeof inputArgArray[i] === "string") {
          throw new Error(`toNetInput -${getIdxHint(i)} string passed, but could not resolve HTMLElement for element id ${inputArgArray[i]}`);
        }
        throw new Error(`toNetInput -${getIdxHint(i)} expected media to be of type HTMLImageElement | HTMLVideoElement | HTMLCanvasElement | tf.Tensor3D, or to be an element id`);
      }
      if (isTensor4D(input)) {
        const batchSize = input.shape[0];
        if (batchSize !== 1) {
          throw new Error(`toNetInput -${getIdxHint(i)} tf.Tensor4D with batchSize ${batchSize} passed, but not supported in input array`);
        }
      }
    });
    await Promise.all(inputArray.map((input) => isMediaElement(input) && awaitMediaLoaded(input)));
    return new NetInput(inputArray, Array.isArray(inputs));
  }

  // build/src/dom/extractFaces.js
  async function extractFaces(input, detections) {
    const {Canvas} = env2.getEnv();
    let canvas = input;
    if (!(input instanceof Canvas)) {
      const netInput = await toNetInput(input);
      if (netInput.batchSize > 1) {
        throw new Error("extractFaces - batchSize > 1 not supported");
      }
      const tensorOrCanvas = netInput.getInput(0);
      canvas = tensorOrCanvas instanceof Canvas ? tensorOrCanvas : await imageTensorToCanvas(tensorOrCanvas);
    }
    const ctx = getContext2dOrThrow(canvas);
    const boxes = detections.map((det) => det instanceof FaceDetection ? det.forSize(canvas.width, canvas.height).box.floor() : det).map((box) => box.clipAtImageBorders(canvas.width, canvas.height));
    return boxes.map(({x, y, width, height}) => {
      const faceImg = createCanvas({width, height});
      getContext2dOrThrow(faceImg).putImageData(ctx.getImageData(x, y, width, height), 0, 0);
      return faceImg;
    });
  }

  // build/src/dom/extractFaceTensors.js
  async function extractFaceTensors(imageTensor, detections) {
    if (!isTensor3D(imageTensor) && !isTensor4D(imageTensor)) {
      throw new Error("extractFaceTensors - expected image tensor to be 3D or 4D");
    }
    if (isTensor4D(imageTensor) && imageTensor.shape[0] > 1) {
      throw new Error("extractFaceTensors - batchSize > 1 not supported");
    }
    return tidy(() => {
      const [imgHeight, imgWidth, numChannels] = imageTensor.shape.slice(isTensor4D(imageTensor) ? 1 : 0);
      const boxes = detections.map((det) => det instanceof FaceDetection ? det.forSize(imgWidth, imgHeight).box : det).map((box) => box.clipAtImageBorders(imgWidth, imgHeight));
      const faceTensors = boxes.map(({x, y, width, height}) => slice3d(imageTensor.as3D(imgHeight, imgWidth, numChannels), [y, x, 0], [height, width, numChannels]));
      return faceTensors;
    });
  }

  // build/src/dom/fetchOrThrow.js
  async function fetchOrThrow(url, init) {
    const fetch3 = env2.getEnv().fetch;
    const res = await fetch3(url, init);
    if (!(res.status < 400)) {
      throw new Error(`failed to fetch: (${res.status}) ${res.statusText}, from url: ${res.url}`);
    }
    return res;
  }

  // build/src/dom/fetchImage.js
  async function fetchImage(uri) {
    const res = await fetchOrThrow(uri);
    const blob = await res.blob();
    if (!blob.type.startsWith("image/")) {
      throw new Error(`fetchImage - expected blob type to be of type image/*, instead have: ${blob.type}, for url: ${res.url}`);
    }
    return bufferToImage(blob);
  }

  // build/src/dom/fetchJson.js
  async function fetchJson(uri) {
    return (await fetchOrThrow(uri)).json();
  }

  // build/src/dom/fetchNetWeights.js
  async function fetchNetWeights(uri) {
    return new Float32Array(await (await fetchOrThrow(uri)).arrayBuffer());
  }

  // build/src/common/getModelUris.js
  function getModelUris(uri, defaultModelName) {
    const defaultManifestFilename = `${defaultModelName}-weights_manifest.json`;
    if (!uri) {
      return {
        modelBaseUri: "",
        manifestUri: defaultManifestFilename
      };
    }
    if (uri === "/") {
      return {
        modelBaseUri: "/",
        manifestUri: `/${defaultManifestFilename}`
      };
    }
    const protocol = uri.startsWith("http://") ? "http://" : uri.startsWith("https://") ? "https://" : "";
    uri = uri.replace(protocol, "");
    const parts = uri.split("/").filter((s) => s);
    const manifestFile = uri.endsWith(".json") ? parts[parts.length - 1] : defaultManifestFilename;
    let modelBaseUri = protocol + (uri.endsWith(".json") ? parts.slice(0, parts.length - 1) : parts).join("/");
    modelBaseUri = uri.startsWith("/") ? `/${modelBaseUri}` : modelBaseUri;
    return {
      modelBaseUri,
      manifestUri: modelBaseUri === "/" ? `/${manifestFile}` : `${modelBaseUri}/${manifestFile}`
    };
  }

  // build/src/dom/loadWeightMap.js
  async function loadWeightMap(uri, defaultModelName) {
    const {manifestUri, modelBaseUri} = getModelUris(uri, defaultModelName);
    let manifest = await fetchJson(manifestUri);
    return io_exports.loadWeights(manifest, modelBaseUri);
  }

  // build/src/dom/matchDimensions.js
  function matchDimensions(input, reference, useMediaDimensions = false) {
    const {width, height} = useMediaDimensions ? getMediaDimensions(reference) : reference;
    input.width = width;
    input.height = height;
    return {width, height};
  }

  // build/src/dom/types.js

  // build/src/dom/index.js

  // build/src/NeuralNetwork.js
  class NeuralNetwork {
    constructor(_name) {
      this._name = _name;
      this._params = void 0;
      this._paramMappings = [];
    }
    get params() {
      return this._params;
    }
    get paramMappings() {
      return this._paramMappings;
    }
    get isLoaded() {
      return !!this.params;
    }
    getParamFromPath(paramPath) {
      const {obj, objProp} = this.traversePropertyPath(paramPath);
      return obj[objProp];
    }
    reassignParamFromPath(paramPath, tensor17) {
      const {obj, objProp} = this.traversePropertyPath(paramPath);
      obj[objProp].dispose();
      obj[objProp] = tensor17;
    }
    getParamList() {
      return this._paramMappings.map(({paramPath}) => ({
        path: paramPath,
        tensor: this.getParamFromPath(paramPath)
      }));
    }
    getTrainableParams() {
      return this.getParamList().filter((param) => param.tensor instanceof Variable);
    }
    getFrozenParams() {
      return this.getParamList().filter((param) => !(param.tensor instanceof Variable));
    }
    variable() {
      this.getFrozenParams().forEach(({path, tensor: tensor17}) => {
        this.reassignParamFromPath(path, tensor17.variable());
      });
    }
    freeze() {
      this.getTrainableParams().forEach(({path, tensor: variable3}) => {
        const tensor17 = tensor4(variable3.dataSync());
        variable3.dispose();
        this.reassignParamFromPath(path, tensor17);
      });
    }
    dispose(throwOnRedispose = true) {
      this.getParamList().forEach((param) => {
        if (throwOnRedispose && param.tensor.isDisposed) {
          throw new Error(`param tensor has already been disposed for path ${param.path}`);
        }
        param.tensor.dispose();
      });
      this._params = void 0;
    }
    serializeParams() {
      return new Float32Array(this.getParamList().map(({tensor: tensor17}) => Array.from(tensor17.dataSync())).reduce((flat, arr) => flat.concat(arr)));
    }
    async load(weightsOrUrl) {
      if (weightsOrUrl instanceof Float32Array) {
        this.extractWeights(weightsOrUrl);
        return;
      }
      await this.loadFromUri(weightsOrUrl);
    }
    async loadFromUri(uri) {
      if (uri && typeof uri !== "string") {
        throw new Error(`${this._name}.loadFromUri - expected model uri`);
      }
      const weightMap = await loadWeightMap(uri, this.getDefaultModelName());
      this.loadFromWeightMap(weightMap);
    }
    async loadFromDisk(filePath) {
      if (filePath && typeof filePath !== "string") {
        throw new Error(`${this._name}.loadFromDisk - expected model file path`);
      }
      const {readFile} = env2.getEnv();
      const {manifestUri, modelBaseUri} = getModelUris(filePath, this.getDefaultModelName());
      const fetchWeightsFromDisk = (filePaths) => Promise.all(filePaths.map((filePath2) => readFile(filePath2).then((buf) => buf.buffer)));
      const loadWeights2 = io_exports.weightsLoaderFactory(fetchWeightsFromDisk);
      const manifest = JSON.parse((await readFile(manifestUri)).toString());
      const weightMap = await loadWeights2(manifest, modelBaseUri);
      this.loadFromWeightMap(weightMap);
    }
    loadFromWeightMap(weightMap) {
      const {paramMappings, params} = this.extractParamsFromWeigthMap(weightMap);
      this._paramMappings = paramMappings;
      this._params = params;
    }
    extractWeights(weights) {
      const {paramMappings, params} = this.extractParams(weights);
      this._paramMappings = paramMappings;
      this._params = params;
    }
    traversePropertyPath(paramPath) {
      if (!this.params) {
        throw new Error(`traversePropertyPath - model has no loaded params`);
      }
      const result = paramPath.split("/").reduce((res, objProp2) => {
        if (!res.nextObj.hasOwnProperty(objProp2)) {
          throw new Error(`traversePropertyPath - object does not have property ${objProp2}, for path ${paramPath}`);
        }
        return {obj: res.nextObj, objProp: objProp2, nextObj: res.nextObj[objProp2]};
      }, {nextObj: this.params});
      const {obj, objProp} = result;
      if (!obj || !objProp || !(obj[objProp] instanceof Tensor)) {
        throw new Error(`traversePropertyPath - parameter is not a tensor, for path ${paramPath}`);
      }
      return {obj, objProp};
    }
  }

  // build/src/common/depthwiseSeparableConv.js
  function depthwiseSeparableConv(x, params, stride) {
    return tidy(() => {
      let out = separableConv2d(x, params.depthwise_filter, params.pointwise_filter, stride, "same");
      out = add2(out, params.bias);
      return out;
    });
  }

  // build/src/faceFeatureExtractor/denseBlock.js
  function denseBlock3(x, denseBlockParams, isFirstLayer = false) {
    return tidy(() => {
      const out1 = relu(isFirstLayer ? add2(conv2d(x, denseBlockParams.conv0.filters, [2, 2], "same"), denseBlockParams.conv0.bias) : depthwiseSeparableConv(x, denseBlockParams.conv0, [2, 2]));
      const out2 = depthwiseSeparableConv(out1, denseBlockParams.conv1, [1, 1]);
      const in3 = relu(add2(out1, out2));
      const out3 = depthwiseSeparableConv(in3, denseBlockParams.conv2, [1, 1]);
      return relu(add2(out1, add2(out2, out3)));
    });
  }
  function denseBlock4(x, denseBlockParams, isFirstLayer = false, isScaleDown = true) {
    return tidy(() => {
      const out1 = relu(isFirstLayer ? add2(conv2d(x, denseBlockParams.conv0.filters, isScaleDown ? [2, 2] : [1, 1], "same"), denseBlockParams.conv0.bias) : depthwiseSeparableConv(x, denseBlockParams.conv0, isScaleDown ? [2, 2] : [1, 1]));
      const out2 = depthwiseSeparableConv(out1, denseBlockParams.conv1, [1, 1]);
      const in3 = relu(add2(out1, out2));
      const out3 = depthwiseSeparableConv(in3, denseBlockParams.conv2, [1, 1]);
      const in4 = relu(add2(out1, add2(out2, out3)));
      const out4 = depthwiseSeparableConv(in4, denseBlockParams.conv3, [1, 1]);
      return relu(add2(out1, add2(out2, add2(out3, out4))));
    });
  }

  // build/src/common/convLayer.js
  function convLayer(x, params, padding = "same", withRelu = false) {
    return tidy(() => {
      const out = add2(conv2d(x, params.filters, [1, 1], padding), params.bias);
      return withRelu ? relu(out) : out;
    });
  }

  // build/src/common/disposeUnusedWeightTensors.js
  function disposeUnusedWeightTensors(weightMap, paramMappings) {
    Object.keys(weightMap).forEach((path) => {
      if (!paramMappings.some((pm) => pm.originalPath === path)) {
        weightMap[path].dispose();
      }
    });
  }

  // build/src/common/extractConvParamsFactory.js
  function extractConvParamsFactory(extractWeights, paramMappings) {
    return function(channelsIn, channelsOut, filterSize, mappedPrefix) {
      const filters = tensor4d(extractWeights(channelsIn * channelsOut * filterSize * filterSize), [filterSize, filterSize, channelsIn, channelsOut]);
      const bias = tensor1d(extractWeights(channelsOut));
      paramMappings.push({paramPath: `${mappedPrefix}/filters`}, {paramPath: `${mappedPrefix}/bias`});
      return {filters, bias};
    };
  }

  // build/src/common/extractFCParamsFactory.js
  function extractFCParamsFactory(extractWeights, paramMappings) {
    return function(channelsIn, channelsOut, mappedPrefix) {
      const fc_weights = tensor2d(extractWeights(channelsIn * channelsOut), [channelsIn, channelsOut]);
      const fc_bias = tensor1d(extractWeights(channelsOut));
      paramMappings.push({paramPath: `${mappedPrefix}/weights`}, {paramPath: `${mappedPrefix}/bias`});
      return {
        weights: fc_weights,
        bias: fc_bias
      };
    };
  }

  // build/src/common/types.js
  class SeparableConvParams {
    constructor(depthwise_filter, pointwise_filter, bias) {
      this.depthwise_filter = depthwise_filter;
      this.pointwise_filter = pointwise_filter;
      this.bias = bias;
    }
  }

  // build/src/common/extractSeparableConvParamsFactory.js
  function extractSeparableConvParamsFactory(extractWeights, paramMappings) {
    return function(channelsIn, channelsOut, mappedPrefix) {
      const depthwise_filter = tensor4d(extractWeights(3 * 3 * channelsIn), [3, 3, channelsIn, 1]);
      const pointwise_filter = tensor4d(extractWeights(channelsIn * channelsOut), [1, 1, channelsIn, channelsOut]);
      const bias = tensor1d(extractWeights(channelsOut));
      paramMappings.push({paramPath: `${mappedPrefix}/depthwise_filter`}, {paramPath: `${mappedPrefix}/pointwise_filter`}, {paramPath: `${mappedPrefix}/bias`});
      return new SeparableConvParams(depthwise_filter, pointwise_filter, bias);
    };
  }
  function loadSeparableConvParamsFactory(extractWeightEntry) {
    return function(prefix) {
      const depthwise_filter = extractWeightEntry(`${prefix}/depthwise_filter`, 4);
      const pointwise_filter = extractWeightEntry(`${prefix}/pointwise_filter`, 4);
      const bias = extractWeightEntry(`${prefix}/bias`, 1);
      return new SeparableConvParams(depthwise_filter, pointwise_filter, bias);
    };
  }

  // build/src/common/extractWeightEntryFactory.js
  function extractWeightEntryFactory(weightMap, paramMappings) {
    return function(originalPath, paramRank, mappedPath) {
      const tensor17 = weightMap[originalPath];
      if (!isTensor(tensor17, paramRank)) {
        throw new Error(`expected weightMap[${originalPath}] to be a Tensor${paramRank}D, instead have ${tensor17}`);
      }
      paramMappings.push({originalPath, paramPath: mappedPath || originalPath});
      return tensor17;
    };
  }

  // build/src/common/extractWeightsFactory.js
  function extractWeightsFactory(weights) {
    let remainingWeights = weights;
    function extractWeights(numWeights) {
      const ret = remainingWeights.slice(0, numWeights);
      remainingWeights = remainingWeights.slice(numWeights);
      return ret;
    }
    function getRemainingWeights() {
      return remainingWeights;
    }
    return {
      extractWeights,
      getRemainingWeights
    };
  }

  // build/src/common/index.js

  // build/src/faceFeatureExtractor/extractorsFactory.js
  function extractorsFactory(extractWeights, paramMappings) {
    const extractConvParams = extractConvParamsFactory(extractWeights, paramMappings);
    const extractSeparableConvParams = extractSeparableConvParamsFactory(extractWeights, paramMappings);
    function extractDenseBlock3Params(channelsIn, channelsOut, mappedPrefix, isFirstLayer = false) {
      const conv0 = isFirstLayer ? extractConvParams(channelsIn, channelsOut, 3, `${mappedPrefix}/conv0`) : extractSeparableConvParams(channelsIn, channelsOut, `${mappedPrefix}/conv0`);
      const conv1 = extractSeparableConvParams(channelsOut, channelsOut, `${mappedPrefix}/conv1`);
      const conv22 = extractSeparableConvParams(channelsOut, channelsOut, `${mappedPrefix}/conv2`);
      return {conv0, conv1, conv2: conv22};
    }
    function extractDenseBlock4Params(channelsIn, channelsOut, mappedPrefix, isFirstLayer = false) {
      const {conv0, conv1, conv2: conv22} = extractDenseBlock3Params(channelsIn, channelsOut, mappedPrefix, isFirstLayer);
      const conv3 = extractSeparableConvParams(channelsOut, channelsOut, `${mappedPrefix}/conv3`);
      return {conv0, conv1, conv2: conv22, conv3};
    }
    return {
      extractDenseBlock3Params,
      extractDenseBlock4Params
    };
  }

  // build/src/faceFeatureExtractor/extractParams.js
  function extractParams(weights) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const {extractDenseBlock4Params} = extractorsFactory(extractWeights, paramMappings);
    const dense0 = extractDenseBlock4Params(3, 32, "dense0", true);
    const dense1 = extractDenseBlock4Params(32, 64, "dense1");
    const dense2 = extractDenseBlock4Params(64, 128, "dense2");
    const dense3 = extractDenseBlock4Params(128, 256, "dense3");
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      paramMappings,
      params: {dense0, dense1, dense2, dense3}
    };
  }

  // build/src/common/loadConvParamsFactory.js
  function loadConvParamsFactory(extractWeightEntry) {
    return function(prefix) {
      const filters = extractWeightEntry(`${prefix}/filters`, 4);
      const bias = extractWeightEntry(`${prefix}/bias`, 1);
      return {filters, bias};
    };
  }

  // build/src/faceFeatureExtractor/loadParamsFactory.js
  function loadParamsFactory(weightMap, paramMappings) {
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    const extractConvParams = loadConvParamsFactory(extractWeightEntry);
    const extractSeparableConvParams = loadSeparableConvParamsFactory(extractWeightEntry);
    function extractDenseBlock3Params(prefix, isFirstLayer = false) {
      const conv0 = isFirstLayer ? extractConvParams(`${prefix}/conv0`) : extractSeparableConvParams(`${prefix}/conv0`);
      const conv1 = extractSeparableConvParams(`${prefix}/conv1`);
      const conv22 = extractSeparableConvParams(`${prefix}/conv2`);
      return {conv0, conv1, conv2: conv22};
    }
    function extractDenseBlock4Params(prefix, isFirstLayer = false) {
      const conv0 = isFirstLayer ? extractConvParams(`${prefix}/conv0`) : extractSeparableConvParams(`${prefix}/conv0`);
      const conv1 = extractSeparableConvParams(`${prefix}/conv1`);
      const conv22 = extractSeparableConvParams(`${prefix}/conv2`);
      const conv3 = extractSeparableConvParams(`${prefix}/conv3`);
      return {conv0, conv1, conv2: conv22, conv3};
    }
    return {
      extractDenseBlock3Params,
      extractDenseBlock4Params
    };
  }

  // build/src/faceFeatureExtractor/extractParamsFromWeigthMap.js
  function extractParamsFromWeigthMap(weightMap) {
    const paramMappings = [];
    const {extractDenseBlock4Params} = loadParamsFactory(weightMap, paramMappings);
    const params = {
      dense0: extractDenseBlock4Params("dense0", true),
      dense1: extractDenseBlock4Params("dense1"),
      dense2: extractDenseBlock4Params("dense2"),
      dense3: extractDenseBlock4Params("dense3")
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/faceFeatureExtractor/FaceFeatureExtractor.js
  class FaceFeatureExtractor extends NeuralNetwork {
    constructor() {
      super("FaceFeatureExtractor");
    }
    forwardInput(input) {
      const {params} = this;
      if (!params) {
        throw new Error("FaceFeatureExtractor - load model before inference");
      }
      return tidy(() => {
        const batchTensor = input.toBatchTensor(112, true);
        const meanRgb = [122.782, 117.001, 104.298];
        const normalized = normalize(batchTensor, meanRgb).div(scalar(255));
        let out = denseBlock4(normalized, params.dense0, true);
        out = denseBlock4(out, params.dense1);
        out = denseBlock4(out, params.dense2);
        out = denseBlock4(out, params.dense3);
        out = avgPool(out, [7, 7], [2, 2], "valid");
        return out;
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    getDefaultModelName() {
      return "face_feature_extractor_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMap(weightMap);
    }
    extractParams(weights) {
      return extractParams(weights);
    }
  }

  // build/src/common/fullyConnectedLayer.js
  function fullyConnectedLayer(x, params) {
    return tidy(() => add2(matMul(x, params.weights), params.bias));
  }

  // build/src/faceProcessor/extractParams.js
  function extractParams3(weights, channelsIn, channelsOut) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const extractFCParams = extractFCParamsFactory(extractWeights, paramMappings);
    const fc = extractFCParams(channelsIn, channelsOut, "fc");
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      paramMappings,
      params: {fc}
    };
  }

  // build/src/faceProcessor/extractParamsFromWeigthMap.js
  function extractParamsFromWeigthMap3(weightMap) {
    const paramMappings = [];
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    function extractFcParams(prefix) {
      const weights = extractWeightEntry(`${prefix}/weights`, 2);
      const bias = extractWeightEntry(`${prefix}/bias`, 1);
      return {weights, bias};
    }
    const params = {
      fc: extractFcParams("fc")
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/faceProcessor/util.js
  function seperateWeightMaps(weightMap) {
    const featureExtractorMap = {};
    const classifierMap = {};
    Object.keys(weightMap).forEach((key) => {
      const map = key.startsWith("fc") ? classifierMap : featureExtractorMap;
      map[key] = weightMap[key];
    });
    return {featureExtractorMap, classifierMap};
  }

  // build/src/faceProcessor/FaceProcessor.js
  class FaceProcessor extends NeuralNetwork {
    constructor(_name, faceFeatureExtractor) {
      super(_name);
      this._faceFeatureExtractor = faceFeatureExtractor;
    }
    get faceFeatureExtractor() {
      return this._faceFeatureExtractor;
    }
    runNet(input) {
      const {params} = this;
      if (!params) {
        throw new Error(`${this._name} - load model before inference`);
      }
      return tidy(() => {
        const bottleneckFeatures = input instanceof NetInput ? this.faceFeatureExtractor.forwardInput(input) : input;
        return fullyConnectedLayer(bottleneckFeatures.as2D(bottleneckFeatures.shape[0], -1), params.fc);
      });
    }
    dispose(throwOnRedispose = true) {
      this.faceFeatureExtractor.dispose(throwOnRedispose);
      super.dispose(throwOnRedispose);
    }
    loadClassifierParams(weights) {
      const {params, paramMappings} = this.extractClassifierParams(weights);
      this._params = params;
      this._paramMappings = paramMappings;
    }
    extractClassifierParams(weights) {
      return extractParams3(weights, this.getClassifierChannelsIn(), this.getClassifierChannelsOut());
    }
    extractParamsFromWeigthMap(weightMap) {
      const {featureExtractorMap, classifierMap} = seperateWeightMaps(weightMap);
      this.faceFeatureExtractor.loadFromWeightMap(featureExtractorMap);
      return extractParamsFromWeigthMap3(classifierMap);
    }
    extractParams(weights) {
      const cIn = this.getClassifierChannelsIn();
      const cOut = this.getClassifierChannelsOut();
      const classifierWeightSize = cOut * cIn + cOut;
      const featureExtractorWeights = weights.slice(0, weights.length - classifierWeightSize);
      const classifierWeights = weights.slice(weights.length - classifierWeightSize);
      this.faceFeatureExtractor.extractWeights(featureExtractorWeights);
      return this.extractClassifierParams(classifierWeights);
    }
  }

  // build/src/faceExpressionNet/FaceExpressions.js
  const FACE_EXPRESSION_LABELS = ["neutral", "happy", "sad", "angry", "fearful", "disgusted", "surprised"];
  class FaceExpressions {
    constructor(probabilities) {
      if (probabilities.length !== 7) {
        throw new Error(`FaceExpressions.constructor - expected probabilities.length to be 7, have: ${probabilities.length}`);
      }
      FACE_EXPRESSION_LABELS.forEach((expression, idx) => {
        this[expression] = probabilities[idx];
      });
    }
    asSortedArray() {
      return FACE_EXPRESSION_LABELS.map((expression) => ({expression, probability: this[expression]})).sort((e0, e1) => e1.probability - e0.probability);
    }
  }

  // build/src/faceExpressionNet/FaceExpressionNet.js
  class FaceExpressionNet extends FaceProcessor {
    constructor(faceFeatureExtractor = new FaceFeatureExtractor()) {
      super("FaceExpressionNet", faceFeatureExtractor);
    }
    forwardInput(input) {
      return tidy(() => softmax(this.runNet(input)));
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    async predictExpressions(input) {
      const netInput = await toNetInput(input);
      const out = await this.forwardInput(netInput);
      const probabilitesByBatch = await Promise.all(unstack(out).map(async (t) => {
        const data = await t.data();
        t.dispose();
        return data;
      }));
      out.dispose();
      const predictionsByBatch = probabilitesByBatch.map((probabilites) => new FaceExpressions(probabilites));
      return netInput.isBatchInput ? predictionsByBatch : predictionsByBatch[0];
    }
    getDefaultModelName() {
      return "face_expression_model";
    }
    getClassifierChannelsIn() {
      return 256;
    }
    getClassifierChannelsOut() {
      return 7;
    }
  }

  // build/src/faceExpressionNet/index.js

  // build/src/factories/WithFaceExpressions.js
  function isWithFaceExpressions(obj) {
    return obj["expressions"] instanceof FaceExpressions;
  }
  function extendWithFaceExpressions(sourceObj, expressions) {
    const extension = {expressions};
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/draw/drawFaceExpressions.js
  function drawFaceExpressions(canvasArg, faceExpressions, minConfidence = 0.1, textFieldAnchor) {
    const faceExpressionsArray = Array.isArray(faceExpressions) ? faceExpressions : [faceExpressions];
    faceExpressionsArray.forEach((e) => {
      const expr = e instanceof FaceExpressions ? e : isWithFaceExpressions(e) ? e.expressions : void 0;
      if (!expr) {
        throw new Error("drawFaceExpressions - expected faceExpressions to be FaceExpressions | WithFaceExpressions<{}> or array thereof");
      }
      const sorted = expr.asSortedArray();
      const resultsToDisplay = sorted.filter((expr2) => expr2.probability > minConfidence);
      const anchor = isWithFaceDetection(e) ? e.detection.box.bottomLeft : textFieldAnchor || new Point(0, 0);
      const drawTextField = new DrawTextField(resultsToDisplay.map((expr2) => `${expr2.expression} (${round3(expr2.probability)})`), anchor);
      drawTextField.draw(canvasArg);
    });
  }

  // build/src/factories/WithFaceLandmarks.js
  function isWithFaceLandmarks(obj) {
    return isWithFaceDetection(obj) && obj["landmarks"] instanceof FaceLandmarks && obj["unshiftedLandmarks"] instanceof FaceLandmarks && obj["alignedRect"] instanceof FaceDetection;
  }
  function extendWithFaceLandmarks(sourceObj, unshiftedLandmarks) {
    const {box: shift} = sourceObj.detection;
    const landmarks = unshiftedLandmarks.shiftBy(shift.x, shift.y);
    const rect = landmarks.align();
    const {imageDims} = sourceObj.detection;
    const alignedRect = new FaceDetection(sourceObj.detection.score, rect.rescale(imageDims.reverse()), imageDims);
    const extension = {
      landmarks,
      unshiftedLandmarks,
      alignedRect
    };
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/draw/DrawFaceLandmarks.js
  class DrawFaceLandmarksOptions {
    constructor(options = {}) {
      const {drawLines = true, drawPoints = true, lineWidth, lineColor, pointSize, pointColor} = options;
      this.drawLines = drawLines;
      this.drawPoints = drawPoints;
      this.lineWidth = lineWidth || 1;
      this.pointSize = pointSize || 2;
      this.lineColor = lineColor || "rgba(0, 255, 255, 1)";
      this.pointColor = pointColor || "rgba(255, 0, 255, 1)";
    }
  }
  class DrawFaceLandmarks {
    constructor(faceLandmarks, options = {}) {
      this.faceLandmarks = faceLandmarks;
      this.options = new DrawFaceLandmarksOptions(options);
    }
    draw(canvasArg) {
      const ctx = getContext2dOrThrow(canvasArg);
      const {drawLines, drawPoints, lineWidth, lineColor, pointSize, pointColor} = this.options;
      if (drawLines && this.faceLandmarks instanceof FaceLandmarks68) {
        ctx.strokeStyle = lineColor;
        ctx.lineWidth = lineWidth;
        drawContour(ctx, this.faceLandmarks.getJawOutline());
        drawContour(ctx, this.faceLandmarks.getLeftEyeBrow());
        drawContour(ctx, this.faceLandmarks.getRightEyeBrow());
        drawContour(ctx, this.faceLandmarks.getNose());
        drawContour(ctx, this.faceLandmarks.getLeftEye(), true);
        drawContour(ctx, this.faceLandmarks.getRightEye(), true);
        drawContour(ctx, this.faceLandmarks.getMouth(), true);
      }
      if (drawPoints) {
        ctx.strokeStyle = pointColor;
        ctx.fillStyle = pointColor;
        const drawPoint = (pt) => {
          ctx.beginPath();
          ctx.arc(pt.x, pt.y, pointSize, 0, 2 * Math.PI);
          ctx.fill();
        };
        this.faceLandmarks.positions.forEach(drawPoint);
      }
    }
  }
  function drawFaceLandmarks(canvasArg, faceLandmarks) {
    const faceLandmarksArray = Array.isArray(faceLandmarks) ? faceLandmarks : [faceLandmarks];
    faceLandmarksArray.forEach((f) => {
      const landmarks = f instanceof FaceLandmarks ? f : isWithFaceLandmarks(f) ? f.landmarks : void 0;
      if (!landmarks) {
        throw new Error("drawFaceLandmarks - expected faceExpressions to be FaceLandmarks | WithFaceLandmarks<WithFaceDetection<{}>> or array thereof");
      }
      new DrawFaceLandmarks(landmarks).draw(canvasArg);
    });
  }

  // build/src/draw/index.js
  const draw_exports = {};
  __export(draw_exports, {
    AnchorPosition: () => AnchorPosition,
    DrawBox: () => DrawBox,
    DrawBoxOptions: () => DrawBoxOptions,
    DrawFaceLandmarks: () => DrawFaceLandmarks,
    DrawFaceLandmarksOptions: () => DrawFaceLandmarksOptions,
    DrawTextField: () => DrawTextField,
    DrawTextFieldOptions: () => DrawTextFieldOptions,
    drawContour: () => drawContour,
    drawDetections: () => drawDetections,
    drawFaceExpressions: () => drawFaceExpressions,
    drawFaceLandmarks: () => drawFaceLandmarks
  });

  // build/src/xception/extractParams.js
  function extractorsFactory3(extractWeights, paramMappings) {
    const extractConvParams = extractConvParamsFactory(extractWeights, paramMappings);
    const extractSeparableConvParams = extractSeparableConvParamsFactory(extractWeights, paramMappings);
    function extractReductionBlockParams(channelsIn, channelsOut, mappedPrefix) {
      const separable_conv0 = extractSeparableConvParams(channelsIn, channelsOut, `${mappedPrefix}/separable_conv0`);
      const separable_conv1 = extractSeparableConvParams(channelsOut, channelsOut, `${mappedPrefix}/separable_conv1`);
      const expansion_conv = extractConvParams(channelsIn, channelsOut, 1, `${mappedPrefix}/expansion_conv`);
      return {separable_conv0, separable_conv1, expansion_conv};
    }
    function extractMainBlockParams(channels, mappedPrefix) {
      const separable_conv0 = extractSeparableConvParams(channels, channels, `${mappedPrefix}/separable_conv0`);
      const separable_conv1 = extractSeparableConvParams(channels, channels, `${mappedPrefix}/separable_conv1`);
      const separable_conv2 = extractSeparableConvParams(channels, channels, `${mappedPrefix}/separable_conv2`);
      return {separable_conv0, separable_conv1, separable_conv2};
    }
    return {
      extractConvParams,
      extractSeparableConvParams,
      extractReductionBlockParams,
      extractMainBlockParams
    };
  }
  function extractParams5(weights, numMainBlocks) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const {extractConvParams, extractSeparableConvParams, extractReductionBlockParams, extractMainBlockParams} = extractorsFactory3(extractWeights, paramMappings);
    const entry_flow_conv_in = extractConvParams(3, 32, 3, "entry_flow/conv_in");
    const entry_flow_reduction_block_0 = extractReductionBlockParams(32, 64, "entry_flow/reduction_block_0");
    const entry_flow_reduction_block_1 = extractReductionBlockParams(64, 128, "entry_flow/reduction_block_1");
    const entry_flow = {
      conv_in: entry_flow_conv_in,
      reduction_block_0: entry_flow_reduction_block_0,
      reduction_block_1: entry_flow_reduction_block_1
    };
    const middle_flow = {};
    range4(numMainBlocks, 0, 1).forEach((idx) => {
      middle_flow[`main_block_${idx}`] = extractMainBlockParams(128, `middle_flow/main_block_${idx}`);
    });
    const exit_flow_reduction_block = extractReductionBlockParams(128, 256, "exit_flow/reduction_block");
    const exit_flow_separable_conv = extractSeparableConvParams(256, 512, "exit_flow/separable_conv");
    const exit_flow = {
      reduction_block: exit_flow_reduction_block,
      separable_conv: exit_flow_separable_conv
    };
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      paramMappings,
      params: {entry_flow, middle_flow, exit_flow}
    };
  }

  // build/src/xception/extractParamsFromWeigthMap.js
  function loadParamsFactory3(weightMap, paramMappings) {
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    const extractConvParams = loadConvParamsFactory(extractWeightEntry);
    const extractSeparableConvParams = loadSeparableConvParamsFactory(extractWeightEntry);
    function extractReductionBlockParams(mappedPrefix) {
      const separable_conv0 = extractSeparableConvParams(`${mappedPrefix}/separable_conv0`);
      const separable_conv1 = extractSeparableConvParams(`${mappedPrefix}/separable_conv1`);
      const expansion_conv = extractConvParams(`${mappedPrefix}/expansion_conv`);
      return {separable_conv0, separable_conv1, expansion_conv};
    }
    function extractMainBlockParams(mappedPrefix) {
      const separable_conv0 = extractSeparableConvParams(`${mappedPrefix}/separable_conv0`);
      const separable_conv1 = extractSeparableConvParams(`${mappedPrefix}/separable_conv1`);
      const separable_conv2 = extractSeparableConvParams(`${mappedPrefix}/separable_conv2`);
      return {separable_conv0, separable_conv1, separable_conv2};
    }
    return {
      extractConvParams,
      extractSeparableConvParams,
      extractReductionBlockParams,
      extractMainBlockParams
    };
  }
  function extractParamsFromWeigthMap5(weightMap, numMainBlocks) {
    const paramMappings = [];
    const {extractConvParams, extractSeparableConvParams, extractReductionBlockParams, extractMainBlockParams} = loadParamsFactory3(weightMap, paramMappings);
    const entry_flow_conv_in = extractConvParams("entry_flow/conv_in");
    const entry_flow_reduction_block_0 = extractReductionBlockParams("entry_flow/reduction_block_0");
    const entry_flow_reduction_block_1 = extractReductionBlockParams("entry_flow/reduction_block_1");
    const entry_flow = {
      conv_in: entry_flow_conv_in,
      reduction_block_0: entry_flow_reduction_block_0,
      reduction_block_1: entry_flow_reduction_block_1
    };
    const middle_flow = {};
    range4(numMainBlocks, 0, 1).forEach((idx) => {
      middle_flow[`main_block_${idx}`] = extractMainBlockParams(`middle_flow/main_block_${idx}`);
    });
    const exit_flow_reduction_block = extractReductionBlockParams("exit_flow/reduction_block");
    const exit_flow_separable_conv = extractSeparableConvParams("exit_flow/separable_conv");
    const exit_flow = {
      reduction_block: exit_flow_reduction_block,
      separable_conv: exit_flow_separable_conv
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params: {entry_flow, middle_flow, exit_flow}, paramMappings};
  }

  // build/src/xception/TinyXception.js
  function conv(x, params, stride) {
    return add2(conv2d(x, params.filters, stride, "same"), params.bias);
  }
  function reductionBlock(x, params, isActivateInput = true) {
    let out = isActivateInput ? relu(x) : x;
    out = depthwiseSeparableConv(out, params.separable_conv0, [1, 1]);
    out = depthwiseSeparableConv(relu(out), params.separable_conv1, [1, 1]);
    out = maxPool(out, [3, 3], [2, 2], "same");
    out = add2(out, conv(x, params.expansion_conv, [2, 2]));
    return out;
  }
  function mainBlock(x, params) {
    let out = depthwiseSeparableConv(relu(x), params.separable_conv0, [1, 1]);
    out = depthwiseSeparableConv(relu(out), params.separable_conv1, [1, 1]);
    out = depthwiseSeparableConv(relu(out), params.separable_conv2, [1, 1]);
    out = add2(out, x);
    return out;
  }
  class TinyXception extends NeuralNetwork {
    constructor(numMainBlocks) {
      super("TinyXception");
      this._numMainBlocks = numMainBlocks;
    }
    forwardInput(input) {
      const {params} = this;
      if (!params) {
        throw new Error("TinyXception - load model before inference");
      }
      return tidy(() => {
        const batchTensor = input.toBatchTensor(112, true);
        const meanRgb = [122.782, 117.001, 104.298];
        const normalized = normalize(batchTensor, meanRgb).div(scalar(256));
        let out = relu(conv(normalized, params.entry_flow.conv_in, [2, 2]));
        out = reductionBlock(out, params.entry_flow.reduction_block_0, false);
        out = reductionBlock(out, params.entry_flow.reduction_block_1);
        range4(this._numMainBlocks, 0, 1).forEach((idx) => {
          out = mainBlock(out, params.middle_flow[`main_block_${idx}`]);
        });
        out = reductionBlock(out, params.exit_flow.reduction_block);
        out = relu(depthwiseSeparableConv(out, params.exit_flow.separable_conv, [1, 1]));
        return out;
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    getDefaultModelName() {
      return "tiny_xception_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMap5(weightMap, this._numMainBlocks);
    }
    extractParams(weights) {
      return extractParams5(weights, this._numMainBlocks);
    }
  }

  // build/src/ageGenderNet/extractParams.js
  function extractParams7(weights) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const extractFCParams = extractFCParamsFactory(extractWeights, paramMappings);
    const age = extractFCParams(512, 1, "fc/age");
    const gender = extractFCParams(512, 2, "fc/gender");
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      paramMappings,
      params: {fc: {age, gender}}
    };
  }

  // build/src/ageGenderNet/extractParamsFromWeigthMap.js
  function extractParamsFromWeigthMap7(weightMap) {
    const paramMappings = [];
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    function extractFcParams(prefix) {
      const weights = extractWeightEntry(`${prefix}/weights`, 2);
      const bias = extractWeightEntry(`${prefix}/bias`, 1);
      return {weights, bias};
    }
    const params = {
      fc: {
        age: extractFcParams("fc/age"),
        gender: extractFcParams("fc/gender")
      }
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/ageGenderNet/types.js
  var Gender;
  (function(Gender2) {
    Gender2["FEMALE"] = "female";
    Gender2["MALE"] = "male";
  })(Gender || (Gender = {}));

  // build/src/ageGenderNet/AgeGenderNet.js
  class AgeGenderNet extends NeuralNetwork {
    constructor(faceFeatureExtractor = new TinyXception(2)) {
      super("AgeGenderNet");
      this._faceFeatureExtractor = faceFeatureExtractor;
    }
    get faceFeatureExtractor() {
      return this._faceFeatureExtractor;
    }
    runNet(input) {
      const {params} = this;
      if (!params) {
        throw new Error(`${this._name} - load model before inference`);
      }
      return tidy(() => {
        const bottleneckFeatures = input instanceof NetInput ? this.faceFeatureExtractor.forwardInput(input) : input;
        const pooled = avgPool(bottleneckFeatures, [7, 7], [2, 2], "valid").as2D(bottleneckFeatures.shape[0], -1);
        const age = fullyConnectedLayer(pooled, params.fc.age).as1D();
        const gender = fullyConnectedLayer(pooled, params.fc.gender);
        return {age, gender};
      });
    }
    forwardInput(input) {
      return tidy(() => {
        const {age, gender} = this.runNet(input);
        return {age, gender: softmax(gender)};
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    async predictAgeAndGender(input) {
      const netInput = await toNetInput(input);
      const out = await this.forwardInput(netInput);
      const ages = unstack(out.age);
      const genders = unstack(out.gender);
      const ageAndGenderTensors = ages.map((ageTensor, i) => ({
        ageTensor,
        genderTensor: genders[i]
      }));
      const predictionsByBatch = await Promise.all(ageAndGenderTensors.map(async ({ageTensor, genderTensor}) => {
        const age = (await ageTensor.data())[0];
        const probMale = (await genderTensor.data())[0];
        const isMale = probMale > 0.5;
        const gender = isMale ? Gender.MALE : Gender.FEMALE;
        const genderProbability = isMale ? probMale : 1 - probMale;
        ageTensor.dispose();
        genderTensor.dispose();
        return {age, gender, genderProbability};
      }));
      out.age.dispose();
      out.gender.dispose();
      return netInput.isBatchInput ? predictionsByBatch : predictionsByBatch[0];
    }
    getDefaultModelName() {
      return "age_gender_model";
    }
    dispose(throwOnRedispose = true) {
      this.faceFeatureExtractor.dispose(throwOnRedispose);
      super.dispose(throwOnRedispose);
    }
    loadClassifierParams(weights) {
      const {params, paramMappings} = this.extractClassifierParams(weights);
      this._params = params;
      this._paramMappings = paramMappings;
    }
    extractClassifierParams(weights) {
      return extractParams7(weights);
    }
    extractParamsFromWeigthMap(weightMap) {
      const {featureExtractorMap, classifierMap} = seperateWeightMaps(weightMap);
      this.faceFeatureExtractor.loadFromWeightMap(featureExtractorMap);
      return extractParamsFromWeigthMap7(classifierMap);
    }
    extractParams(weights) {
      const classifierWeightSize = 512 * 1 + 1 + (512 * 2 + 2);
      const featureExtractorWeights = weights.slice(0, weights.length - classifierWeightSize);
      const classifierWeights = weights.slice(weights.length - classifierWeightSize);
      this.faceFeatureExtractor.extractWeights(featureExtractorWeights);
      return this.extractClassifierParams(classifierWeights);
    }
  }

  // build/src/ageGenderNet/index.js

  // build/src/faceLandmarkNet/FaceLandmark68NetBase.js
  class FaceLandmark68NetBase extends FaceProcessor {
    postProcess(output, inputSize, originalDimensions) {
      const inputDimensions = originalDimensions.map(({width, height}) => {
        const scale2 = inputSize / Math.max(height, width);
        return {
          width: width * scale2,
          height: height * scale2
        };
      });
      const batchSize = inputDimensions.length;
      return tidy(() => {
        const createInterleavedTensor = (fillX, fillY) => stack([
          fill([68], fillX),
          fill([68], fillY)
        ], 1).as2D(1, 136).as1D();
        const getPadding = (batchIdx, cond) => {
          const {width, height} = inputDimensions[batchIdx];
          return cond(width, height) ? Math.abs(width - height) / 2 : 0;
        };
        const getPaddingX = (batchIdx) => getPadding(batchIdx, (w, h) => w < h);
        const getPaddingY = (batchIdx) => getPadding(batchIdx, (w, h) => h < w);
        const landmarkTensors = output.mul(fill([batchSize, 136], inputSize)).sub(stack(Array.from(Array(batchSize), (_, batchIdx) => createInterleavedTensor(getPaddingX(batchIdx), getPaddingY(batchIdx))))).div(stack(Array.from(Array(batchSize), (_, batchIdx) => createInterleavedTensor(inputDimensions[batchIdx].width, inputDimensions[batchIdx].height))));
        return landmarkTensors;
      });
    }
    forwardInput(input) {
      return tidy(() => {
        const out = this.runNet(input);
        return this.postProcess(out, input.inputSize, input.inputDimensions.map(([height, width]) => ({height, width})));
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    async detectLandmarks(input) {
      const netInput = await toNetInput(input);
      const landmarkTensors = tidy(() => unstack(this.forwardInput(netInput)));
      const landmarksForBatch = await Promise.all(landmarkTensors.map(async (landmarkTensor, batchIdx) => {
        const landmarksArray = Array.from(await landmarkTensor.data());
        const xCoords = landmarksArray.filter((_, i) => isEven(i));
        const yCoords = landmarksArray.filter((_, i) => !isEven(i));
        return new FaceLandmarks68(Array(68).fill(0).map((_, i) => new Point(xCoords[i], yCoords[i])), {
          height: netInput.getInputHeight(batchIdx),
          width: netInput.getInputWidth(batchIdx)
        });
      }));
      landmarkTensors.forEach((t) => t.dispose());
      return netInput.isBatchInput ? landmarksForBatch : landmarksForBatch[0];
    }
    getClassifierChannelsOut() {
      return 136;
    }
  }

  // build/src/faceLandmarkNet/FaceLandmark68Net.js
  class FaceLandmark68Net extends FaceLandmark68NetBase {
    constructor(faceFeatureExtractor = new FaceFeatureExtractor()) {
      super("FaceLandmark68Net", faceFeatureExtractor);
    }
    getDefaultModelName() {
      return "face_landmark_68_model";
    }
    getClassifierChannelsIn() {
      return 256;
    }
  }

  // build/src/faceFeatureExtractor/extractParamsFromWeigthMapTiny.js
  function extractParamsFromWeigthMapTiny(weightMap) {
    const paramMappings = [];
    const {extractDenseBlock3Params} = loadParamsFactory(weightMap, paramMappings);
    const params = {
      dense0: extractDenseBlock3Params("dense0", true),
      dense1: extractDenseBlock3Params("dense1"),
      dense2: extractDenseBlock3Params("dense2")
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/faceFeatureExtractor/extractParamsTiny.js
  function extractParamsTiny(weights) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const {extractDenseBlock3Params} = extractorsFactory(extractWeights, paramMappings);
    const dense0 = extractDenseBlock3Params(3, 32, "dense0", true);
    const dense1 = extractDenseBlock3Params(32, 64, "dense1");
    const dense2 = extractDenseBlock3Params(64, 128, "dense2");
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      paramMappings,
      params: {dense0, dense1, dense2}
    };
  }

  // build/src/faceFeatureExtractor/TinyFaceFeatureExtractor.js
  class TinyFaceFeatureExtractor extends NeuralNetwork {
    constructor() {
      super("TinyFaceFeatureExtractor");
    }
    forwardInput(input) {
      const {params} = this;
      if (!params) {
        throw new Error("TinyFaceFeatureExtractor - load model before inference");
      }
      return tidy(() => {
        const batchTensor = input.toBatchTensor(112, true);
        const meanRgb = [122.782, 117.001, 104.298];
        const normalized = normalize(batchTensor, meanRgb).div(scalar(255));
        let out = denseBlock3(normalized, params.dense0, true);
        out = denseBlock3(out, params.dense1);
        out = denseBlock3(out, params.dense2);
        out = avgPool(out, [14, 14], [2, 2], "valid");
        return out;
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    getDefaultModelName() {
      return "face_feature_extractor_tiny_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMapTiny(weightMap);
    }
    extractParams(weights) {
      return extractParamsTiny(weights);
    }
  }

  // build/src/faceLandmarkNet/FaceLandmark68TinyNet.js
  class FaceLandmark68TinyNet extends FaceLandmark68NetBase {
    constructor(faceFeatureExtractor = new TinyFaceFeatureExtractor()) {
      super("FaceLandmark68TinyNet", faceFeatureExtractor);
    }
    getDefaultModelName() {
      return "face_landmark_68_tiny_model";
    }
    getClassifierChannelsIn() {
      return 128;
    }
  }

  // build/src/faceLandmarkNet/index.js
  class FaceLandmarkNet extends FaceLandmark68Net {
  }

  // build/src/faceRecognitionNet/scaleLayer.js
  function scale(x, params) {
    return add2(mul(x, params.weights), params.biases);
  }

  // build/src/faceRecognitionNet/convLayer.js
  function convLayer2(x, params, strides, withRelu, padding = "same") {
    const {filters, bias} = params.conv;
    let out = conv2d(x, filters, strides, padding);
    out = add2(out, bias);
    out = scale(out, params.scale);
    return withRelu ? relu(out) : out;
  }
  function conv2(x, params) {
    return convLayer2(x, params, [1, 1], true);
  }
  function convNoRelu(x, params) {
    return convLayer2(x, params, [1, 1], false);
  }
  function convDown(x, params) {
    return convLayer2(x, params, [2, 2], true, "valid");
  }

  // build/src/faceRecognitionNet/extractParams.js
  function extractorsFactory5(extractWeights, paramMappings) {
    function extractFilterValues(numFilterValues, numFilters, filterSize) {
      const weights = extractWeights(numFilterValues);
      const depth = weights.length / (numFilters * filterSize * filterSize);
      if (isFloat(depth)) {
        throw new Error(`depth has to be an integer: ${depth}, weights.length: ${weights.length}, numFilters: ${numFilters}, filterSize: ${filterSize}`);
      }
      return tidy(() => transpose(tensor4d(weights, [numFilters, depth, filterSize, filterSize]), [2, 3, 1, 0]));
    }
    function extractConvParams(numFilterValues, numFilters, filterSize, mappedPrefix) {
      const filters = extractFilterValues(numFilterValues, numFilters, filterSize);
      const bias = tensor1d(extractWeights(numFilters));
      paramMappings.push({paramPath: `${mappedPrefix}/filters`}, {paramPath: `${mappedPrefix}/bias`});
      return {filters, bias};
    }
    function extractScaleLayerParams(numWeights, mappedPrefix) {
      const weights = tensor1d(extractWeights(numWeights));
      const biases = tensor1d(extractWeights(numWeights));
      paramMappings.push({paramPath: `${mappedPrefix}/weights`}, {paramPath: `${mappedPrefix}/biases`});
      return {
        weights,
        biases
      };
    }
    function extractConvLayerParams(numFilterValues, numFilters, filterSize, mappedPrefix) {
      const conv3 = extractConvParams(numFilterValues, numFilters, filterSize, `${mappedPrefix}/conv`);
      const scale2 = extractScaleLayerParams(numFilters, `${mappedPrefix}/scale`);
      return {conv: conv3, scale: scale2};
    }
    function extractResidualLayerParams(numFilterValues, numFilters, filterSize, mappedPrefix, isDown = false) {
      const conv1 = extractConvLayerParams((isDown ? 0.5 : 1) * numFilterValues, numFilters, filterSize, `${mappedPrefix}/conv1`);
      const conv22 = extractConvLayerParams(numFilterValues, numFilters, filterSize, `${mappedPrefix}/conv2`);
      return {conv1, conv2: conv22};
    }
    return {
      extractConvLayerParams,
      extractResidualLayerParams
    };
  }
  function extractParams9(weights) {
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const paramMappings = [];
    const {extractConvLayerParams, extractResidualLayerParams} = extractorsFactory5(extractWeights, paramMappings);
    const conv32_down = extractConvLayerParams(4704, 32, 7, "conv32_down");
    const conv32_1 = extractResidualLayerParams(9216, 32, 3, "conv32_1");
    const conv32_2 = extractResidualLayerParams(9216, 32, 3, "conv32_2");
    const conv32_3 = extractResidualLayerParams(9216, 32, 3, "conv32_3");
    const conv64_down = extractResidualLayerParams(36864, 64, 3, "conv64_down", true);
    const conv64_1 = extractResidualLayerParams(36864, 64, 3, "conv64_1");
    const conv64_2 = extractResidualLayerParams(36864, 64, 3, "conv64_2");
    const conv64_3 = extractResidualLayerParams(36864, 64, 3, "conv64_3");
    const conv128_down = extractResidualLayerParams(147456, 128, 3, "conv128_down", true);
    const conv128_1 = extractResidualLayerParams(147456, 128, 3, "conv128_1");
    const conv128_2 = extractResidualLayerParams(147456, 128, 3, "conv128_2");
    const conv256_down = extractResidualLayerParams(589824, 256, 3, "conv256_down", true);
    const conv256_1 = extractResidualLayerParams(589824, 256, 3, "conv256_1");
    const conv256_2 = extractResidualLayerParams(589824, 256, 3, "conv256_2");
    const conv256_down_out = extractResidualLayerParams(589824, 256, 3, "conv256_down_out");
    const fc = tidy(() => transpose(tensor2d(extractWeights(256 * 128), [128, 256]), [1, 0]));
    paramMappings.push({paramPath: `fc`});
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    const params = {
      conv32_down,
      conv32_1,
      conv32_2,
      conv32_3,
      conv64_down,
      conv64_1,
      conv64_2,
      conv64_3,
      conv128_down,
      conv128_1,
      conv128_2,
      conv256_down,
      conv256_1,
      conv256_2,
      conv256_down_out,
      fc
    };
    return {params, paramMappings};
  }

  // build/src/faceRecognitionNet/extractParamsFromWeigthMap.js
  function extractorsFactory6(weightMap, paramMappings) {
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    function extractScaleLayerParams(prefix) {
      const weights = extractWeightEntry(`${prefix}/scale/weights`, 1);
      const biases = extractWeightEntry(`${prefix}/scale/biases`, 1);
      return {weights, biases};
    }
    function extractConvLayerParams(prefix) {
      const filters = extractWeightEntry(`${prefix}/conv/filters`, 4);
      const bias = extractWeightEntry(`${prefix}/conv/bias`, 1);
      const scale2 = extractScaleLayerParams(prefix);
      return {conv: {filters, bias}, scale: scale2};
    }
    function extractResidualLayerParams(prefix) {
      return {
        conv1: extractConvLayerParams(`${prefix}/conv1`),
        conv2: extractConvLayerParams(`${prefix}/conv2`)
      };
    }
    return {
      extractConvLayerParams,
      extractResidualLayerParams
    };
  }
  function extractParamsFromWeigthMap9(weightMap) {
    const paramMappings = [];
    const {extractConvLayerParams, extractResidualLayerParams} = extractorsFactory6(weightMap, paramMappings);
    const conv32_down = extractConvLayerParams("conv32_down");
    const conv32_1 = extractResidualLayerParams("conv32_1");
    const conv32_2 = extractResidualLayerParams("conv32_2");
    const conv32_3 = extractResidualLayerParams("conv32_3");
    const conv64_down = extractResidualLayerParams("conv64_down");
    const conv64_1 = extractResidualLayerParams("conv64_1");
    const conv64_2 = extractResidualLayerParams("conv64_2");
    const conv64_3 = extractResidualLayerParams("conv64_3");
    const conv128_down = extractResidualLayerParams("conv128_down");
    const conv128_1 = extractResidualLayerParams("conv128_1");
    const conv128_2 = extractResidualLayerParams("conv128_2");
    const conv256_down = extractResidualLayerParams("conv256_down");
    const conv256_1 = extractResidualLayerParams("conv256_1");
    const conv256_2 = extractResidualLayerParams("conv256_2");
    const conv256_down_out = extractResidualLayerParams("conv256_down_out");
    const fc = weightMap["fc"];
    paramMappings.push({originalPath: "fc", paramPath: "fc"});
    if (!isTensor2D(fc)) {
      throw new Error(`expected weightMap[fc] to be a Tensor2D, instead have ${fc}`);
    }
    const params = {
      conv32_down,
      conv32_1,
      conv32_2,
      conv32_3,
      conv64_down,
      conv64_1,
      conv64_2,
      conv64_3,
      conv128_down,
      conv128_1,
      conv128_2,
      conv256_down,
      conv256_1,
      conv256_2,
      conv256_down_out,
      fc
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/faceRecognitionNet/residualLayer.js
  function residual(x, params) {
    let out = conv2(x, params.conv1);
    out = convNoRelu(out, params.conv2);
    out = add2(out, x);
    out = relu(out);
    return out;
  }
  function residualDown(x, params) {
    let out = convDown(x, params.conv1);
    out = convNoRelu(out, params.conv2);
    let pooled = avgPool(x, 2, 2, "valid");
    const zeros9 = zeros(pooled.shape);
    const isPad = pooled.shape[3] !== out.shape[3];
    const isAdjustShape = pooled.shape[1] !== out.shape[1] || pooled.shape[2] !== out.shape[2];
    if (isAdjustShape) {
      const padShapeX = [...out.shape];
      padShapeX[1] = 1;
      const zerosW = zeros(padShapeX);
      out = concat([out, zerosW], 1);
      const padShapeY = [...out.shape];
      padShapeY[2] = 1;
      const zerosH = zeros(padShapeY);
      out = concat([out, zerosH], 2);
    }
    pooled = isPad ? concat([pooled, zeros9], 3) : pooled;
    out = add2(pooled, out);
    out = relu(out);
    return out;
  }

  // build/src/faceRecognitionNet/FaceRecognitionNet.js
  class FaceRecognitionNet extends NeuralNetwork {
    constructor() {
      super("FaceRecognitionNet");
    }
    forwardInput(input) {
      const {params} = this;
      if (!params) {
        throw new Error("FaceRecognitionNet - load model before inference");
      }
      return tidy(() => {
        const batchTensor = cast(input.toBatchTensor(150, true), "float32");
        const meanRgb = [122.782, 117.001, 104.298];
        const normalized = normalize(batchTensor, meanRgb).div(scalar(256));
        let out = convDown(normalized, params.conv32_down);
        out = maxPool(out, 3, 2, "valid");
        out = residual(out, params.conv32_1);
        out = residual(out, params.conv32_2);
        out = residual(out, params.conv32_3);
        out = residualDown(out, params.conv64_down);
        out = residual(out, params.conv64_1);
        out = residual(out, params.conv64_2);
        out = residual(out, params.conv64_3);
        out = residualDown(out, params.conv128_down);
        out = residual(out, params.conv128_1);
        out = residual(out, params.conv128_2);
        out = residualDown(out, params.conv256_down);
        out = residual(out, params.conv256_1);
        out = residual(out, params.conv256_2);
        out = residualDown(out, params.conv256_down_out);
        const globalAvg = out.mean([1, 2]);
        const fullyConnected = matMul(globalAvg, params.fc);
        return fullyConnected;
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    async computeFaceDescriptor(input) {
      const netInput = await toNetInput(input);
      const faceDescriptorTensors = tidy(() => unstack(this.forwardInput(netInput)));
      const faceDescriptorsForBatch = await Promise.all(faceDescriptorTensors.map((t) => t.data()));
      faceDescriptorTensors.forEach((t) => t.dispose());
      return netInput.isBatchInput ? faceDescriptorsForBatch : faceDescriptorsForBatch[0];
    }
    getDefaultModelName() {
      return "face_recognition_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMap9(weightMap);
    }
    extractParams(weights) {
      return extractParams9(weights);
    }
  }

  // build/src/faceRecognitionNet/index.js
  function createFaceRecognitionNet(weights) {
    const net = new FaceRecognitionNet();
    net.extractWeights(weights);
    return net;
  }

  // build/src/factories/WithFaceDescriptor.js
  function extendWithFaceDescriptor(sourceObj, descriptor) {
    const extension = {descriptor};
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/factories/WithAge.js
  function isWithAge(obj) {
    return typeof obj["age"] === "number";
  }
  function extendWithAge(sourceObj, age) {
    const extension = {age};
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/factories/WithGender.js
  function isWithGender(obj) {
    return (obj["gender"] === Gender.MALE || obj["gender"] === Gender.FEMALE) && isValidProbablitiy(obj["genderProbability"]);
  }
  function extendWithGender(sourceObj, gender, genderProbability) {
    const extension = {gender, genderProbability};
    return Object.assign({}, sourceObj, extension);
  }

  // build/src/factories/index.js

  // build/src/ssdMobilenetv1/extractParams.js
  function extractorsFactory7(extractWeights, paramMappings) {
    function extractDepthwiseConvParams(numChannels, mappedPrefix) {
      const filters = tensor4d(extractWeights(3 * 3 * numChannels), [3, 3, numChannels, 1]);
      const batch_norm_scale = tensor1d(extractWeights(numChannels));
      const batch_norm_offset = tensor1d(extractWeights(numChannels));
      const batch_norm_mean = tensor1d(extractWeights(numChannels));
      const batch_norm_variance = tensor1d(extractWeights(numChannels));
      paramMappings.push({paramPath: `${mappedPrefix}/filters`}, {paramPath: `${mappedPrefix}/batch_norm_scale`}, {paramPath: `${mappedPrefix}/batch_norm_offset`}, {paramPath: `${mappedPrefix}/batch_norm_mean`}, {paramPath: `${mappedPrefix}/batch_norm_variance`});
      return {
        filters,
        batch_norm_scale,
        batch_norm_offset,
        batch_norm_mean,
        batch_norm_variance
      };
    }
    function extractConvParams(channelsIn, channelsOut, filterSize, mappedPrefix, isPointwiseConv) {
      const filters = tensor4d(extractWeights(channelsIn * channelsOut * filterSize * filterSize), [filterSize, filterSize, channelsIn, channelsOut]);
      const bias = tensor1d(extractWeights(channelsOut));
      paramMappings.push({paramPath: `${mappedPrefix}/filters`}, {paramPath: `${mappedPrefix}/${isPointwiseConv ? "batch_norm_offset" : "bias"}`});
      return {filters, bias};
    }
    function extractPointwiseConvParams(channelsIn, channelsOut, filterSize, mappedPrefix) {
      const {filters, bias} = extractConvParams(channelsIn, channelsOut, filterSize, mappedPrefix, true);
      return {
        filters,
        batch_norm_offset: bias
      };
    }
    function extractConvPairParams(channelsIn, channelsOut, mappedPrefix) {
      const depthwise_conv = extractDepthwiseConvParams(channelsIn, `${mappedPrefix}/depthwise_conv`);
      const pointwise_conv = extractPointwiseConvParams(channelsIn, channelsOut, 1, `${mappedPrefix}/pointwise_conv`);
      return {depthwise_conv, pointwise_conv};
    }
    function extractMobilenetV1Params() {
      const conv_0 = extractPointwiseConvParams(3, 32, 3, "mobilenetv1/conv_0");
      const conv_1 = extractConvPairParams(32, 64, "mobilenetv1/conv_1");
      const conv_2 = extractConvPairParams(64, 128, "mobilenetv1/conv_2");
      const conv_3 = extractConvPairParams(128, 128, "mobilenetv1/conv_3");
      const conv_4 = extractConvPairParams(128, 256, "mobilenetv1/conv_4");
      const conv_5 = extractConvPairParams(256, 256, "mobilenetv1/conv_5");
      const conv_6 = extractConvPairParams(256, 512, "mobilenetv1/conv_6");
      const conv_7 = extractConvPairParams(512, 512, "mobilenetv1/conv_7");
      const conv_8 = extractConvPairParams(512, 512, "mobilenetv1/conv_8");
      const conv_9 = extractConvPairParams(512, 512, "mobilenetv1/conv_9");
      const conv_10 = extractConvPairParams(512, 512, "mobilenetv1/conv_10");
      const conv_11 = extractConvPairParams(512, 512, "mobilenetv1/conv_11");
      const conv_12 = extractConvPairParams(512, 1024, "mobilenetv1/conv_12");
      const conv_13 = extractConvPairParams(1024, 1024, "mobilenetv1/conv_13");
      return {
        conv_0,
        conv_1,
        conv_2,
        conv_3,
        conv_4,
        conv_5,
        conv_6,
        conv_7,
        conv_8,
        conv_9,
        conv_10,
        conv_11,
        conv_12,
        conv_13
      };
    }
    function extractPredictionLayerParams() {
      const conv_0 = extractPointwiseConvParams(1024, 256, 1, "prediction_layer/conv_0");
      const conv_1 = extractPointwiseConvParams(256, 512, 3, "prediction_layer/conv_1");
      const conv_2 = extractPointwiseConvParams(512, 128, 1, "prediction_layer/conv_2");
      const conv_3 = extractPointwiseConvParams(128, 256, 3, "prediction_layer/conv_3");
      const conv_4 = extractPointwiseConvParams(256, 128, 1, "prediction_layer/conv_4");
      const conv_5 = extractPointwiseConvParams(128, 256, 3, "prediction_layer/conv_5");
      const conv_6 = extractPointwiseConvParams(256, 64, 1, "prediction_layer/conv_6");
      const conv_7 = extractPointwiseConvParams(64, 128, 3, "prediction_layer/conv_7");
      const box_encoding_0_predictor = extractConvParams(512, 12, 1, "prediction_layer/box_predictor_0/box_encoding_predictor");
      const class_predictor_0 = extractConvParams(512, 9, 1, "prediction_layer/box_predictor_0/class_predictor");
      const box_encoding_1_predictor = extractConvParams(1024, 24, 1, "prediction_layer/box_predictor_1/box_encoding_predictor");
      const class_predictor_1 = extractConvParams(1024, 18, 1, "prediction_layer/box_predictor_1/class_predictor");
      const box_encoding_2_predictor = extractConvParams(512, 24, 1, "prediction_layer/box_predictor_2/box_encoding_predictor");
      const class_predictor_2 = extractConvParams(512, 18, 1, "prediction_layer/box_predictor_2/class_predictor");
      const box_encoding_3_predictor = extractConvParams(256, 24, 1, "prediction_layer/box_predictor_3/box_encoding_predictor");
      const class_predictor_3 = extractConvParams(256, 18, 1, "prediction_layer/box_predictor_3/class_predictor");
      const box_encoding_4_predictor = extractConvParams(256, 24, 1, "prediction_layer/box_predictor_4/box_encoding_predictor");
      const class_predictor_4 = extractConvParams(256, 18, 1, "prediction_layer/box_predictor_4/class_predictor");
      const box_encoding_5_predictor = extractConvParams(128, 24, 1, "prediction_layer/box_predictor_5/box_encoding_predictor");
      const class_predictor_5 = extractConvParams(128, 18, 1, "prediction_layer/box_predictor_5/class_predictor");
      const box_predictor_0 = {
        box_encoding_predictor: box_encoding_0_predictor,
        class_predictor: class_predictor_0
      };
      const box_predictor_1 = {
        box_encoding_predictor: box_encoding_1_predictor,
        class_predictor: class_predictor_1
      };
      const box_predictor_2 = {
        box_encoding_predictor: box_encoding_2_predictor,
        class_predictor: class_predictor_2
      };
      const box_predictor_3 = {
        box_encoding_predictor: box_encoding_3_predictor,
        class_predictor: class_predictor_3
      };
      const box_predictor_4 = {
        box_encoding_predictor: box_encoding_4_predictor,
        class_predictor: class_predictor_4
      };
      const box_predictor_5 = {
        box_encoding_predictor: box_encoding_5_predictor,
        class_predictor: class_predictor_5
      };
      return {
        conv_0,
        conv_1,
        conv_2,
        conv_3,
        conv_4,
        conv_5,
        conv_6,
        conv_7,
        box_predictor_0,
        box_predictor_1,
        box_predictor_2,
        box_predictor_3,
        box_predictor_4,
        box_predictor_5
      };
    }
    return {
      extractMobilenetV1Params,
      extractPredictionLayerParams
    };
  }
  function extractParams11(weights) {
    const paramMappings = [];
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const {extractMobilenetV1Params, extractPredictionLayerParams} = extractorsFactory7(extractWeights, paramMappings);
    const mobilenetv1 = extractMobilenetV1Params();
    const prediction_layer = extractPredictionLayerParams();
    const extra_dim = tensor3d(extractWeights(5118 * 4), [1, 5118, 4]);
    const output_layer = {
      extra_dim
    };
    paramMappings.push({paramPath: "output_layer/extra_dim"});
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {
      params: {
        mobilenetv1,
        prediction_layer,
        output_layer
      },
      paramMappings
    };
  }

  // build/src/ssdMobilenetv1/extractParamsFromWeigthMap.js
  function extractorsFactory8(weightMap, paramMappings) {
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    function extractPointwiseConvParams(prefix, idx, mappedPrefix) {
      const filters = extractWeightEntry(`${prefix}/Conv2d_${idx}_pointwise/weights`, 4, `${mappedPrefix}/filters`);
      const batch_norm_offset = extractWeightEntry(`${prefix}/Conv2d_${idx}_pointwise/convolution_bn_offset`, 1, `${mappedPrefix}/batch_norm_offset`);
      return {filters, batch_norm_offset};
    }
    function extractConvPairParams(idx) {
      const mappedPrefix = `mobilenetv1/conv_${idx}`;
      const prefixDepthwiseConv = `MobilenetV1/Conv2d_${idx}_depthwise`;
      const mappedPrefixDepthwiseConv = `${mappedPrefix}/depthwise_conv`;
      const mappedPrefixPointwiseConv = `${mappedPrefix}/pointwise_conv`;
      const filters = extractWeightEntry(`${prefixDepthwiseConv}/depthwise_weights`, 4, `${mappedPrefixDepthwiseConv}/filters`);
      const batch_norm_scale = extractWeightEntry(`${prefixDepthwiseConv}/BatchNorm/gamma`, 1, `${mappedPrefixDepthwiseConv}/batch_norm_scale`);
      const batch_norm_offset = extractWeightEntry(`${prefixDepthwiseConv}/BatchNorm/beta`, 1, `${mappedPrefixDepthwiseConv}/batch_norm_offset`);
      const batch_norm_mean = extractWeightEntry(`${prefixDepthwiseConv}/BatchNorm/moving_mean`, 1, `${mappedPrefixDepthwiseConv}/batch_norm_mean`);
      const batch_norm_variance = extractWeightEntry(`${prefixDepthwiseConv}/BatchNorm/moving_variance`, 1, `${mappedPrefixDepthwiseConv}/batch_norm_variance`);
      return {
        depthwise_conv: {
          filters,
          batch_norm_scale,
          batch_norm_offset,
          batch_norm_mean,
          batch_norm_variance
        },
        pointwise_conv: extractPointwiseConvParams("MobilenetV1", idx, mappedPrefixPointwiseConv)
      };
    }
    function extractMobilenetV1Params() {
      return {
        conv_0: extractPointwiseConvParams("MobilenetV1", 0, "mobilenetv1/conv_0"),
        conv_1: extractConvPairParams(1),
        conv_2: extractConvPairParams(2),
        conv_3: extractConvPairParams(3),
        conv_4: extractConvPairParams(4),
        conv_5: extractConvPairParams(5),
        conv_6: extractConvPairParams(6),
        conv_7: extractConvPairParams(7),
        conv_8: extractConvPairParams(8),
        conv_9: extractConvPairParams(9),
        conv_10: extractConvPairParams(10),
        conv_11: extractConvPairParams(11),
        conv_12: extractConvPairParams(12),
        conv_13: extractConvPairParams(13)
      };
    }
    function extractConvParams(prefix, mappedPrefix) {
      const filters = extractWeightEntry(`${prefix}/weights`, 4, `${mappedPrefix}/filters`);
      const bias = extractWeightEntry(`${prefix}/biases`, 1, `${mappedPrefix}/bias`);
      return {filters, bias};
    }
    function extractBoxPredictorParams(idx) {
      const box_encoding_predictor = extractConvParams(`Prediction/BoxPredictor_${idx}/BoxEncodingPredictor`, `prediction_layer/box_predictor_${idx}/box_encoding_predictor`);
      const class_predictor = extractConvParams(`Prediction/BoxPredictor_${idx}/ClassPredictor`, `prediction_layer/box_predictor_${idx}/class_predictor`);
      return {box_encoding_predictor, class_predictor};
    }
    function extractPredictionLayerParams() {
      return {
        conv_0: extractPointwiseConvParams("Prediction", 0, "prediction_layer/conv_0"),
        conv_1: extractPointwiseConvParams("Prediction", 1, "prediction_layer/conv_1"),
        conv_2: extractPointwiseConvParams("Prediction", 2, "prediction_layer/conv_2"),
        conv_3: extractPointwiseConvParams("Prediction", 3, "prediction_layer/conv_3"),
        conv_4: extractPointwiseConvParams("Prediction", 4, "prediction_layer/conv_4"),
        conv_5: extractPointwiseConvParams("Prediction", 5, "prediction_layer/conv_5"),
        conv_6: extractPointwiseConvParams("Prediction", 6, "prediction_layer/conv_6"),
        conv_7: extractPointwiseConvParams("Prediction", 7, "prediction_layer/conv_7"),
        box_predictor_0: extractBoxPredictorParams(0),
        box_predictor_1: extractBoxPredictorParams(1),
        box_predictor_2: extractBoxPredictorParams(2),
        box_predictor_3: extractBoxPredictorParams(3),
        box_predictor_4: extractBoxPredictorParams(4),
        box_predictor_5: extractBoxPredictorParams(5)
      };
    }
    return {
      extractMobilenetV1Params,
      extractPredictionLayerParams
    };
  }
  function extractParamsFromWeigthMap11(weightMap) {
    const paramMappings = [];
    const {extractMobilenetV1Params, extractPredictionLayerParams} = extractorsFactory8(weightMap, paramMappings);
    const extra_dim = weightMap["Output/extra_dim"];
    paramMappings.push({originalPath: "Output/extra_dim", paramPath: "output_layer/extra_dim"});
    if (!isTensor3D(extra_dim)) {
      throw new Error(`expected weightMap['Output/extra_dim'] to be a Tensor3D, instead have ${extra_dim}`);
    }
    const params = {
      mobilenetv1: extractMobilenetV1Params(),
      prediction_layer: extractPredictionLayerParams(),
      output_layer: {
        extra_dim
      }
    };
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/ssdMobilenetv1/pointwiseConvLayer.js
  function pointwiseConvLayer(x, params, strides) {
    return tidy(() => {
      let out = conv2d(x, params.filters, strides, "same");
      out = add2(out, params.batch_norm_offset);
      return clipByValue(out, 0, 6);
    });
  }

  // build/src/ssdMobilenetv1/mobileNetV1.js
  const epsilon = 0.0010000000474974513;
  function depthwiseConvLayer(x, params, strides) {
    return tidy(() => {
      let out = depthwiseConv2d(x, params.filters, strides, "same");
      out = batchNorm(out, params.batch_norm_mean, params.batch_norm_variance, params.batch_norm_offset, params.batch_norm_scale, epsilon);
      return clipByValue(out, 0, 6);
    });
  }
  function getStridesForLayerIdx(layerIdx) {
    return [2, 4, 6, 12].some((idx) => idx === layerIdx) ? [2, 2] : [1, 1];
  }
  function mobileNetV1(x, params) {
    return tidy(() => {
      let conv11;
      let out = pointwiseConvLayer(x, params.conv_0, [2, 2]);
      const convPairParams = [
        params.conv_1,
        params.conv_2,
        params.conv_3,
        params.conv_4,
        params.conv_5,
        params.conv_6,
        params.conv_7,
        params.conv_8,
        params.conv_9,
        params.conv_10,
        params.conv_11,
        params.conv_12,
        params.conv_13
      ];
      convPairParams.forEach((param, i) => {
        const layerIdx = i + 1;
        const depthwiseConvStrides = getStridesForLayerIdx(layerIdx);
        out = depthwiseConvLayer(out, param.depthwise_conv, depthwiseConvStrides);
        out = pointwiseConvLayer(out, param.pointwise_conv, [1, 1]);
        if (layerIdx === 11) {
          conv11 = out;
        }
      });
      if (conv11 === null) {
        throw new Error("mobileNetV1 - output of conv layer 11 is null");
      }
      return {
        out,
        conv11
      };
    });
  }

  // build/src/ssdMobilenetv1/nonMaxSuppression.js
  function nonMaxSuppression3(boxes, scores, maxOutputSize, iouThreshold, scoreThreshold) {
    const numBoxes = boxes.shape[0];
    const outputSize = Math.min(maxOutputSize, numBoxes);
    const candidates = scores.map((score, boxIndex) => ({score, boxIndex})).filter((c) => c.score > scoreThreshold).sort((c1, c2) => c2.score - c1.score);
    const suppressFunc = (x) => x <= iouThreshold ? 1 : 0;
    const selected = [];
    candidates.forEach((c) => {
      if (selected.length >= outputSize) {
        return;
      }
      const originalScore = c.score;
      for (let j = selected.length - 1; j >= 0; --j) {
        const iou3 = IOU(boxes, c.boxIndex, selected[j]);
        if (iou3 === 0) {
          continue;
        }
        c.score *= suppressFunc(iou3);
        if (c.score <= scoreThreshold) {
          break;
        }
      }
      if (originalScore === c.score) {
        selected.push(c.boxIndex);
      }
    });
    return selected;
  }
  function IOU(boxes, i, j) {
    const boxesData = boxes.arraySync();
    const yminI = Math.min(boxesData[i][0], boxesData[i][2]);
    const xminI = Math.min(boxesData[i][1], boxesData[i][3]);
    const ymaxI = Math.max(boxesData[i][0], boxesData[i][2]);
    const xmaxI = Math.max(boxesData[i][1], boxesData[i][3]);
    const yminJ = Math.min(boxesData[j][0], boxesData[j][2]);
    const xminJ = Math.min(boxesData[j][1], boxesData[j][3]);
    const ymaxJ = Math.max(boxesData[j][0], boxesData[j][2]);
    const xmaxJ = Math.max(boxesData[j][1], boxesData[j][3]);
    const areaI = (ymaxI - yminI) * (xmaxI - xminI);
    const areaJ = (ymaxJ - yminJ) * (xmaxJ - xminJ);
    if (areaI <= 0 || areaJ <= 0) {
      return 0;
    }
    const intersectionYmin = Math.max(yminI, yminJ);
    const intersectionXmin = Math.max(xminI, xminJ);
    const intersectionYmax = Math.min(ymaxI, ymaxJ);
    const intersectionXmax = Math.min(xmaxI, xmaxJ);
    const intersectionArea = Math.max(intersectionYmax - intersectionYmin, 0) * Math.max(intersectionXmax - intersectionXmin, 0);
    return intersectionArea / (areaI + areaJ - intersectionArea);
  }

  // build/src/ssdMobilenetv1/outputLayer.js
  function getCenterCoordinatesAndSizesLayer(x) {
    const vec = unstack(transpose(x, [1, 0]));
    const sizes = [
      sub(vec[2], vec[0]),
      sub(vec[3], vec[1])
    ];
    const centers = [
      add2(vec[0], div(sizes[0], scalar(2))),
      add2(vec[1], div(sizes[1], scalar(2)))
    ];
    return {
      sizes,
      centers
    };
  }
  function decodeBoxesLayer(x0, x1) {
    const {sizes, centers} = getCenterCoordinatesAndSizesLayer(x0);
    const vec = unstack(transpose(x1, [1, 0]));
    const div0_out = div(mul(exp(div(vec[2], scalar(5))), sizes[0]), scalar(2));
    const add0_out = add2(mul(div(vec[0], scalar(10)), sizes[0]), centers[0]);
    const div1_out = div(mul(exp(div(vec[3], scalar(5))), sizes[1]), scalar(2));
    const add1_out = add2(mul(div(vec[1], scalar(10)), sizes[1]), centers[1]);
    return transpose(stack([
      sub(add0_out, div0_out),
      sub(add1_out, div1_out),
      add2(add0_out, div0_out),
      add2(add1_out, div1_out)
    ]), [1, 0]);
  }
  function outputLayer(boxPredictions, classPredictions, params) {
    return tidy(() => {
      const batchSize = boxPredictions.shape[0];
      let boxes = decodeBoxesLayer(reshape(tile(params.extra_dim, [batchSize, 1, 1]), [-1, 4]), reshape(boxPredictions, [-1, 4]));
      boxes = reshape(boxes, [batchSize, boxes.shape[0] / batchSize, 4]);
      const scoresAndClasses = sigmoid(slice(classPredictions, [0, 0, 1], [-1, -1, -1]));
      let scores = slice(scoresAndClasses, [0, 0, 0], [-1, -1, 1]);
      scores = reshape(scores, [batchSize, scores.shape[1]]);
      const boxesByBatch = unstack(boxes);
      const scoresByBatch = unstack(scores);
      return {
        boxes: boxesByBatch,
        scores: scoresByBatch
      };
    });
  }

  // build/src/ssdMobilenetv1/boxPredictionLayer.js
  function boxPredictionLayer(x, params) {
    return tidy(() => {
      const batchSize = x.shape[0];
      const boxPredictionEncoding = reshape(convLayer(x, params.box_encoding_predictor), [batchSize, -1, 1, 4]);
      const classPrediction = reshape(convLayer(x, params.class_predictor), [batchSize, -1, 3]);
      return {
        boxPredictionEncoding,
        classPrediction
      };
    });
  }

  // build/src/ssdMobilenetv1/predictionLayer.js
  function predictionLayer(x, conv11, params) {
    return tidy(() => {
      const conv0 = pointwiseConvLayer(x, params.conv_0, [1, 1]);
      const conv1 = pointwiseConvLayer(conv0, params.conv_1, [2, 2]);
      const conv22 = pointwiseConvLayer(conv1, params.conv_2, [1, 1]);
      const conv3 = pointwiseConvLayer(conv22, params.conv_3, [2, 2]);
      const conv4 = pointwiseConvLayer(conv3, params.conv_4, [1, 1]);
      const conv5 = pointwiseConvLayer(conv4, params.conv_5, [2, 2]);
      const conv6 = pointwiseConvLayer(conv5, params.conv_6, [1, 1]);
      const conv7 = pointwiseConvLayer(conv6, params.conv_7, [2, 2]);
      const boxPrediction0 = boxPredictionLayer(conv11, params.box_predictor_0);
      const boxPrediction1 = boxPredictionLayer(x, params.box_predictor_1);
      const boxPrediction2 = boxPredictionLayer(conv1, params.box_predictor_2);
      const boxPrediction3 = boxPredictionLayer(conv3, params.box_predictor_3);
      const boxPrediction4 = boxPredictionLayer(conv5, params.box_predictor_4);
      const boxPrediction5 = boxPredictionLayer(conv7, params.box_predictor_5);
      const boxPredictions = concat([
        boxPrediction0.boxPredictionEncoding,
        boxPrediction1.boxPredictionEncoding,
        boxPrediction2.boxPredictionEncoding,
        boxPrediction3.boxPredictionEncoding,
        boxPrediction4.boxPredictionEncoding,
        boxPrediction5.boxPredictionEncoding
      ], 1);
      const classPredictions = concat([
        boxPrediction0.classPrediction,
        boxPrediction1.classPrediction,
        boxPrediction2.classPrediction,
        boxPrediction3.classPrediction,
        boxPrediction4.classPrediction,
        boxPrediction5.classPrediction
      ], 1);
      return {
        boxPredictions,
        classPredictions
      };
    });
  }

  // build/src/ssdMobilenetv1/SsdMobilenetv1Options.js
  class SsdMobilenetv1Options {
    constructor({minConfidence, maxResults} = {}) {
      this._name = "SsdMobilenetv1Options";
      this._minConfidence = minConfidence || 0.5;
      this._maxResults = maxResults || 100;
      if (typeof this._minConfidence !== "number" || this._minConfidence <= 0 || this._minConfidence >= 1) {
        throw new Error(`${this._name} - expected minConfidence to be a number between 0 and 1`);
      }
      if (typeof this._maxResults !== "number") {
        throw new Error(`${this._name} - expected maxResults to be a number`);
      }
    }
    get minConfidence() {
      return this._minConfidence;
    }
    get maxResults() {
      return this._maxResults;
    }
  }

  // build/src/ssdMobilenetv1/SsdMobilenetv1.js
  class SsdMobilenetv1 extends NeuralNetwork {
    constructor() {
      super("SsdMobilenetv1");
    }
    forwardInput(input) {
      const {params} = this;
      if (!params) {
        throw new Error("SsdMobilenetv1 - load model before inference");
      }
      return tidy(() => {
        const batchTensor = cast(input.toBatchTensor(512, false), "float32");
        const x = sub(mul(batchTensor, scalar(0.007843137718737125)), scalar(1));
        const features = mobileNetV1(x, params.mobilenetv1);
        const {boxPredictions, classPredictions} = predictionLayer(features.out, features.conv11, params.prediction_layer);
        return outputLayer(boxPredictions, classPredictions, params.output_layer);
      });
    }
    async forward(input) {
      return this.forwardInput(await toNetInput(input));
    }
    async locateFaces(input, options = {}) {
      const {maxResults, minConfidence} = new SsdMobilenetv1Options(options);
      const netInput = await toNetInput(input);
      const {boxes: _boxes, scores: _scores} = this.forwardInput(netInput);
      const boxes = _boxes[0];
      const scores = _scores[0];
      for (let i = 1; i < _boxes.length; i++) {
        _boxes[i].dispose();
        _scores[i].dispose();
      }
      const scoresData = Array.from(await scores.data());
      const iouThreshold = 0.5;
      const indices = nonMaxSuppression3(boxes, scoresData, maxResults, iouThreshold, minConfidence);
      const reshapedDims = netInput.getReshapedInputDimensions(0);
      const inputSize = netInput.inputSize;
      const padX = inputSize / reshapedDims.width;
      const padY = inputSize / reshapedDims.height;
      const boxesData = boxes.arraySync();
      const results = indices.map((idx) => {
        const [top, bottom] = [
          Math.max(0, boxesData[idx][0]),
          Math.min(1, boxesData[idx][2])
        ].map((val) => val * padY);
        const [left, right] = [
          Math.max(0, boxesData[idx][1]),
          Math.min(1, boxesData[idx][3])
        ].map((val) => val * padX);
        return new FaceDetection(scoresData[idx], new Rect(left, top, right - left, bottom - top), {
          height: netInput.getInputHeight(0),
          width: netInput.getInputWidth(0)
        });
      });
      boxes.dispose();
      scores.dispose();
      return results;
    }
    getDefaultModelName() {
      return "ssd_mobilenetv1_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMap11(weightMap);
    }
    extractParams(weights) {
      return extractParams11(weights);
    }
  }

  // build/src/ssdMobilenetv1/index.js
  function createSsdMobilenetv1(weights) {
    const net = new SsdMobilenetv1();
    net.extractWeights(weights);
    return net;
  }
  function createFaceDetectionNet(weights) {
    return createSsdMobilenetv1(weights);
  }
  class FaceDetectionNet extends SsdMobilenetv1 {
  }

  // build/src/tinyYolov2/const.js
  const IOU_THRESHOLD = 0.4;
  const BOX_ANCHORS = [
    new Point(0.738768, 0.874946),
    new Point(2.42204, 2.65704),
    new Point(4.30971, 7.04493),
    new Point(10.246, 4.59428),
    new Point(12.6868, 11.8741)
  ];
  const BOX_ANCHORS_SEPARABLE = [
    new Point(1.603231, 2.094468),
    new Point(6.041143, 7.080126),
    new Point(2.882459, 3.518061),
    new Point(4.266906, 5.178857),
    new Point(9.041765, 10.66308)
  ];
  const MEAN_RGB_SEPARABLE = [117.001, 114.697, 97.404];
  const DEFAULT_MODEL_NAME = "tiny_yolov2_model";
  const DEFAULT_MODEL_NAME_SEPARABLE_CONV = "tiny_yolov2_separable_conv_model";

  // build/src/tinyYolov2/config.js
  const isNumber2 = (arg) => typeof arg === "number";
  function validateConfig(config2) {
    if (!config2) {
      throw new Error(`invalid config: ${config2}`);
    }
    if (typeof config2.withSeparableConvs !== "boolean") {
      throw new Error(`config.withSeparableConvs has to be a boolean, have: ${config2.withSeparableConvs}`);
    }
    if (!isNumber2(config2.iouThreshold) || config2.iouThreshold < 0 || config2.iouThreshold > 1) {
      throw new Error(`config.iouThreshold has to be a number between [0, 1], have: ${config2.iouThreshold}`);
    }
    if (!Array.isArray(config2.classes) || !config2.classes.length || !config2.classes.every((c) => typeof c === "string")) {
      throw new Error(`config.classes has to be an array class names: string[], have: ${JSON.stringify(config2.classes)}`);
    }
    if (!Array.isArray(config2.anchors) || !config2.anchors.length || !config2.anchors.map((a) => a || {}).every((a) => isNumber2(a.x) && isNumber2(a.y))) {
      throw new Error(`config.anchors has to be an array of { x: number, y: number }, have: ${JSON.stringify(config2.anchors)}`);
    }
    if (config2.meanRgb && (!Array.isArray(config2.meanRgb) || config2.meanRgb.length !== 3 || !config2.meanRgb.every(isNumber2))) {
      throw new Error(`config.meanRgb has to be an array of shape [number, number, number], have: ${JSON.stringify(config2.meanRgb)}`);
    }
  }

  // build/src/tinyYolov2/leaky.js
  function leaky(x) {
    return tidy(() => {
      const min4 = mul(x, scalar(0.10000000149011612));
      return add2(relu(sub(x, min4)), min4);
    });
  }

  // build/src/tinyYolov2/convWithBatchNorm.js
  function convWithBatchNorm(x, params) {
    return tidy(() => {
      let out = pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]]);
      out = conv2d(out, params.conv.filters, [1, 1], "valid");
      out = sub(out, params.bn.sub);
      out = mul(out, params.bn.truediv);
      out = add2(out, params.conv.bias);
      return leaky(out);
    });
  }

  // build/src/tinyYolov2/depthwiseSeparableConv.js
  function depthwiseSeparableConv3(x, params) {
    return tidy(() => {
      let out = pad(x, [[0, 0], [1, 1], [1, 1], [0, 0]]);
      out = separableConv2d(out, params.depthwise_filter, params.pointwise_filter, [1, 1], "valid");
      out = add2(out, params.bias);
      return leaky(out);
    });
  }

  // build/src/tinyYolov2/extractParams.js
  function extractorsFactory9(extractWeights, paramMappings) {
    const extractConvParams = extractConvParamsFactory(extractWeights, paramMappings);
    function extractBatchNormParams(size, mappedPrefix) {
      const sub32 = tensor1d(extractWeights(size));
      const truediv = tensor1d(extractWeights(size));
      paramMappings.push({paramPath: `${mappedPrefix}/sub`}, {paramPath: `${mappedPrefix}/truediv`});
      return {sub: sub32, truediv};
    }
    function extractConvWithBatchNormParams(channelsIn, channelsOut, mappedPrefix) {
      const conv3 = extractConvParams(channelsIn, channelsOut, 3, `${mappedPrefix}/conv`);
      const bn = extractBatchNormParams(channelsOut, `${mappedPrefix}/bn`);
      return {conv: conv3, bn};
    }
    const extractSeparableConvParams = extractSeparableConvParamsFactory(extractWeights, paramMappings);
    return {
      extractConvParams,
      extractConvWithBatchNormParams,
      extractSeparableConvParams
    };
  }
  function extractParams13(weights, config2, boxEncodingSize, filterSizes) {
    const {extractWeights, getRemainingWeights} = extractWeightsFactory(weights);
    const paramMappings = [];
    const {extractConvParams, extractConvWithBatchNormParams, extractSeparableConvParams} = extractorsFactory9(extractWeights, paramMappings);
    let params;
    if (config2.withSeparableConvs) {
      const [s0, s1, s2, s3, s4, s5, s6, s7, s8] = filterSizes;
      const conv0 = config2.isFirstLayerConv2d ? extractConvParams(s0, s1, 3, "conv0") : extractSeparableConvParams(s0, s1, "conv0");
      const conv1 = extractSeparableConvParams(s1, s2, "conv1");
      const conv22 = extractSeparableConvParams(s2, s3, "conv2");
      const conv3 = extractSeparableConvParams(s3, s4, "conv3");
      const conv4 = extractSeparableConvParams(s4, s5, "conv4");
      const conv5 = extractSeparableConvParams(s5, s6, "conv5");
      const conv6 = s7 ? extractSeparableConvParams(s6, s7, "conv6") : void 0;
      const conv7 = s8 ? extractSeparableConvParams(s7, s8, "conv7") : void 0;
      const conv8 = extractConvParams(s8 || s7 || s6, 5 * boxEncodingSize, 1, "conv8");
      params = {conv0, conv1, conv2: conv22, conv3, conv4, conv5, conv6, conv7, conv8};
    } else {
      const [s0, s1, s2, s3, s4, s5, s6, s7, s8] = filterSizes;
      const conv0 = extractConvWithBatchNormParams(s0, s1, "conv0");
      const conv1 = extractConvWithBatchNormParams(s1, s2, "conv1");
      const conv22 = extractConvWithBatchNormParams(s2, s3, "conv2");
      const conv3 = extractConvWithBatchNormParams(s3, s4, "conv3");
      const conv4 = extractConvWithBatchNormParams(s4, s5, "conv4");
      const conv5 = extractConvWithBatchNormParams(s5, s6, "conv5");
      const conv6 = extractConvWithBatchNormParams(s6, s7, "conv6");
      const conv7 = extractConvWithBatchNormParams(s7, s8, "conv7");
      const conv8 = extractConvParams(s8, 5 * boxEncodingSize, 1, "conv8");
      params = {conv0, conv1, conv2: conv22, conv3, conv4, conv5, conv6, conv7, conv8};
    }
    if (getRemainingWeights().length !== 0) {
      throw new Error(`weights remaing after extract: ${getRemainingWeights().length}`);
    }
    return {params, paramMappings};
  }

  // build/src/tinyYolov2/extractParamsFromWeigthMap.js
  function extractorsFactory10(weightMap, paramMappings) {
    const extractWeightEntry = extractWeightEntryFactory(weightMap, paramMappings);
    function extractBatchNormParams(prefix) {
      const sub32 = extractWeightEntry(`${prefix}/sub`, 1);
      const truediv = extractWeightEntry(`${prefix}/truediv`, 1);
      return {sub: sub32, truediv};
    }
    function extractConvParams(prefix) {
      const filters = extractWeightEntry(`${prefix}/filters`, 4);
      const bias = extractWeightEntry(`${prefix}/bias`, 1);
      return {filters, bias};
    }
    function extractConvWithBatchNormParams(prefix) {
      const conv3 = extractConvParams(`${prefix}/conv`);
      const bn = extractBatchNormParams(`${prefix}/bn`);
      return {conv: conv3, bn};
    }
    const extractSeparableConvParams = loadSeparableConvParamsFactory(extractWeightEntry);
    return {
      extractConvParams,
      extractConvWithBatchNormParams,
      extractSeparableConvParams
    };
  }
  function extractParamsFromWeigthMap13(weightMap, config2) {
    const paramMappings = [];
    const {extractConvParams, extractConvWithBatchNormParams, extractSeparableConvParams} = extractorsFactory10(weightMap, paramMappings);
    let params;
    if (config2.withSeparableConvs) {
      const numFilters = config2.filterSizes && config2.filterSizes.length || 9;
      params = {
        conv0: config2.isFirstLayerConv2d ? extractConvParams("conv0") : extractSeparableConvParams("conv0"),
        conv1: extractSeparableConvParams("conv1"),
        conv2: extractSeparableConvParams("conv2"),
        conv3: extractSeparableConvParams("conv3"),
        conv4: extractSeparableConvParams("conv4"),
        conv5: extractSeparableConvParams("conv5"),
        conv6: numFilters > 7 ? extractSeparableConvParams("conv6") : void 0,
        conv7: numFilters > 8 ? extractSeparableConvParams("conv7") : void 0,
        conv8: extractConvParams("conv8")
      };
    } else {
      params = {
        conv0: extractConvWithBatchNormParams("conv0"),
        conv1: extractConvWithBatchNormParams("conv1"),
        conv2: extractConvWithBatchNormParams("conv2"),
        conv3: extractConvWithBatchNormParams("conv3"),
        conv4: extractConvWithBatchNormParams("conv4"),
        conv5: extractConvWithBatchNormParams("conv5"),
        conv6: extractConvWithBatchNormParams("conv6"),
        conv7: extractConvWithBatchNormParams("conv7"),
        conv8: extractConvParams("conv8")
      };
    }
    disposeUnusedWeightTensors(weightMap, paramMappings);
    return {params, paramMappings};
  }

  // build/src/tinyYolov2/TinyYolov2Options.js
  var TinyYolov2SizeType;
  (function(TinyYolov2SizeType2) {
    TinyYolov2SizeType2[TinyYolov2SizeType2["XS"] = 224] = "XS";
    TinyYolov2SizeType2[TinyYolov2SizeType2["SM"] = 320] = "SM";
    TinyYolov2SizeType2[TinyYolov2SizeType2["MD"] = 416] = "MD";
    TinyYolov2SizeType2[TinyYolov2SizeType2["LG"] = 608] = "LG";
  })(TinyYolov2SizeType || (TinyYolov2SizeType = {}));
  class TinyYolov2Options {
    constructor({inputSize, scoreThreshold} = {}) {
      this._name = "TinyYolov2Options";
      this._inputSize = inputSize || 416;
      this._scoreThreshold = scoreThreshold || 0.5;
      if (typeof this._inputSize !== "number" || this._inputSize % 32 !== 0) {
        throw new Error(`${this._name} - expected inputSize to be a number divisible by 32`);
      }
      if (typeof this._scoreThreshold !== "number" || this._scoreThreshold <= 0 || this._scoreThreshold >= 1) {
        throw new Error(`${this._name} - expected scoreThreshold to be a number between 0 and 1`);
      }
    }
    get inputSize() {
      return this._inputSize;
    }
    get scoreThreshold() {
      return this._scoreThreshold;
    }
  }

  // build/src/tinyYolov2/TinyYolov2Base.js
  class TinyYolov2Base extends NeuralNetwork {
    constructor(config2) {
      super("TinyYolov2");
      validateConfig(config2);
      this._config = config2;
    }
    get config() {
      return this._config;
    }
    get withClassScores() {
      return this.config.withClassScores || this.config.classes.length > 1;
    }
    get boxEncodingSize() {
      return 5 + (this.withClassScores ? this.config.classes.length : 0);
    }
    runTinyYolov2(x, params) {
      let out = convWithBatchNorm(x, params.conv0);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = convWithBatchNorm(out, params.conv1);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = convWithBatchNorm(out, params.conv2);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = convWithBatchNorm(out, params.conv3);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = convWithBatchNorm(out, params.conv4);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = convWithBatchNorm(out, params.conv5);
      out = maxPool(out, [2, 2], [1, 1], "same");
      out = convWithBatchNorm(out, params.conv6);
      out = convWithBatchNorm(out, params.conv7);
      return convLayer(out, params.conv8, "valid", false);
    }
    runMobilenet(x, params) {
      let out = this.config.isFirstLayerConv2d ? leaky(convLayer(x, params.conv0, "valid", false)) : depthwiseSeparableConv3(x, params.conv0);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = depthwiseSeparableConv3(out, params.conv1);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = depthwiseSeparableConv3(out, params.conv2);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = depthwiseSeparableConv3(out, params.conv3);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = depthwiseSeparableConv3(out, params.conv4);
      out = maxPool(out, [2, 2], [2, 2], "same");
      out = depthwiseSeparableConv3(out, params.conv5);
      out = maxPool(out, [2, 2], [1, 1], "same");
      out = params.conv6 ? depthwiseSeparableConv3(out, params.conv6) : out;
      out = params.conv7 ? depthwiseSeparableConv3(out, params.conv7) : out;
      return convLayer(out, params.conv8, "valid", false);
    }
    forwardInput(input, inputSize) {
      const {params} = this;
      if (!params) {
        throw new Error("TinyYolov2 - load model before inference");
      }
      return tidy(() => {
        let batchTensor = cast(input.toBatchTensor(inputSize, false), "float32");
        batchTensor = this.config.meanRgb ? normalize(batchTensor, this.config.meanRgb) : batchTensor;
        batchTensor = batchTensor.div(scalar(256));
        return this.config.withSeparableConvs ? this.runMobilenet(batchTensor, params) : this.runTinyYolov2(batchTensor, params);
      });
    }
    async forward(input, inputSize) {
      return await this.forwardInput(await toNetInput(input), inputSize);
    }
    async detect(input, forwardParams = {}) {
      const {inputSize, scoreThreshold} = new TinyYolov2Options(forwardParams);
      const netInput = await toNetInput(input);
      const out = await this.forwardInput(netInput, inputSize);
      const out0 = tidy(() => unstack(out)[0].expandDims());
      const inputDimensions = {
        width: netInput.getInputWidth(0),
        height: netInput.getInputHeight(0)
      };
      const results = await this.extractBoxes(out0, netInput.getReshapedInputDimensions(0), scoreThreshold);
      out.dispose();
      out0.dispose();
      const boxes = results.map((res) => res.box);
      const scores = results.map((res) => res.score);
      const classScores = results.map((res) => res.classScore);
      const classNames = results.map((res) => this.config.classes[res.label]);
      const indices = nonMaxSuppression2(boxes.map((box) => box.rescale(inputSize)), scores, this.config.iouThreshold, true);
      const detections = indices.map((idx) => new ObjectDetection(scores[idx], classScores[idx], classNames[idx], boxes[idx], inputDimensions));
      return detections;
    }
    getDefaultModelName() {
      return "";
    }
    extractParamsFromWeigthMap(weightMap) {
      return extractParamsFromWeigthMap13(weightMap, this.config);
    }
    extractParams(weights) {
      const filterSizes = this.config.filterSizes || TinyYolov2Base.DEFAULT_FILTER_SIZES;
      const numFilters = filterSizes ? filterSizes.length : void 0;
      if (numFilters !== 7 && numFilters !== 8 && numFilters !== 9) {
        throw new Error(`TinyYolov2 - expected 7 | 8 | 9 convolutional filters, but found ${numFilters} filterSizes in config`);
      }
      return extractParams13(weights, this.config, this.boxEncodingSize, filterSizes);
    }
    async extractBoxes(outputTensor, inputBlobDimensions, scoreThreshold) {
      const {width, height} = inputBlobDimensions;
      const inputSize = Math.max(width, height);
      const correctionFactorX = inputSize / width;
      const correctionFactorY = inputSize / height;
      const numCells = outputTensor.shape[1];
      const numBoxes = this.config.anchors.length;
      const [boxesTensor, scoresTensor, classScoresTensor] = tidy(() => {
        const reshaped = outputTensor.reshape([numCells, numCells, numBoxes, this.boxEncodingSize]);
        const boxes = reshaped.slice([0, 0, 0, 0], [numCells, numCells, numBoxes, 4]);
        const scores = reshaped.slice([0, 0, 0, 4], [numCells, numCells, numBoxes, 1]);
        const classScores = this.withClassScores ? softmax(reshaped.slice([0, 0, 0, 5], [numCells, numCells, numBoxes, this.config.classes.length]), 3) : scalar(0);
        return [boxes, scores, classScores];
      });
      const results = [];
      const scoresData = await scoresTensor.array();
      const boxesData = await boxesTensor.array();
      for (let row = 0; row < numCells; row++) {
        for (let col = 0; col < numCells; col++) {
          for (let anchor = 0; anchor < numBoxes; anchor++) {
            const score = sigmoid6(scoresData[row][col][anchor][0]);
            if (!scoreThreshold || score > scoreThreshold) {
              const ctX = (col + sigmoid6(boxesData[row][col][anchor][0])) / numCells * correctionFactorX;
              const ctY = (row + sigmoid6(boxesData[row][col][anchor][1])) / numCells * correctionFactorY;
              const width2 = Math.exp(boxesData[row][col][anchor][2]) * this.config.anchors[anchor].x / numCells * correctionFactorX;
              const height2 = Math.exp(boxesData[row][col][anchor][3]) * this.config.anchors[anchor].y / numCells * correctionFactorY;
              const x = ctX - width2 / 2;
              const y = ctY - height2 / 2;
              const pos = {row, col, anchor};
              const {classScore, label} = this.withClassScores ? await this.extractPredictedClass(classScoresTensor, pos) : {classScore: 1, label: 0};
              results.push(__assign({
                box: new BoundingBox(x, y, x + width2, y + height2),
                score,
                classScore: score * classScore,
                label
              }, pos));
            }
          }
        }
      }
      boxesTensor.dispose();
      scoresTensor.dispose();
      classScoresTensor.dispose();
      return results;
    }
    async extractPredictedClass(classesTensor, pos) {
      const {row, col, anchor} = pos;
      const classesData = await classesTensor.array();
      return Array(this.config.classes.length).fill(0).map((_, i) => classesData[row][col][anchor][i]).map((classScore, label) => ({
        classScore,
        label
      })).reduce((max6, curr) => max6.classScore > curr.classScore ? max6 : curr);
    }
  }
  TinyYolov2Base.DEFAULT_FILTER_SIZES = [
    3,
    16,
    32,
    64,
    128,
    256,
    512,
    1024,
    1024
  ];

  // build/src/tinyYolov2/TinyYolov2.js
  class TinyYolov2 extends TinyYolov2Base {
    constructor(withSeparableConvs = true) {
      const config2 = Object.assign({}, {
        withSeparableConvs,
        iouThreshold: IOU_THRESHOLD,
        classes: ["face"]
      }, withSeparableConvs ? {
        anchors: BOX_ANCHORS_SEPARABLE,
        meanRgb: MEAN_RGB_SEPARABLE
      } : {
        anchors: BOX_ANCHORS,
        withClassScores: true
      });
      super(config2);
    }
    get withSeparableConvs() {
      return this.config.withSeparableConvs;
    }
    get anchors() {
      return this.config.anchors;
    }
    async locateFaces(input, forwardParams) {
      const objectDetections = await this.detect(input, forwardParams);
      return objectDetections.map((det) => new FaceDetection(det.score, det.relativeBox, {width: det.imageWidth, height: det.imageHeight}));
    }
    getDefaultModelName() {
      return this.withSeparableConvs ? DEFAULT_MODEL_NAME_SEPARABLE_CONV : DEFAULT_MODEL_NAME;
    }
    extractParamsFromWeigthMap(weightMap) {
      return super.extractParamsFromWeigthMap(weightMap);
    }
  }

  // build/src/tinyYolov2/types.js

  // build/src/tinyYolov2/index.js
  function createTinyYolov2(weights, withSeparableConvs = true) {
    const net = new TinyYolov2(withSeparableConvs);
    net.extractWeights(weights);
    return net;
  }

  // build/src/tinyFaceDetector/TinyFaceDetectorOptions.js
  class TinyFaceDetectorOptions extends TinyYolov2Options {
    constructor() {
      super(...arguments);
      this._name = "TinyFaceDetectorOptions";
    }
  }

  // build/src/globalApi/ComposableTask.js
  class ComposableTask {
    async then(onfulfilled) {
      return onfulfilled(await this.run());
    }
    async run() {
      throw new Error("ComposableTask - run is not implemented");
    }
  }

  // build/src/globalApi/extractFacesAndComputeResults.js
  async function extractAllFacesAndComputeResults(parentResults, input, computeResults, extractedFaces, getRectForAlignment = ({alignedRect}) => alignedRect) {
    const faceBoxes = parentResults.map((parentResult) => isWithFaceLandmarks(parentResult) ? getRectForAlignment(parentResult) : parentResult.detection);
    const faces = extractedFaces || (input instanceof Tensor ? await extractFaceTensors(input, faceBoxes) : await extractFaces(input, faceBoxes));
    const results = await computeResults(faces);
    faces.forEach((f) => f instanceof Tensor && f.dispose());
    return results;
  }
  async function extractSingleFaceAndComputeResult(parentResult, input, computeResult, extractedFaces, getRectForAlignment) {
    return extractAllFacesAndComputeResults([parentResult], input, async (faces) => computeResult(faces[0]), extractedFaces, getRectForAlignment);
  }

  // build/src/tinyFaceDetector/const.js
  const IOU_THRESHOLD2 = 0.4;
  const BOX_ANCHORS2 = [
    new Point(1.603231, 2.094468),
    new Point(6.041143, 7.080126),
    new Point(2.882459, 3.518061),
    new Point(4.266906, 5.178857),
    new Point(9.041765, 10.66308)
  ];
  const MEAN_RGB = [117.001, 114.697, 97.404];

  // build/src/tinyFaceDetector/TinyFaceDetector.js
  class TinyFaceDetector extends TinyYolov2Base {
    constructor() {
      const config2 = {
        withSeparableConvs: true,
        iouThreshold: IOU_THRESHOLD2,
        classes: ["face"],
        anchors: BOX_ANCHORS2,
        meanRgb: MEAN_RGB,
        isFirstLayerConv2d: true,
        filterSizes: [3, 16, 32, 64, 128, 256, 512]
      };
      super(config2);
    }
    get anchors() {
      return this.config.anchors;
    }
    async locateFaces(input, forwardParams) {
      const objectDetections = await this.detect(input, forwardParams);
      return objectDetections.map((det) => new FaceDetection(det.score, det.relativeBox, {width: det.imageWidth, height: det.imageHeight}));
    }
    getDefaultModelName() {
      return "tiny_face_detector_model";
    }
    extractParamsFromWeigthMap(weightMap) {
      return super.extractParamsFromWeigthMap(weightMap);
    }
  }

  // build/src/globalApi/nets.js
  const nets = {
    ssdMobilenetv1: new SsdMobilenetv1(),
    tinyFaceDetector: new TinyFaceDetector(),
    tinyYolov2: new TinyYolov2(),
    faceLandmark68Net: new FaceLandmark68Net(),
    faceLandmark68TinyNet: new FaceLandmark68TinyNet(),
    faceRecognitionNet: new FaceRecognitionNet(),
    faceExpressionNet: new FaceExpressionNet(),
    ageGenderNet: new AgeGenderNet()
  };
  const ssdMobilenetv1 = (input, options) => nets.ssdMobilenetv1.locateFaces(input, options);
  const tinyFaceDetector = (input, options) => nets.tinyFaceDetector.locateFaces(input, options);
  const tinyYolov23 = (input, options) => nets.tinyYolov2.locateFaces(input, options);
  const detectFaceLandmarks = (input) => nets.faceLandmark68Net.detectLandmarks(input);
  const detectFaceLandmarksTiny = (input) => nets.faceLandmark68TinyNet.detectLandmarks(input);
  const computeFaceDescriptor = (input) => nets.faceRecognitionNet.computeFaceDescriptor(input);
  const recognizeFaceExpressions = (input) => nets.faceExpressionNet.predictExpressions(input);
  const predictAgeAndGender = (input) => nets.ageGenderNet.predictAgeAndGender(input);
  const loadSsdMobilenetv1Model = (url) => nets.ssdMobilenetv1.load(url);
  const loadTinyFaceDetectorModel = (url) => nets.tinyFaceDetector.load(url);
  const loadTinyYolov2Model = (url) => nets.tinyYolov2.load(url);
  const loadFaceLandmarkModel = (url) => nets.faceLandmark68Net.load(url);
  const loadFaceLandmarkTinyModel = (url) => nets.faceLandmark68TinyNet.load(url);
  const loadFaceRecognitionModel = (url) => nets.faceRecognitionNet.load(url);
  const loadFaceExpressionModel = (url) => nets.faceExpressionNet.load(url);
  const loadAgeGenderModel = (url) => nets.ageGenderNet.load(url);
  const loadFaceDetectionModel = loadSsdMobilenetv1Model;
  const locateFaces = ssdMobilenetv1;
  const detectLandmarks = detectFaceLandmarks;

  // build/src/globalApi/PredictFaceExpressionsTask.js
  class PredictFaceExpressionsTaskBase extends ComposableTask {
    constructor(parentTask, input, extractedFaces) {
      super();
      this.parentTask = parentTask;
      this.input = input;
      this.extractedFaces = extractedFaces;
    }
  }
  class PredictAllFaceExpressionsTask extends PredictFaceExpressionsTaskBase {
    async run() {
      const parentResults = await this.parentTask;
      const faceExpressionsByFace = await extractAllFacesAndComputeResults(parentResults, this.input, async (faces) => await Promise.all(faces.map((face) => nets.faceExpressionNet.predictExpressions(face))), this.extractedFaces);
      return parentResults.map((parentResult, i) => extendWithFaceExpressions(parentResult, faceExpressionsByFace[i]));
    }
    withAgeAndGender() {
      return new PredictAllAgeAndGenderTask(this, this.input);
    }
  }
  class PredictSingleFaceExpressionsTask extends PredictFaceExpressionsTaskBase {
    async run() {
      const parentResult = await this.parentTask;
      if (!parentResult) {
        return;
      }
      const faceExpressions = await extractSingleFaceAndComputeResult(parentResult, this.input, (face) => nets.faceExpressionNet.predictExpressions(face), this.extractedFaces);
      return extendWithFaceExpressions(parentResult, faceExpressions);
    }
    withAgeAndGender() {
      return new PredictSingleAgeAndGenderTask(this, this.input);
    }
  }
  class PredictAllFaceExpressionsWithFaceAlignmentTask extends PredictAllFaceExpressionsTask {
    withAgeAndGender() {
      return new PredictAllAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptors() {
      return new ComputeAllFaceDescriptorsTask(this, this.input);
    }
  }
  class PredictSingleFaceExpressionsWithFaceAlignmentTask extends PredictSingleFaceExpressionsTask {
    withAgeAndGender() {
      return new PredictSingleAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptor() {
      return new ComputeSingleFaceDescriptorTask(this, this.input);
    }
  }

  // build/src/globalApi/PredictAgeAndGenderTask.js
  class PredictAgeAndGenderTaskBase extends ComposableTask {
    constructor(parentTask, input, extractedFaces) {
      super();
      this.parentTask = parentTask;
      this.input = input;
      this.extractedFaces = extractedFaces;
    }
  }
  class PredictAllAgeAndGenderTask extends PredictAgeAndGenderTaskBase {
    async run() {
      const parentResults = await this.parentTask;
      const ageAndGenderByFace = await extractAllFacesAndComputeResults(parentResults, this.input, async (faces) => await Promise.all(faces.map((face) => nets.ageGenderNet.predictAgeAndGender(face))), this.extractedFaces);
      return parentResults.map((parentResult, i) => {
        const {age, gender, genderProbability} = ageAndGenderByFace[i];
        return extendWithAge(extendWithGender(parentResult, gender, genderProbability), age);
      });
    }
    withFaceExpressions() {
      return new PredictAllFaceExpressionsTask(this, this.input);
    }
  }
  class PredictSingleAgeAndGenderTask extends PredictAgeAndGenderTaskBase {
    async run() {
      const parentResult = await this.parentTask;
      if (!parentResult) {
        return;
      }
      const {age, gender, genderProbability} = await extractSingleFaceAndComputeResult(parentResult, this.input, (face) => nets.ageGenderNet.predictAgeAndGender(face), this.extractedFaces);
      return extendWithAge(extendWithGender(parentResult, gender, genderProbability), age);
    }
    withFaceExpressions() {
      return new PredictSingleFaceExpressionsTask(this, this.input);
    }
  }
  class PredictAllAgeAndGenderWithFaceAlignmentTask extends PredictAllAgeAndGenderTask {
    withFaceExpressions() {
      return new PredictAllFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptors() {
      return new ComputeAllFaceDescriptorsTask(this, this.input);
    }
  }
  class PredictSingleAgeAndGenderWithFaceAlignmentTask extends PredictSingleAgeAndGenderTask {
    withFaceExpressions() {
      return new PredictSingleFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptor() {
      return new ComputeSingleFaceDescriptorTask(this, this.input);
    }
  }

  // build/src/globalApi/ComputeFaceDescriptorsTasks.js
  class ComputeFaceDescriptorsTaskBase extends ComposableTask {
    constructor(parentTask, input) {
      super();
      this.parentTask = parentTask;
      this.input = input;
    }
  }
  class ComputeAllFaceDescriptorsTask extends ComputeFaceDescriptorsTaskBase {
    async run() {
      const parentResults = await this.parentTask;
      const descriptors = await extractAllFacesAndComputeResults(parentResults, this.input, (faces) => Promise.all(faces.map((face) => nets.faceRecognitionNet.computeFaceDescriptor(face))), null, (parentResult) => parentResult.landmarks.align(null, {useDlibAlignment: true}));
      return descriptors.map((descriptor, i) => extendWithFaceDescriptor(parentResults[i], descriptor));
    }
    withFaceExpressions() {
      return new PredictAllFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withAgeAndGender() {
      return new PredictAllAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
  }
  class ComputeSingleFaceDescriptorTask extends ComputeFaceDescriptorsTaskBase {
    async run() {
      const parentResult = await this.parentTask;
      if (!parentResult) {
        return;
      }
      const descriptor = await extractSingleFaceAndComputeResult(parentResult, this.input, (face) => nets.faceRecognitionNet.computeFaceDescriptor(face), null, (parentResult2) => parentResult2.landmarks.align(null, {useDlibAlignment: true}));
      return extendWithFaceDescriptor(parentResult, descriptor);
    }
    withFaceExpressions() {
      return new PredictSingleFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withAgeAndGender() {
      return new PredictSingleAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
  }

  // build/src/globalApi/DetectFaceLandmarksTasks.js
  class DetectFaceLandmarksTaskBase extends ComposableTask {
    constructor(parentTask, input, useTinyLandmarkNet) {
      super();
      this.parentTask = parentTask;
      this.input = input;
      this.useTinyLandmarkNet = useTinyLandmarkNet;
    }
    get landmarkNet() {
      return this.useTinyLandmarkNet ? nets.faceLandmark68TinyNet : nets.faceLandmark68Net;
    }
  }
  class DetectAllFaceLandmarksTask extends DetectFaceLandmarksTaskBase {
    async run() {
      const parentResults = await this.parentTask;
      const detections = parentResults.map((res) => res.detection);
      const faces = this.input instanceof Tensor ? await extractFaceTensors(this.input, detections) : await extractFaces(this.input, detections);
      const faceLandmarksByFace = await Promise.all(faces.map((face) => this.landmarkNet.detectLandmarks(face)));
      faces.forEach((f) => f instanceof Tensor && f.dispose());
      return parentResults.map((parentResult, i) => extendWithFaceLandmarks(parentResult, faceLandmarksByFace[i]));
    }
    withFaceExpressions() {
      return new PredictAllFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withAgeAndGender() {
      return new PredictAllAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptors() {
      return new ComputeAllFaceDescriptorsTask(this, this.input);
    }
  }
  class DetectSingleFaceLandmarksTask extends DetectFaceLandmarksTaskBase {
    async run() {
      const parentResult = await this.parentTask;
      if (!parentResult) {
        return;
      }
      const {detection} = parentResult;
      const faces = this.input instanceof Tensor ? await extractFaceTensors(this.input, [detection]) : await extractFaces(this.input, [detection]);
      const landmarks = await this.landmarkNet.detectLandmarks(faces[0]);
      faces.forEach((f) => f instanceof Tensor && f.dispose());
      return extendWithFaceLandmarks(parentResult, landmarks);
    }
    withFaceExpressions() {
      return new PredictSingleFaceExpressionsWithFaceAlignmentTask(this, this.input);
    }
    withAgeAndGender() {
      return new PredictSingleAgeAndGenderWithFaceAlignmentTask(this, this.input);
    }
    withFaceDescriptor() {
      return new ComputeSingleFaceDescriptorTask(this, this.input);
    }
  }

  // build/src/globalApi/DetectFacesTasks.js
  class DetectFacesTaskBase extends ComposableTask {
    constructor(input, options = new SsdMobilenetv1Options()) {
      super();
      this.input = input;
      this.options = options;
    }
  }
  class DetectAllFacesTask extends DetectFacesTaskBase {
    async run() {
      const {input, options} = this;
      const faceDetectionFunction = options instanceof TinyFaceDetectorOptions ? (input2) => nets.tinyFaceDetector.locateFaces(input2, options) : options instanceof SsdMobilenetv1Options ? (input2) => nets.ssdMobilenetv1.locateFaces(input2, options) : options instanceof TinyYolov2Options ? (input2) => nets.tinyYolov2.locateFaces(input2, options) : null;
      if (!faceDetectionFunction) {
        throw new Error("detectFaces - expected options to be instance of TinyFaceDetectorOptions | SsdMobilenetv1Options | MtcnnOptions | TinyYolov2Options");
      }
      return faceDetectionFunction(input);
    }
    runAndExtendWithFaceDetections() {
      return new Promise(async (res) => {
        const detections = await this.run();
        return res(detections.map((detection) => extendWithFaceDetection({}, detection)));
      });
    }
    withFaceLandmarks(useTinyLandmarkNet = false) {
      return new DetectAllFaceLandmarksTask(this.runAndExtendWithFaceDetections(), this.input, useTinyLandmarkNet);
    }
    withFaceExpressions() {
      return new PredictAllFaceExpressionsTask(this.runAndExtendWithFaceDetections(), this.input);
    }
    withAgeAndGender() {
      return new PredictAllAgeAndGenderTask(this.runAndExtendWithFaceDetections(), this.input);
    }
  }
  class DetectSingleFaceTask extends DetectFacesTaskBase {
    async run() {
      const faceDetections = await new DetectAllFacesTask(this.input, this.options);
      let faceDetectionWithHighestScore = faceDetections[0];
      faceDetections.forEach((faceDetection) => {
        if (faceDetection.score > faceDetectionWithHighestScore.score) {
          faceDetectionWithHighestScore = faceDetection;
        }
      });
      return faceDetectionWithHighestScore;
    }
    runAndExtendWithFaceDetection() {
      return new Promise(async (res) => {
        const detection = await this.run();
        return res(detection ? extendWithFaceDetection({}, detection) : void 0);
      });
    }
    withFaceLandmarks(useTinyLandmarkNet = false) {
      return new DetectSingleFaceLandmarksTask(this.runAndExtendWithFaceDetection(), this.input, useTinyLandmarkNet);
    }
    withFaceExpressions() {
      return new PredictSingleFaceExpressionsTask(this.runAndExtendWithFaceDetection(), this.input);
    }
    withAgeAndGender() {
      return new PredictSingleAgeAndGenderTask(this.runAndExtendWithFaceDetection(), this.input);
    }
  }

  // build/src/globalApi/detectFaces.js
  function detectSingleFace(input, options = new SsdMobilenetv1Options()) {
    return new DetectSingleFaceTask(input, options);
  }
  function detectAllFaces(input, options = new SsdMobilenetv1Options()) {
    return new DetectAllFacesTask(input, options);
  }

  // build/src/globalApi/allFaces.js
  async function allFacesSsdMobilenetv1(input, minConfidence) {
    console.warn("allFacesSsdMobilenetv1 is deprecated and will be removed soon, use the high level api instead");
    return await detectAllFaces(input, new SsdMobilenetv1Options(minConfidence ? {minConfidence} : {})).withFaceLandmarks().withFaceDescriptors();
  }
  async function allFacesTinyYolov2(input, forwardParams = {}) {
    console.warn("allFacesTinyYolov2 is deprecated and will be removed soon, use the high level api instead");
    return await detectAllFaces(input, new TinyYolov2Options(forwardParams)).withFaceLandmarks().withFaceDescriptors();
  }
  const allFaces = allFacesSsdMobilenetv1;

  // build/src/euclideanDistance.js
  function euclideanDistance(arr1, arr2) {
    if (arr1.length !== arr2.length)
      throw new Error("euclideanDistance: arr1.length !== arr2.length");
    const desc1 = Array.from(arr1);
    const desc2 = Array.from(arr2);
    return Math.sqrt(desc1.map((val, i) => val - desc2[i]).reduce((res, diff) => res + Math.pow(diff, 2), 0));
  }

  // build/src/globalApi/FaceMatcher.js
  class FaceMatcher {
    constructor(inputs, distanceThreshold = 0.6) {
      this._distanceThreshold = distanceThreshold;
      const inputArray = Array.isArray(inputs) ? inputs : [inputs];
      if (!inputArray.length) {
        throw new Error(`FaceRecognizer.constructor - expected atleast one input`);
      }
      let count = 1;
      const createUniqueLabel = () => `person ${count++}`;
      this._labeledDescriptors = inputArray.map((desc) => {
        if (desc instanceof LabeledFaceDescriptors) {
          return desc;
        }
        if (desc instanceof Float32Array) {
          return new LabeledFaceDescriptors(createUniqueLabel(), [desc]);
        }
        if (desc.descriptor && desc.descriptor instanceof Float32Array) {
          return new LabeledFaceDescriptors(createUniqueLabel(), [desc.descriptor]);
        }
        throw new Error(`FaceRecognizer.constructor - expected inputs to be of type LabeledFaceDescriptors | WithFaceDescriptor<any> | Float32Array | Array<LabeledFaceDescriptors | WithFaceDescriptor<any> | Float32Array>`);
      });
    }
    get labeledDescriptors() {
      return this._labeledDescriptors;
    }
    get distanceThreshold() {
      return this._distanceThreshold;
    }
    computeMeanDistance(queryDescriptor, descriptors) {
      return descriptors.map((d) => euclideanDistance(d, queryDescriptor)).reduce((d1, d2) => d1 + d2, 0) / (descriptors.length || 1);
    }
    matchDescriptor(queryDescriptor) {
      return this.labeledDescriptors.map(({descriptors, label}) => new FaceMatch(label, this.computeMeanDistance(queryDescriptor, descriptors))).reduce((best, curr) => best.distance < curr.distance ? best : curr);
    }
    findBestMatch(queryDescriptor) {
      const bestMatch = this.matchDescriptor(queryDescriptor);
      return bestMatch.distance < this.distanceThreshold ? bestMatch : new FaceMatch("unknown", bestMatch.distance);
    }
    toJSON() {
      return {
        distanceThreshold: this.distanceThreshold,
        labeledDescriptors: this.labeledDescriptors.map((ld) => ld.toJSON())
      };
    }
    static fromJSON(json) {
      const labeledDescriptors = json.labeledDescriptors.map((ld) => LabeledFaceDescriptors.fromJSON(ld));
      return new FaceMatcher(labeledDescriptors, json.distanceThreshold);
    }
  }

  // build/src/globalApi/types.js

  // build/src/globalApi/index.js

  // build/src/tinyFaceDetector/index.js
  function createTinyFaceDetector(weights) {
    const net = new TinyFaceDetector();
    net.extractWeights(weights);
    return net;
  }

  // build/src/resizeResults.js
  function resizeResults(results, dimensions) {
    const {width, height} = new Dimensions(dimensions.width, dimensions.height);
    if (width <= 0 || height <= 0) {
      throw new Error(`resizeResults - invalid dimensions: ${JSON.stringify({width, height})}`);
    }
    if (Array.isArray(results)) {
      return results.map((obj) => resizeResults(obj, {width, height}));
    }
    if (isWithFaceLandmarks(results)) {
      const resizedDetection = results.detection.forSize(width, height);
      const resizedLandmarks = results.unshiftedLandmarks.forSize(resizedDetection.box.width, resizedDetection.box.height);
      return extendWithFaceLandmarks(extendWithFaceDetection(results, resizedDetection), resizedLandmarks);
    }
    if (isWithFaceDetection(results)) {
      return extendWithFaceDetection(results, results.detection.forSize(width, height));
    }
    if (results instanceof FaceLandmarks || results instanceof FaceDetection) {
      return results.forSize(width, height);
    }
    return results;
  }

  // build/package.json
  var version2 = "0.5.1";
  return require_src();
})();
//# sourceMappingURL=face-api.iife.js.map