text: import { __decorate, __metadata } from 'tslib';
  import { Input, Output, EventEmitter, ViewChild, Component, NgModule } from '@angular/core';
  import { CommonModule } from '@angular/common';
  import { Observable } from 'rxjs';
  
  /**
   * Container class for a captured webcam image
   * @author basst314, davidshen84
   */
  import * as ɵngcc0 from '@angular/core';
  import * as ɵngcc1 from '@angular/common';
  
  var _c0 = ["video"];
  var _c1 = ["canvas"];
  function WebcamComponent_div_3_Template(rf, ctx) { if (rf & 1) {
      var _r220 = ɵngcc0.ɵɵgetCurrentView();
      ɵngcc0.ɵɵelementStart(0, "div", 6);
      ɵngcc0.ɵɵlistener("click", function WebcamComponent_div_3_Template_div_click_0_listener($event) { ɵngcc0.ɵɵrestoreView(_r220); var ctx_r219 = ɵngcc0.ɵɵnextContext(); return ctx_r219.rotateVideoInput(true); });
      ɵngcc0.ɵɵelementEnd();
  } }
  var WebcamImage = /** @class */ (function () {
      function WebcamImage(imageAsDataUrl, mimeType, imageData) {
          this._mimeType = null;
          this._imageAsBase64 = null;
          this._imageAsDataUrl = null;
          this._imageData = null;
          this._mimeType = mimeType;
          this._imageAsDataUrl = imageAsDataUrl;
          this._imageData = imageData;
      }
      /**
       * Extracts the Base64 data out of the given dataUrl.
       * @param dataUrl the given dataUrl
       * @param mimeType the mimeType of the data
       */
      WebcamImage.getDataFromDataUrl = function (dataUrl, mimeType) {
          return dataUrl.replace("data:" + mimeType + ";base64,", '');
      };
      Object.defineProperty(WebcamImage.prototype, "imageAsBase64", {
          /**
           * Get the base64 encoded image data
           * @returns base64 data of the image
           */
          get: function () {
              return this._imageAsBase64 ? this._imageAsBase64
                  : this._imageAsBase64 = WebcamImage.getDataFromDataUrl(this._imageAsDataUrl, this._mimeType);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamImage.prototype, "imageAsDataUrl", {
          /**
           * Get the encoded image as dataUrl
           * @returns the dataUrl of the image
           */
          get: function () {
              return this._imageAsDataUrl;
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamImage.prototype, "imageData", {
          /**
           * Get the ImageData object associated with the canvas' 2d context.
           * @returns the ImageData of the canvas's 2d context.
           */
          get: function () {
              return this._imageData;
          },
          enumerable: true,
          configurable: true
      });
      return WebcamImage;
  }());
  
  var WebcamUtil = /** @class */ (function () {
      function WebcamUtil() {
      }
      /**
       * Lists available videoInput devices
       * @returns a list of media device info.
       */
      WebcamUtil.getAvailableVideoInputs = function () {
          if (!navigator.mediaDevices || !navigator.mediaDevices.enumerateDevices) {
              return Promise.reject('enumerateDevices() not supported.');
          }
          return new Promise(function (resolve, reject) {
              navigator.mediaDevices.enumerateDevices()
                  .then(function (devices) {
                  resolve(devices.filter(function (device) { return device.kind === 'videoinput'; }));
              })
                  .catch(function (err) {
                  reject(err.message || err);
              });
          });
      };
      return WebcamUtil;
  }());
  
  var WebcamComponent = /** @class */ (function () {
      function WebcamComponent() {
          /** Defines the max width of the webcam area in px */
          this.width = 640;
          /** Defines the max height of the webcam area in px */
          this.height = 480;
          /** Defines base constraints to apply when requesting video track from UserMedia */
          this.videoOptions = WebcamComponent_1.DEFAULT_VIDEO_OPTIONS;
          /** Flag to enable/disable camera switch. If enabled, a switch icon will be displayed if multiple cameras were found */
          this.allowCameraSwitch = true;
          /** Flag to control whether an ImageData object is stored into the WebcamImage object. */
          this.captureImageData = false;
          /** The image type to use when capturing snapshots */
          this.imageType = WebcamComponent_1.DEFAULT_IMAGE_TYPE;
          /** The image quality to use when capturing snapshots (number between 0 and 1) */
          this.imageQuality = WebcamComponent_1.DEFAULT_IMAGE_QUALITY;
          /** EventEmitter which fires when an image has been captured */
          this.imageCapture = new EventEmitter();
          /** Emits a mediaError if webcam cannot be initialized (e.g. missing user permissions) */
          this.initError = new EventEmitter();
          /** Emits when the webcam video was clicked */
          this.imageClick = new EventEmitter();
          /** Emits the active deviceId after the active video device was switched */
          this.cameraSwitched = new EventEmitter();
          /** available video devices */
          this.availableVideoInputs = [];
          /** Indicates whether the video device is ready to be switched */
          this.videoInitialized = false;
          /** Index of active video in availableVideoInputs */
          this.activeVideoInputIndex = -1;
          /** MediaStream object in use for streaming UserMedia data */
          this.mediaStream = null;
          /** width and height of the active video stream */
          this.activeVideoSettings = null;
      }
      WebcamComponent_1 = WebcamComponent;
      Object.defineProperty(WebcamComponent.prototype, "trigger", {
          /**
           * If the given Observable emits, an image will be captured and emitted through 'imageCapture' EventEmitter
           */
          set: function (trigger) {
              var _this = this;
              if (this.triggerSubscription) {
                  this.triggerSubscription.unsubscribe();
              }
              // Subscribe to events from this Observable to take snapshots
              this.triggerSubscription = trigger.subscribe(function () {
                  _this.takeSnapshot();
              });
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamComponent.prototype, "switchCamera", {
          /**
           * If the given Observable emits, the active webcam will be switched to the one indicated by the emitted value.
           * @param switchCamera Indicates which webcam to switch to
           *   true: cycle forwards through available webcams
           *   false: cycle backwards through available webcams
           *   string: activate the webcam with the given id
           */
          set: function (switchCamera) {
              var _this = this;
              if (this.switchCameraSubscription) {
                  this.switchCameraSubscription.unsubscribe();
              }
              // Subscribe to events from this Observable to switch video device
              this.switchCameraSubscription = switchCamera.subscribe(function (value) {
                  if (typeof value === 'string') {
                      // deviceId was specified
                      _this.switchToVideoInput(value);
                  }
                  else {
                      // direction was specified
                      _this.rotateVideoInput(value !== false);
                  }
              });
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Get MediaTrackConstraints to request streaming the given device
       * @param deviceId
       * @param baseMediaTrackConstraints base constraints to merge deviceId-constraint into
       * @returns
       */
      WebcamComponent.getMediaConstraintsForDevice = function (deviceId, baseMediaTrackConstraints) {
          var result = baseMediaTrackConstraints ? baseMediaTrackConstraints : this.DEFAULT_VIDEO_OPTIONS;
          if (deviceId) {
              result.deviceId = { exact: deviceId };
          }
          return result;
      };
      /**
       * Tries to harvest the deviceId from the given mediaStreamTrack object.
       * Browsers populate this object differently; this method tries some different approaches
       * to read the id.
       * @param mediaStreamTrack
       * @returns deviceId if found in the mediaStreamTrack
       */
      WebcamComponent.getDeviceIdFromMediaStreamTrack = function (mediaStreamTrack) {
          if (mediaStreamTrack.getSettings && mediaStreamTrack.getSettings() && mediaStreamTrack.getSettings().deviceId) {
              return mediaStreamTrack.getSettings().deviceId;
          }
          else if (mediaStreamTrack.getConstraints && mediaStreamTrack.getConstraints() && mediaStreamTrack.getConstraints().deviceId) {
              var deviceIdObj = mediaStreamTrack.getConstraints().deviceId;
              return WebcamComponent_1.getValueFromConstrainDOMString(deviceIdObj);
          }
      };
      /**
       * Tries to harvest the facingMode from the given mediaStreamTrack object.
       * Browsers populate this object differently; this method tries some different approaches
       * to read the value.
       * @param mediaStreamTrack
       * @returns facingMode if found in the mediaStreamTrack
       */
      WebcamComponent.getFacingModeFromMediaStreamTrack = function (mediaStreamTrack) {
          if (mediaStreamTrack) {
              if (mediaStreamTrack.getSettings && mediaStreamTrack.getSettings() && mediaStreamTrack.getSettings().facingMode) {
                  return mediaStreamTrack.getSettings().facingMode;
              }
              else if (mediaStreamTrack.getConstraints && mediaStreamTrack.getConstraints() && mediaStreamTrack.getConstraints().facingMode) {
                  var facingModeConstraint = mediaStreamTrack.getConstraints().facingMode;
                  return WebcamComponent_1.getValueFromConstrainDOMString(facingModeConstraint);
              }
          }
      };
      /**
       * Determines whether the given mediaStreamTrack claims itself as user facing
       * @param mediaStreamTrack
       */
      WebcamComponent.isUserFacing = function (mediaStreamTrack) {
          var facingMode = WebcamComponent_1.getFacingModeFromMediaStreamTrack(mediaStreamTrack);
          return facingMode ? 'user' === facingMode.toLowerCase() : false;
      };
      /**
       * Extracts the value from the given ConstrainDOMString
       * @param constrainDOMString
       */
      WebcamComponent.getValueFromConstrainDOMString = function (constrainDOMString) {
          if (constrainDOMString) {
              if (constrainDOMString instanceof String) {
                  return String(constrainDOMString);
              }
              else if (Array.isArray(constrainDOMString) && Array(constrainDOMString).length > 0) {
                  return String(constrainDOMString[0]);
              }
              else if (typeof constrainDOMString === 'object') {
                  if (constrainDOMString['exact']) {
                      return String(constrainDOMString['exact']);
                  }
                  else if (constrainDOMString['ideal']) {
                      return String(constrainDOMString['ideal']);
                  }
              }
          }
          return null;
      };
      WebcamComponent.prototype.ngAfterViewInit = function () {
          var _this = this;
          this.detectAvailableDevices()
              .then(function () {
              // start video
              _this.switchToVideoInput(null);
          })
              .catch(function (err) {
              _this.initError.next({ message: err });
              // fallback: still try to load webcam, even if device enumeration failed
              _this.switchToVideoInput(null);
          });
      };
      WebcamComponent.prototype.ngOnDestroy = function () {
          this.stopMediaTracks();
          this.unsubscribeFromSubscriptions();
      };
      /**
       * Takes a snapshot of the current webcam's view and emits the image as an event
       */
      WebcamComponent.prototype.takeSnapshot = function () {
          // set canvas size to actual video size
          var _video = this.nativeVideoElement;
          var dimensions = { width: this.width, height: this.height };
          if (_video.videoWidth) {
              dimensions.width = _video.videoWidth;
              dimensions.height = _video.videoHeight;
          }
          var _canvas = this.canvas.nativeElement;
          _canvas.width = dimensions.width;
          _canvas.height = dimensions.height;
          // paint snapshot image to canvas
          var context2d = _canvas.getContext('2d');
          context2d.drawImage(_video, 0, 0);
          // read canvas content as image
          var mimeType = this.imageType ? this.imageType : WebcamComponent_1.DEFAULT_IMAGE_TYPE;
          var quality = this.imageQuality ? this.imageQuality : WebcamComponent_1.DEFAULT_IMAGE_QUALITY;
          var dataUrl = _canvas.toDataURL(mimeType, quality);
          // get the ImageData object from the canvas' context.
          var imageData = null;
          if (this.captureImageData) {
              imageData = context2d.getImageData(0, 0, _canvas.width, _canvas.height);
          }
          this.imageCapture.next(new WebcamImage(dataUrl, mimeType, imageData));
      };
      /**
       * Switches to the next/previous video device
       * @param forward
       */
      WebcamComponent.prototype.rotateVideoInput = function (forward) {
          if (this.availableVideoInputs && this.availableVideoInputs.length > 1) {
              var increment = forward ? 1 : (this.availableVideoInputs.length - 1);
              var nextInputIndex = (this.activeVideoInputIndex + increment) % this.availableVideoInputs.length;
              this.switchToVideoInput(this.availableVideoInputs[nextInputIndex].deviceId);
          }
      };
      /**
       * Switches the camera-view to the specified video device
       */
      WebcamComponent.prototype.switchToVideoInput = function (deviceId) {
          this.videoInitialized = false;
          this.stopMediaTracks();
          this.initWebcam(deviceId, this.videoOptions);
      };
      /**
       * Event-handler for video resize event.
       * Triggers Angular change detection so that new video dimensions get applied
       */
      WebcamComponent.prototype.videoResize = function () {
          // here to trigger Angular change detection
      };
      Object.defineProperty(WebcamComponent.prototype, "videoWidth", {
          get: function () {
              var videoRatio = this.getVideoAspectRatio();
              return Math.min(this.width, this.height * videoRatio);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamComponent.prototype, "videoHeight", {
          get: function () {
              var videoRatio = this.getVideoAspectRatio();
              return Math.min(this.height, this.width / videoRatio);
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamComponent.prototype, "videoStyleClasses", {
          get: function () {
              var classes = '';
              if (this.isMirrorImage()) {
                  classes += 'mirrored ';
              }
              return classes.trim();
          },
          enumerable: true,
          configurable: true
      });
      Object.defineProperty(WebcamComponent.prototype, "nativeVideoElement", {
          get: function () {
              return this.video.nativeElement;
          },
          enumerable: true,
          configurable: true
      });
      /**
       * Returns the video aspect ratio of the active video stream
       */
      WebcamComponent.prototype.getVideoAspectRatio = function () {
          // calculate ratio from video element dimensions if present
          var videoElement = this.nativeVideoElement;
          if (videoElement.videoWidth && videoElement.videoWidth > 0 &&
              videoElement.videoHeight && videoElement.videoHeight > 0) {
              return videoElement.videoWidth / videoElement.videoHeight;
          }
          // nothing present - calculate ratio based on width/height params
          return this.width / this.height;
      };
      /**
       * Init webcam live view
       */
      WebcamComponent.prototype.initWebcam = function (deviceId, userVideoTrackConstraints) {
          var _this = this;
          var _video = this.nativeVideoElement;
          if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
              // merge deviceId -> userVideoTrackConstraints
              var videoTrackConstraints = WebcamComponent_1.getMediaConstraintsForDevice(deviceId, userVideoTrackConstraints);
              navigator.mediaDevices.getUserMedia({ video: videoTrackConstraints })
                  .then(function (stream) {
                  _this.mediaStream = stream;
                  _video.srcObject = stream;
                  _video.play();
                  _this.activeVideoSettings = stream.getVideoTracks()[0].getSettings();
                  var activeDeviceId = WebcamComponent_1.getDeviceIdFromMediaStreamTrack(stream.getVideoTracks()[0]);
                  _this.cameraSwitched.next(activeDeviceId);
                  // Initial detect may run before user gave permissions, returning no deviceIds. This prevents later camera switches. (#47)
                  // Run detect once again within getUserMedia callback, to make sure this time we have permissions and get deviceIds.
                  _this.detectAvailableDevices()
                      .then(function () {
                      _this.activeVideoInputIndex = activeDeviceId ? _this.availableVideoInputs
                          .findIndex(function (mediaDeviceInfo) { return mediaDeviceInfo.deviceId === activeDeviceId; }) : -1;
                      _this.videoInitialized = true;
                  })
                      .catch(function () {
                      _this.activeVideoInputIndex = -1;
                      _this.videoInitialized = true;
                  });
              })
                  .catch(function (err) {
                  _this.initError.next({ message: err.message, mediaStreamError: err });
              });
          }
          else {
              this.initError.next({ message: 'Cannot read UserMedia from MediaDevices.' });
          }
      };
      WebcamComponent.prototype.getActiveVideoTrack = function () {
          return this.mediaStream ? this.mediaStream.getVideoTracks()[0] : null;
      };
      WebcamComponent.prototype.isMirrorImage = function () {
          if (!this.getActiveVideoTrack()) {
              return false;
          }
          // check for explicit mirror override parameter
          {
              var mirror = 'auto';
              if (this.mirrorImage) {
                  if (typeof this.mirrorImage === 'string') {
                      mirror = String(this.mirrorImage).toLowerCase();
                  }
                  else {
                      // WebcamMirrorProperties
                      if (this.mirrorImage.x) {
                          mirror = this.mirrorImage.x.toLowerCase();
                      }
                  }
              }
              switch (mirror) {
                  case 'always':
                      return true;
                  case 'never':
                      return false;
              }
          }
          // default: enable mirroring if webcam is user facing
          return WebcamComponent_1.isUserFacing(this.getActiveVideoTrack());
      };
      /**
       * Stops all active media tracks.
       * This prevents the webcam from being indicated as active,
       * even if it is no longer used by this component.
       */
      WebcamComponent.prototype.stopMediaTracks = function () {
          if (this.mediaStream && this.mediaStream.getTracks) {
              // getTracks() returns all media tracks (video+audio)
              this.mediaStream.getTracks()
                  .forEach(function (track) { return track.stop(); });
          }
      };
      /**
       * Unsubscribe from all open subscriptions
       */
      WebcamComponent.prototype.unsubscribeFromSubscriptions = function () {
          if (this.triggerSubscription) {
              this.triggerSubscription.unsubscribe();
          }
          if (this.switchCameraSubscription) {
              this.switchCameraSubscription.unsubscribe();
          }
      };
      /**
       * Reads available input devices
       */
      WebcamComponent.prototype.detectAvailableDevices = function () {
          var _this = this;
          return new Promise(function (resolve, reject) {
              WebcamUtil.getAvailableVideoInputs()
                  .then(function (devices) {
                  _this.availableVideoInputs = devices;
                  resolve(devices);
              })
                  .catch(function (err) {
                  _this.availableVideoInputs = [];
                  reject(err);
              });
          });
      };
      var WebcamComponent_1;
      WebcamComponent.DEFAULT_VIDEO_OPTIONS = { facingMode: 'environment' };
      WebcamComponent.DEFAULT_IMAGE_TYPE = 'image/jpeg';
      WebcamComponent.DEFAULT_IMAGE_QUALITY = 0.92;
      __decorate([
          Input(),
          __metadata("design:type", Number)
      ], WebcamComponent.prototype, "width", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Number)
      ], WebcamComponent.prototype, "height", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Object)
      ], WebcamComponent.prototype, "videoOptions", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Boolean)
      ], WebcamComponent.prototype, "allowCameraSwitch", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Object)
      ], WebcamComponent.prototype, "mirrorImage", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Boolean)
      ], WebcamComponent.prototype, "captureImageData", void 0);
      __decorate([
          Input(),
          __metadata("design:type", String)
      ], WebcamComponent.prototype, "imageType", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Number)
      ], WebcamComponent.prototype, "imageQuality", void 0);
      __decorate([
          Output(),
          __metadata("design:type", EventEmitter)
      ], WebcamComponent.prototype, "imageCapture", void 0);
      __decorate([
          Output(),
          __metadata("design:type", EventEmitter)
      ], WebcamComponent.prototype, "initError", void 0);
      __decorate([
          Output(),
          __metadata("design:type", EventEmitter)
      ], WebcamComponent.prototype, "imageClick", void 0);
      __decorate([
          Output(),
          __metadata("design:type", EventEmitter)
      ], WebcamComponent.prototype, "cameraSwitched", void 0);
      __decorate([
          ViewChild('video', { static: true }),
          __metadata("design:type", Object)
      ], WebcamComponent.prototype, "video", void 0);
      __decorate([
          ViewChild('canvas', { static: true }),
          __metadata("design:type", Object)
      ], WebcamComponent.prototype, "canvas", void 0);
      __decorate([
          Input(),
          __metadata("design:type", Observable),
          __metadata("design:paramtypes", [Observable])
      ], WebcamComponent.prototype, "trigger", null);
      __decorate([
          Input(),
          __metadata("design:type", Observable),
          __metadata("design:paramtypes", [Observable])
      ], WebcamComponent.prototype, "switchCamera", null);
  WebcamComponent.ɵfac = function WebcamComponent_Factory(t) { return new (t || WebcamComponent)(); };
  WebcamComponent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: WebcamComponent, selectors: [["webcam"]], viewQuery: function WebcamComponent_Query(rf, ctx) { if (rf & 1) {
          ɵngcc0.ɵɵstaticViewQuery(_c0, true);
          ɵngcc0.ɵɵstaticViewQuery(_c1, true);
      } if (rf & 2) {
          var _t;
          ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.video = _t.first);
          ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.canvas = _t.first);
      } }, inputs: { width: "width", height: "height", videoOptions: "videoOptions", allowCameraSwitch: "allowCameraSwitch", captureImageData: "captureImageData", imageType: "imageType", imageQuality: "imageQuality", trigger: "trigger", switchCamera: "switchCamera", mirrorImage: "mirrorImage" }, outputs: { imageCapture: "imageCapture", initError: "initError", imageClick: "imageClick", cameraSwitched: "cameraSwitched" }, decls: 6, vars: 7, consts: [[1, "webcam-wrapper", 3, "click"], ["autoplay", "", "muted", "", "playsinline", "", 3, "width", "height", "resize"], ["video", ""], ["class", "camera-switch", 3, "click", 4, "ngIf"], [3, "width", "height"], ["canvas", ""], [1, "camera-switch", 3, "click"]], template: function WebcamComponent_Template(rf, ctx) { if (rf & 1) {
          ɵngcc0.ɵɵelementStart(0, "div", 0);
          ɵngcc0.ɵɵlistener("click", function WebcamComponent_Template_div_click_0_listener($event) { return ctx.imageClick.next(); });
          ɵngcc0.ɵɵelementStart(1, "video", 1, 2);
          ɵngcc0.ɵɵlistener("resize", function WebcamComponent_Template_video_resize_1_listener($event) { return ctx.videoResize(); });
          ɵngcc0.ɵɵelementEnd();
          ɵngcc0.ɵɵtemplate(3, WebcamComponent_div_3_Template, 1, 0, "div", 3);
          ɵngcc0.ɵɵelement(4, "canvas", 4, 5);
          ɵngcc0.ɵɵelementEnd();
      } if (rf & 2) {
          ɵngcc0.ɵɵadvance(1);
          ɵngcc0.ɵɵclassMap(ctx.videoStyleClasses);
          ɵngcc0.ɵɵproperty("width", ctx.videoWidth)("height", ctx.videoHeight);
          ɵngcc0.ɵɵadvance(2);
          ɵngcc0.ɵɵproperty("ngIf", ctx.allowCameraSwitch && ctx.availableVideoInputs.length > 1 && ctx.videoInitialized);
          ɵngcc0.ɵɵadvance(1);
          ɵngcc0.ɵɵproperty("width", ctx.width)("height", ctx.height);
      } }, directives: [ɵngcc1.NgIf], styles: [".webcam-wrapper[_ngcontent-%COMP%]{display:inline-block;position:relative;line-height:0}.webcam-wrapper[_ngcontent-%COMP%]   video.mirrored[_ngcontent-%COMP%]{transform:scale(-1,1)}.webcam-wrapper[_ngcontent-%COMP%]   canvas[_ngcontent-%COMP%]{display:none}.webcam-wrapper[_ngcontent-%COMP%]   .camera-switch[_ngcontent-%COMP%]{background-color:rgba(0,0,0,.1);background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAE9UlEQVR42u2aT2hdRRTGf+cRQqghSqihdBFDkRISK2KDfzDWxHaRQHEhaINKqa1gKQhd6EZLN+IidCH+Q0oWIkVRC21BQxXRitVaSbKoJSGtYGoK2tQ/tU1jY5v0c5F54Xl7b/KSO/PyEt+3e5f75p7zzZwzZ74zUEIJJfyfYaEGllQGVAGZlENdBy6Z2cSiYFTSKkkfS/pH/nBF0kFJdUW9AiRVASeAukD8DgNrzOySrwEzng18KaDzALXuG8W3AiStAvqBisBRNg40mtlPxbYCOgvgPO4bncWW+JpVeDQXRQhIygDfA00F5r0XuNfMrgclQFI98DDQCNQA5ZFXqoCWBVp8XwHRHeEqcN7loy/NbHBesyqpQ1KfFj/6nC+ZvFaApFrgPaCZpYVvgCfNbDiRAElNwGFg+RIt/X8H2s2s9wYCJDUAR4HqJX7++RN40MwGpgmQVAH0AQ2BPz4AHHPl8nBOAqtyFWQjsA6oL4Ada81sPDv7uwImod8kvSJp9RyS8O2SXnb/DYVd2Y9VSroQ4ANXJO2WVJmixqh0kzMWwL4LkiqRtDnA4D1zmfE8j9g9AezcnAHaPcfXdbfdnPZ2Yps6+DwAvO/Z1naTdApY7Xng48BDZnY1MpMVQBuw3iXc5Tnb0wBwBPjUzP6eoezuArZ6svM0geJLkvZEYnl3nkntoqROSbckSW2Suj3ZOIangc7GPJuUtNGdFIfmMeavktoSSKiW9LMPw30Q8JqkekmjCbOZRhuclLQjgYSNxUBAj6RyZ9ATgUJpUtJTCSR8vpAEXHAyWK5BXYFIGHOlepSAloUk4NEYgyoknQhEwhFJ0e8h6VSaQeerCb5uZgdi9utxYBNwOUD93hIVXswM4INCi6K9wAszFC2DwLOBDjHbYp59karIUnRdzYy/3ClqVklaUhfwTICj7K25OqA7a4wWagVsm4Me/xzwg2cCqqONFzO7DPxSCAJi436GUBgHHguQD2oTlJ55oSzP9ybccsttSJw1szdjFOSnI/8dTCGZHwcORp4Nx7y3B1iZ8/sm4MW8/Euxg5wIsS/HaAp3zeP4/G7obRDXI4jiTIA22H7Xdc7X+S3A5lC7QBQ357aq3VAjCeSkwUfAJrfvz+R8A9ADLAtZB+TinpjC5JMA+//jwPZZnF8G7J+L8z4IWB/zbG+gIujVWfLBW/NStVMmqaG4POJRsIjix7h8IGnLQuoBbQki5sVAJHyYm7YkNaRRtXwQ8G1cHpX0iKRrgUjYno17Sf0LrQhJUkdCeHWkVITGJI0k1QeS3ikGSUzOyJUJJNznYneuOCnpTldcxa2kP3xJYqOeSDjqZG8ShJLnE8TTuMS6Iyu1BW7djZqkfo9N0QOuYJmYQddfB7RG+gLTNzqAY9FrL+5/nwEbvDdJJe3zzOrhNP3AWRqmk55t3ZcBuj3b2gb0Sbrbo/NNzk7fFzu7s/E5EiC+rrmeQU0Kx2skvRFoOx2ZzlmSdgbsw49JetvtBpk8nM64d/cGbNtJ0s7cGyJlwHeEv+t3nqnLSgPAUOSGyG3AHUxdzqoJbEcvcL+ZTeTeEapzJKxgaeOcc/7Mf06D7kFrguS0VDAMtGadv+E47DT9tcChJej8ISfpD+abgTe45uOkFi8mnQ+JBVQ+d4VXuOptjavcyot8pq86mfwk8LWZnaOEEkoooYQSSojDv8AhQNeGfe0jAAAAAElFTkSuQmCC);background-repeat:no-repeat;border-radius:5px;position:absolute;right:13px;top:10px;height:48px;width:48px;background-size:80%;cursor:pointer;background-position:center;transition:background-color .2s}.webcam-wrapper[_ngcontent-%COMP%]   .camera-switch[_ngcontent-%COMP%]:hover{background-color:rgba(0,0,0,.18)}"] });
  /*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(WebcamComponent, [{
          type: Component,
          args: [{
                  selector: 'webcam',
                  template: "<div class=\"webcam-wrapper\" (click)=\"imageClick.next();\">\r\n  <video #video [width]=\"videoWidth\" [height]=\"videoHeight\" [class]=\"videoStyleClasses\" autoplay muted playsinline (resize)=\"videoResize()\"></video>\r\n  <div class=\"camera-switch\" *ngIf=\"allowCameraSwitch && availableVideoInputs.length > 1 && videoInitialized\" (click)=\"rotateVideoInput(true)\"></div>\r\n  <canvas #canvas [width]=\"width\" [height]=\"height\"></canvas>\r\n</div>\r\n",
                  styles: [".webcam-wrapper{display:inline-block;position:relative;line-height:0}.webcam-wrapper video.mirrored{transform:scale(-1,1)}.webcam-wrapper canvas{display:none}.webcam-wrapper .camera-switch{background-color:rgba(0,0,0,.1);background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAAE9UlEQVR42u2aT2hdRRTGf+cRQqghSqihdBFDkRISK2KDfzDWxHaRQHEhaINKqa1gKQhd6EZLN+IidCH+Q0oWIkVRC21BQxXRitVaSbKoJSGtYGoK2tQ/tU1jY5v0c5F54Xl7b/KSO/PyEt+3e5f75p7zzZwzZ74zUEIJJfyfYaEGllQGVAGZlENdBy6Z2cSiYFTSKkkfS/pH/nBF0kFJdUW9AiRVASeAukD8DgNrzOySrwEzng18KaDzALXuG8W3AiStAvqBisBRNg40mtlPxbYCOgvgPO4bncWW+JpVeDQXRQhIygDfA00F5r0XuNfMrgclQFI98DDQCNQA5ZFXqoCWBVp8XwHRHeEqcN7loy/NbHBesyqpQ1KfFj/6nC+ZvFaApFrgPaCZpYVvgCfNbDiRAElNwGFg+RIt/X8H2s2s9wYCJDUAR4HqJX7++RN40MwGpgmQVAH0AQ2BPz4AHHPl8nBOAqtyFWQjsA6oL4Ada81sPDv7uwImod8kvSJp9RyS8O2SXnb/DYVd2Y9VSroQ4ANXJO2WVJmixqh0kzMWwL4LkiqRtDnA4D1zmfE8j9g9AezcnAHaPcfXdbfdnPZ2Yps6+DwAvO/Z1naTdApY7Xng48BDZnY1MpMVQBuw3iXc5Tnb0wBwBPjUzP6eoezuArZ6svM0geJLkvZEYnl3nkntoqROSbckSW2Suj3ZOIangc7GPJuUtNGdFIfmMeavktoSSKiW9LMPw30Q8JqkekmjCbOZRhuclLQjgYSNxUBAj6RyZ9ATgUJpUtJTCSR8vpAEXHAyWK5BXYFIGHOlepSAloUk4NEYgyoknQhEwhFJ0e8h6VSaQeerCb5uZgdi9utxYBNwOUD93hIVXswM4INCi6K9wAszFC2DwLOBDjHbYp59karIUnRdzYy/3ClqVklaUhfwTICj7K25OqA7a4wWagVsm4Me/xzwg2cCqqONFzO7DPxSCAJi436GUBgHHguQD2oTlJ55oSzP9ybccsttSJw1szdjFOSnI/8dTCGZHwcORp4Nx7y3B1iZ8/sm4MW8/Euxg5wIsS/HaAp3zeP4/G7obRDXI4jiTIA22H7Xdc7X+S3A5lC7QBQ357aq3VAjCeSkwUfAJrfvz+R8A9ADLAtZB+TinpjC5JMA+//jwPZZnF8G7J+L8z4IWB/zbG+gIujVWfLBW/NStVMmqaG4POJRsIjix7h8IGnLQuoBbQki5sVAJHyYm7YkNaRRtXwQ8G1cHpX0iKRrgUjYno17Sf0LrQhJUkdCeHWkVITGJI0k1QeS3ikGSUzOyJUJJNznYneuOCnpTldcxa2kP3xJYqOeSDjqZG8ShJLnE8TTuMS6Iyu1BW7djZqkfo9N0QOuYJmYQddfB7RG+gLTNzqAY9FrL+5/nwEbvDdJJe3zzOrhNP3AWRqmk55t3ZcBuj3b2gb0Sbrbo/NNzk7fFzu7s/E5EiC+rrmeQU0Kx2skvRFoOx2ZzlmSdgbsw49JetvtBpk8nM64d/cGbNtJ0s7cGyJlwHeEv+t3nqnLSgPAUOSGyG3AHUxdzqoJbEcvcL+ZTeTeEapzJKxgaeOcc/7Mf06D7kFrguS0VDAMtGadv+E47DT9tcChJej8ISfpD+abgTe45uOkFi8mnQ+JBVQ+d4VXuOptjavcyot8pq86mfwk8LWZnaOEEkoooYQSSojDv8AhQNeGfe0jAAAAAElFTkSuQmCC);background-repeat:no-repeat;border-radius:5px;position:absolute;right:13px;top:10px;height:48px;width:48px;background-size:80%;cursor:pointer;background-position:center;transition:background-color .2s}.webcam-wrapper .camera-switch:hover{background-color:rgba(0,0,0,.18)}"]
              }]
      }], function () { return []; }, { width: [{
              type: Input
          }], height: [{
              type: Input
          }], videoOptions: [{
              type: Input
          }], allowCameraSwitch: [{
              type: Input
          }], captureImageData: [{
              type: Input
          }], imageType: [{
              type: Input
          }], imageQuality: [{
              type: Input
          }], imageCapture: [{
              type: Output
          }], initError: [{
              type: Output
          }], imageClick: [{
              type: Output
          }], cameraSwitched: [{
              type: Output
          }], trigger: [{
              type: Input
          }], switchCamera: [{
              type: Input
          }], mirrorImage: [{
              type: Input
          }], video: [{
              type: ViewChild,
              args: ['video', { static: true }]
          }], canvas: [{
              type: ViewChild,
              args: ['canvas', { static: true }]
          }] }); })();
      return WebcamComponent;
  }());
  
  var COMPONENTS = [
      WebcamComponent
  ];
  var WebcamModule = /** @class */ (function () {
      function WebcamModule() {
      }
  WebcamModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: WebcamModule });
  WebcamModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ factory: function WebcamModule_Factory(t) { return new (t || WebcamModule)(); }, imports: [[
              CommonModule
          ]] });
  (function () { (typeof ngJitMode === "undefined" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(WebcamModule, { declarations: function () { return [WebcamComponent]; }, imports: function () { return [CommonModule]; }, exports: function () { return [WebcamComponent]; } }); })();
  /*@__PURE__*/ (function () { ɵngcc0.ɵsetClassMetadata(WebcamModule, [{
          type: NgModule,
          args: [{
                  imports: [
                      CommonModule
                  ],
                  declarations: [
                      COMPONENTS
                  ],
                  exports: [
                      COMPONENTS
                  ]
              }]
      }], function () { return []; }, null); })();
      return WebcamModule;
  }());
  
  var WebcamInitError = /** @class */ (function () {
      function WebcamInitError() {
          this.message = null;
          this.mediaStreamError = null;
      }
      return WebcamInitError;
  }());
  
  var WebcamMirrorProperties = /** @class */ (function () {
      function WebcamMirrorProperties() {
      }
      return WebcamMirrorProperties;
  }());
  
  export { WebcamComponent, WebcamImage, WebcamInitError, WebcamMirrorProperties, WebcamModule, WebcamUtil };
  
  //# sourceMappingURL=ngx-webcam.js.map