{"version":3,"file":"906.chunk.js","mappings":"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","sources":["../node_modules/@luxottica/vm-plugin-glasses-removal/src/components/GlassesRemovalRenderer.ts","../node_modules/@luxottica/vm-plugin-glasses-removal/src/components/GlassesDetector.ts","../node_modules/@luxottica/vm-plugin-glasses-removal/src/GlassesRemovalPlugin.ts","../node_modules/@luxottica/vm-plugin-glasses-removal/src/helpers/CallbackHelper.ts","../node_modules/@luxottica/vm-plugin-glasses-removal/src/components/libs/utils/FaceMeshUtils.ts","../node_modules/@luxottica/virtual-mirror/src/plugins/GlassesRemovalEffect.ts","../node_modules/@protobufjs/aspromise/index.js","../node_modules/@protobufjs/base64/index.js","../node_modules/@protobufjs/eventemitter/index.js","../node_modules/@protobufjs/float/index.js","../node_modules/@protobufjs/inquire/index.js","../node_modules/@protobufjs/pool/index.js","../node_modules/@protobufjs/utf8/index.js","../node_modules/gl-matrix/esm/common.js","../node_modules/gl-matrix/esm/mat3.js","../node_modules/gl-matrix/esm/mat4.js","../node_modules/gl-matrix/esm/quat.js","../node_modules/gl-matrix/esm/vec3.js","../node_modules/gl-matrix/esm/vec4.js","../node_modules/@babel/runtime/helpers/esm/superPropBase.js","../node_modules/@babel/runtime/helpers/esm/get.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/math/fit.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/compare/compare.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/compare/numeric.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/math/abs.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/math/interval.js","../node_modules/@thi.ng/ramp/aramp.js","../node_modules/@thi.ng/ramp/node_modules/@thi.ng/arrays/binary-search.js","../node_modules/@thi.ng/ramp/linear.js"],"sourcesContent":["import * as tf from '@tensorflow/tfjs';\n\n// Utility\nimport { Tensor3D } from '@tensorflow/tfjs';\nimport { GlassesRemovalRenderParameters } from '../GlassesRemovalPlugin';\nimport { CallbackHelper } from '../helpers/CallbackHelper';\nimport { getEyeAreaPath, scaledPointList, shouldRender } from './libs/utils/FaceMeshUtils';\nimport { ModelSize, TGlassesDevModelsUrl } from '../interfaces/GlassesRemovalConfig';\n\n// Canvases\nlet faceCropCanvas: HTMLCanvasElement;\nlet faceCropContext: CanvasRenderingContext2D;\n\nlet glassesRemovalCanvas: HTMLCanvasElement;\nlet glassesRemovalContext: CanvasRenderingContext2D;\n\nlet previewCanvasCrop: HTMLCanvasElement;\nlet previewContextCrop: CanvasRenderingContext2D;\n\nlet previewCanvasOutput: HTMLCanvasElement;\nlet previewContextOutput: CanvasRenderingContext2D;\n\n// Models\nlet smallModelName = 'tfjs_unet_mobilenet_light_64';\nlet smallModel = undefined;\nlet smallLoadingStatus: LoadingStatus = 'FALSE';\nlet smallModelUrl = `https://vmcore-test.luxottica.com/headtracker/glasses-removal/0.0.0/${smallModelName}/model.json`;\n\nlet largeModelName = 'tfjs_unet_128_2M_prms';\nlet largeModel = undefined;\nlet largeLoadingStatus: LoadingStatus = 'FALSE';\nlet largeModelUrl = `https://vmcore-test.luxottica.com/headtracker/glasses-removal/0.0.0/${largeModelName}/model.json`;\n\nlet modelUpdated = true;\nlet initialized = false;\n\nconst fpsThreshold = 27;\nlet currentModelSize: ModelSize;\nconst getCurrentModel = () => (currentModelSize === 'SMALL') ? smallModel : largeModel;\nconst getCurrentResolution = () => (currentModelSize === 'SMALL') ? 64 : 128;\n\nconst GlassesRemovalRendererTFData = {\n  input: null,\n  expanded: null,\n  img: null,\n  prediction: null,\n  reduction: null,\n  squeeze: null\n};\n\nconst GlassesRemovalRenderer = {\n  shouldLoad: () => {\n    return !initialized;\n  },\n\n  initialize: (currentFps: number): Promise<void> => {\n    faceCropCanvas = document.createElement('canvas');\n    faceCropContext = faceCropCanvas.getContext('2d', { willReadFrequently: true });\n\n    glassesRemovalCanvas = document.createElement('canvas');\n    glassesRemovalCanvas.width = 128;\n    glassesRemovalCanvas.height = 128;\n    glassesRemovalContext = glassesRemovalCanvas.getContext('2d', { willReadFrequently: true });\n\n    initialized = true;\n\n    // PERMIT TO FORCE A MODEL FROM OUTSIDE AS A GLOBAL VARIABLE\n    // ADDED FOR MIDO FAIR 2024\n    if (window['vmForceGRModel'] && window['vmForceGRModel'] !== currentModelSize) {\n      currentModelSize = window['vmForceGRModel'];\n    }\n    if (currentModelSize === 'SMALL' || (currentFps < fpsThreshold && currentModelSize !== 'LARGE')) {\n      console.debug(`currentFps (${currentFps}) < fpsThreshold (${fpsThreshold}), loading SMALL model`);\n      return GlassesRemovalRenderer.setSmallModel();\n    } else {\n      console.debug(`currentFps (${currentFps}) >= fpsThreshold (${fpsThreshold}), loading LARGE model`);\n      return GlassesRemovalRenderer.setLargeModel();\n    }\n  },\n\n  setModelsUrl: (modelsUrl: TGlassesDevModelsUrl): void => {\n    if (modelsUrl.smallModelUrl) {\n      smallModelUrl = modelsUrl.smallModelUrl;\n      smallLoadingStatus = 'FALSE';\n    }\n\n    if (modelsUrl.largeModelUrl) {\n      largeModelUrl = modelsUrl.largeModelUrl;\n      largeLoadingStatus = 'FALSE';\n    }\n  },\n\n  updateDebug: (debug: boolean, debugCanvasContainer: HTMLElement = undefined): void => {\n    if (debug) {\n      if (!previewCanvasCrop) {\n        previewCanvasCrop = document.createElement('canvas') as HTMLCanvasElement;\n        previewCanvasCrop.id = 'preview_canvas_crop';\n        previewCanvasCrop.style.display = 'default';\n        previewCanvasCrop.style.position = 'absolute';\n        previewCanvasCrop.style.zIndex = '99';\n        previewCanvasCrop.style.transform = 'scaleX(-1.0)';\n        document.body.appendChild(previewCanvasCrop);\n        previewContextCrop = previewCanvasCrop.getContext('2d', { willReadFrequently: true });\n    \n        previewCanvasOutput = document.createElement('canvas') as HTMLCanvasElement;\n        previewCanvasOutput.id = 'preview_canvas_output';\n        previewCanvasOutput.style.display = 'default';\n        previewCanvasOutput.style.position = 'absolute';\n        previewCanvasOutput.style.zIndex = '99';\n        previewCanvasOutput.style.transform = 'scaleX(-1.0)';\n        document.body.appendChild(previewCanvasOutput);\n        previewContextOutput = previewCanvasOutput.getContext('2d', { willReadFrequently: true });\n      }\n\n      if (debugCanvasContainer) {\n        debugCanvasContainer.appendChild(previewCanvasCrop);\n        debugCanvasContainer.appendChild(previewCanvasOutput);\n      } else {\n        document.body.appendChild(previewCanvasCrop);\n        document.body.appendChild(previewCanvasOutput);\n      }\n\n    } else if (previewCanvasCrop !== undefined) {\n      if (debugCanvasContainer) {\n        debugCanvasContainer.removeChild(previewCanvasCrop);\n        previewCanvasCrop = undefined;\n        previewContextCrop = undefined;\n\n        debugCanvasContainer.removeChild(previewCanvasOutput);\n        previewCanvasOutput = undefined;\n        previewContextOutput = undefined;\n      } else {\n        document.body.removeChild(previewCanvasCrop);\n        previewCanvasCrop = undefined;\n        previewContextCrop = undefined;\n\n        document.body.removeChild(previewCanvasOutput);\n        previewCanvasOutput = undefined;\n        previewContextOutput = undefined;\n      }\n    }\n  },\n\n  ready: (): boolean => {\n    return getCurrentModel() !== undefined;\n  },\n\n  setSmallModel: async () => {\n    return new Promise<void>((resolve, reject) => {\n\n      if (smallLoadingStatus === 'FALSE') {\n        smallLoadingStatus = 'LOADING';\n\n        // Load model (small) - [start]\n        CallbackHelper.onLoadSMModelStart();\n\n        tf.loadGraphModel(smallModelUrl).then((model) => {\n\n          smallModel = model;\n          smallLoadingStatus = 'TRUE';\n          currentModelSize = 'SMALL';\n          modelUpdated = true;\n\n        // Load model (small) - [end]\n        CallbackHelper.onLoadSMModelEnd();\n\n          resolve();\n        }).catch((e) => { reject(e); });\n  \n      } else if (smallLoadingStatus = 'TRUE') {\n        currentModelSize = 'SMALL';\n        modelUpdated = true;\n        resolve();\n      } else {\n        resolve();\n      }\n    });\n  },\n\n  setLargeModel: async () => {\n    return new Promise<void>((resolve, reject) => {\n\n      if (largeLoadingStatus === 'FALSE') {\n        largeLoadingStatus = 'LOADING';\n        \n        // Load model (large) - [start]\n        CallbackHelper.onLoadLGModelStart();\n\n        console.log('Loading large model:', largeModelUrl);\n\n        return tf.loadGraphModel(largeModelUrl).then((model) => {\n\n\n          largeModel = model;\n          largeLoadingStatus = 'TRUE';\n          currentModelSize = 'LARGE';\n          modelUpdated = true;\n        \n          // Load model (large) - [end]\n          CallbackHelper.onLoadLGModelEnd();\n\n          resolve();\n        }).catch((e) => { reject(e); });\n  \n      } else if (largeLoadingStatus = 'TRUE') {\n        currentModelSize = 'LARGE';\n        modelUpdated = true;\n        resolve();\n      } else {\n        resolve();\n      }\n    });\n  },\n\n  render: async (parameters: GlassesRemovalRenderParameters): Promise<CanvasRenderingContext2D> => {\n\n    if (!parameters.faceMeshResults?.multiFaceLandmarks?.[0]) {\n      return parameters.context;\n    }\n\n    // PERMIT TO FORCE A MODEL FROM OUTSIDE AS A GLOBAL VARIABLE\n    // ADDED FOR MIDO FAIR 2024\n    if (window['vmForceGRModel'] && window['vmForceGRModel'] !== currentModelSize) {\n      if (currentModelSize === 'LARGE') {\n        await GlassesRemovalRenderer.setSmallModel();\n      } else {\n        await GlassesRemovalRenderer.setLargeModel();\n      }\n    }\n\n    GlassesRemovalRenderer.updateDebug(parameters.debug, parameters.debugCanvasContainer);\n\n    if (modelUpdated) {\n      glassesRemovalCanvas.width = getCurrentResolution();\n      glassesRemovalCanvas.height = getCurrentResolution();\n      modelUpdated = false;\n    }\n\n    const scrSize = {\n      width: parameters.context.canvas.width,\n      height: parameters.context.canvas.height\n    };\n    const facePoints = scaledPointList(\n      parameters.faceMeshResults.multiFaceLandmarks[0],\n      scrSize.width,\n      scrSize.height\n    );\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const pitch = (parameters.faceMeshResults as any).vtoPoseArray[2];\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const faceCoords = getEyeAreaPath(facePoints, (parameters.faceMeshResults as any).vtoPoseArray);\n\n    if (!shouldRender(scrSize, faceCoords)) {\n      return parameters.context;\n    }\n\n    faceCropCanvas.width = faceCoords.cropWidth;\n    faceCropCanvas.height = faceCoords.cropHeight;\n    faceCropContext.translate(\n      faceCropCanvas.width / 2,\n      faceCropCanvas.height / 2\n    );\n    faceCropContext.rotate(-pitch);\n    faceCropContext.drawImage(\n      parameters.faceMeshResults.image,\n      faceCoords.cropCenterX - (faceCoords.cropWidth / 2) - faceCoords.paddingX, //sx\n      faceCoords.cropCenterY - (faceCoords.cropHeight / 2) - faceCoords.paddingY, //sy\n      faceCoords.cropWidth + faceCoords.paddingX * 2, // sw\n      faceCoords.cropHeight + faceCoords.paddingY * 2, // sh\n      -faceCropCanvas.width / 2 - faceCoords.paddingX, // dx\n      -faceCropCanvas.height / 2 - faceCoords.paddingY, // dy\n      faceCropCanvas.width + faceCoords.paddingX * 2, // dWidth\n      faceCropCanvas.height + faceCoords.paddingY * 2 // dHeight\n    );\n    faceCropContext.resetTransform();\n\n    if (parameters.debug) {\n      previewContextCrop.drawImage(faceCropCanvas,\n        0, 0, faceCropCanvas.width, faceCropCanvas.height,\n        0, 0, previewCanvasCrop.width, previewCanvasCrop.height);\n    }\n\n    glassesRemovalContext.drawImage(faceCropCanvas,\n      0, 0, faceCropCanvas.width, faceCropCanvas.height,\n      0, 0, glassesRemovalCanvas.width, glassesRemovalCanvas.height);\n\n\n    // TODO: can this be removed? fromPixelsAsync should work with canvas input but doesnt\n    const cropImageData = glassesRemovalContext.getImageData(0, 0, glassesRemovalCanvas.width, glassesRemovalCanvas.height);\n\n    GlassesRemovalRendererTFData.img = await tf.browser.fromPixelsAsync(cropImageData);\n    GlassesRemovalRendererTFData.input = tf.tidy(() => tf.sub(tf.div(GlassesRemovalRendererTFData.img.toFloat(), 255.0), 0));\n    GlassesRemovalRendererTFData.expanded = GlassesRemovalRendererTFData.input.expandDims(0);\n\n    GlassesRemovalRendererTFData.prediction = await getCurrentModel().predict(GlassesRemovalRendererTFData.expanded, {\n      training: true,\n    });\n\n    GlassesRemovalRendererTFData.reduction = tf.tidy(() => tf.add(tf.mul(GlassesRemovalRendererTFData.prediction, 1.0), 0));\n    GlassesRemovalRendererTFData.squeeze = GlassesRemovalRendererTFData.reduction.squeeze();\n\n    await tf.browser.toPixels(GlassesRemovalRendererTFData.squeeze as Tensor3D, glassesRemovalCanvas);\n\n    GlassesRemovalRenderer.dispose();\n\n    if (parameters.debug) {\n      previewContextOutput.drawImage(\n        glassesRemovalCanvas,\n        0, 0, glassesRemovalCanvas.width, glassesRemovalCanvas.height,\n        0, 0, previewCanvasOutput.width, previewCanvasOutput.height);\n    }\n\n    parameters.context.translate(\n      faceCoords.cropCenterX,\n      faceCoords.cropCenterY,\n    );\n    parameters.context.rotate(pitch);\n    parameters.context.translate(\n      -faceCoords.cropCenterX,\n      -faceCoords.cropCenterY,\n    );\n    \n    parameters.context.drawImage(\n      glassesRemovalCanvas,\n      0, // sx\n      0, // sy\n      glassesRemovalCanvas.width, // sWidth\n      glassesRemovalCanvas.height, // sHeight\n      faceCoords.cropCenterX - (faceCropCanvas.width / 2), // dx\n      faceCoords.cropCenterY - (faceCropCanvas.height / 2), // dy\n      faceCropCanvas.width, // dWidth\n      faceCropCanvas.height, // dHeight\n    );\n    parameters.context.resetTransform();\n\n    return parameters.context;\n  },\n\n  getCurrentModelSize: (): ModelSize => {\n    return currentModelSize;\n  },\n\n  dispose: () : void => {\n    tf.dispose(GlassesRemovalRendererTFData);\n  },\n\n  disposeCanvases: (debug?: boolean, debugCanvasContainer: HTMLElement = undefined) => {\n    initialized = false;\n    largeModel = undefined;\n    largeLoadingStatus = 'FALSE';\n    smallModel = undefined;\n    smallLoadingStatus = 'FALSE';\n    \n    if(faceCropCanvas){\n      faceCropContext.clearRect(0, 0, faceCropCanvas.width, faceCropCanvas.height);\n      faceCropCanvas.width = 0;\n      faceCropCanvas.height = 0;\n      faceCropCanvas = null;\n      faceCropContext = null;\n    }\n    if(glassesRemovalCanvas){\n      glassesRemovalContext.clearRect(0, 0, glassesRemovalCanvas.width, glassesRemovalCanvas.height);\n      glassesRemovalCanvas.width = 0;\n      glassesRemovalCanvas.height = 0;\n      glassesRemovalCanvas = null;\n      glassesRemovalContext = null;\n    }\n\n    if (debug && previewCanvasCrop && previewCanvasOutput) {\n      previewContextCrop.clearRect(0, 0, previewCanvasCrop.width, previewCanvasCrop.height);\n      previewCanvasCrop.width = 0;\n      previewCanvasCrop.height = 0;\n\n      previewContextOutput.clearRect(0, 0, previewCanvasOutput.width, previewCanvasOutput.height);\n      previewCanvasOutput.width = 0;\n      previewCanvasOutput.height = 0;\n\n      if (debugCanvasContainer) {\n        debugCanvasContainer.removeChild(previewCanvasCrop);\n        debugCanvasContainer.removeChild(previewCanvasOutput);\n      } else {\n        document.body.removeChild(previewCanvasCrop);\n        document.body.removeChild(previewCanvasOutput);\n      }\n      \n      previewCanvasCrop = null;\n      previewContextCrop = null;\n      previewCanvasOutput = null;\n      previewContextOutput = null;\n    }\n  }\n    \n};\n\nexport { GlassesRemovalRenderer };\n","import * as tf from '@tensorflow/tfjs';\n\n// Utility\nimport { getEyeAreaPath, scaledPointList, shouldDetect } from './libs/utils/FaceMeshUtils';\nimport { GlassesRemovalRenderParameters } from '../GlassesRemovalPlugin';\nimport { CallbackHelper } from '../helpers/CallbackHelper';\nimport { TGlassesDevModelsUrl } from '../interfaces/GlassesRemovalConfig';\n\n// Variables\nconst detectModelName = 'unet_segm_iper_light_20_march_graph_model_tfjs';\n\n// Canvases\nlet faceCropCanvas: HTMLCanvasElement;\nlet faceCropContext: CanvasRenderingContext2D;\n\nlet glassesDetectionCanvas: HTMLCanvasElement;\nlet glassesDetectionContext: CanvasRenderingContext2D;\n\nlet previewCanvasDetectionGlass: HTMLCanvasElement;\nlet previewContextDetectionGlass: CanvasRenderingContext2D;\n\nlet detectModel = undefined;\nlet loadingStatus = 'FALSE';\nconst threshold = 0.012;\n\nlet isDetectedGlasses: boolean;\nlet detectModelUrl = `https://vmcore-test.luxottica.com/headtracker/glasses-removal/0.0.0/${detectModelName}/model.json`;\n\nconst GlassesDetectorTFData = {\n  img: null,\n  input: null,\n  expanded: null,\n  prediction: null,\n  sumT:null,\n  sum: null\n};\n\nconst GlassesDetector = {\n  initialize: (): Promise<void> => {\n    if (GlassesDetector.shouldLoad()) {\n\n    // GlassesDetector initialization time - [start]\n      CallbackHelper.onDetectInitStart();\n\n      // Load model\n      loadingStatus = 'LOADING';\n  \n      console.log('Loading detect model:', detectModelUrl);\n      \n      return tf.loadGraphModel(detectModelUrl).then((graphModel) => {\n        detectModel = graphModel;\n  \n        faceCropCanvas = document.createElement('canvas');\n        faceCropContext = faceCropCanvas.getContext('2d', { willReadFrequently: true });\n  \n        glassesDetectionCanvas = document.createElement('canvas');\n        glassesDetectionCanvas.width = 256;\n        glassesDetectionCanvas.height = 256;\n        glassesDetectionContext = glassesDetectionCanvas.getContext('2d', { willReadFrequently: true });\n\n        loadingStatus = 'TRUE';\n\n        // GlassesDetector initialization time - [end]\n        CallbackHelper.onDetectInitEnd();\n      });\n    }\n  },\n\n  setModelsUrl: (modelsUrl: TGlassesDevModelsUrl): void => {\n    if (modelsUrl.detectModelUrl) {\n      detectModelUrl = modelsUrl.detectModelUrl;\n      loadingStatus = 'FALSE';\n    }\n  },\n\n  updateDebug: (debug: boolean, debugCanvasContainer: HTMLElement = undefined): void => {\n    if (debug) {\n\n      if (!previewCanvasDetectionGlass) {\n        previewCanvasDetectionGlass = document.createElement('canvas') as HTMLCanvasElement;\n        previewCanvasDetectionGlass.id = 'preview_canvas_detection';\n        previewCanvasDetectionGlass.style.display = 'default';\n        previewCanvasDetectionGlass.style.position = 'absolute';\n        previewCanvasDetectionGlass.style.zIndex = '99';\n        previewCanvasDetectionGlass.style.transform = 'scaleX(-1.0)';\n        previewContextDetectionGlass = previewCanvasDetectionGlass.getContext('2d', { willReadFrequently: true });\n      }\n\n      if (debugCanvasContainer) {\n        debugCanvasContainer.appendChild(previewCanvasDetectionGlass);\n      } else {\n        document.body.appendChild(previewCanvasDetectionGlass);\n      }\n\n      if (isDetectedGlasses === true) {\n        previewCanvasDetectionGlass.style.borderColor = 'green';\n      } else {\n        previewCanvasDetectionGlass.style.borderColor = 'red';\n      }\n\n    } else if (previewCanvasDetectionGlass !== undefined) {\n      if (debugCanvasContainer) {\n        debugCanvasContainer.removeChild(previewCanvasDetectionGlass);\n        previewCanvasDetectionGlass = undefined;\n        previewContextDetectionGlass = undefined;\n      } else {\n        document.body.removeChild(previewCanvasDetectionGlass);\n        previewCanvasDetectionGlass = undefined;\n        previewContextDetectionGlass = undefined;\n      }\n    }\n  },\n\n  shouldLoad: () => {\n    return loadingStatus === 'FALSE' || loadingStatus === 'ERR';\n  },\n\n  ready: () => {\n    return loadingStatus === 'TRUE';\n  },\n\n  finalize: () => {\n    return;\n  },\n\n  detectGlasses: async (\n    parameters: GlassesRemovalRenderParameters,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    previousPose: any\n  ): Promise<boolean> => {\n\n    GlassesDetector.updateDebug(parameters.debug, parameters.debugCanvasContainer);\n\n    if (parameters?.faceMeshResults?.multiFaceLandmarks === undefined) {\n      return false;\n    }\n\n    if (parameters?.faceMeshResults?.multiFaceLandmarks[0] === undefined) {\n      return false;\n    }\n\n    const scrSize = {\n      width: parameters.context.canvas.width,\n      height: parameters.context.canvas.height\n    };\n\n    const facePoints = scaledPointList(\n      parameters.faceMeshResults.multiFaceLandmarks[0],\n      scrSize.width,\n      scrSize.height\n    );\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const faceCoords = getEyeAreaPath(facePoints, (parameters.faceMeshResults as any).vtoPoseArray);\n\n    if (\n      !shouldDetect(\n        scrSize,\n        faceCoords,\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (parameters.faceMeshResults as any).vtoPoseArray,\n        previousPose)\n      ) {\n      return undefined;\n    }\n\n  // full type info isnt imported\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const pitch = (parameters.faceMeshResults as any).vtoPoseArray[2];\n\n    faceCropCanvas.width = faceCoords.cropWidth;\n    faceCropCanvas.height = faceCoords.cropHeight;\n    faceCropContext.translate(\n      faceCropCanvas.width / 2,\n      faceCropCanvas.height / 2\n    );\n    faceCropContext.rotate(-pitch);\n    faceCropContext.drawImage(\n      parameters.faceMeshResults.image,\n      faceCoords.cropCenterX - (faceCoords.cropWidth / 2) - faceCoords.paddingX, //sx\n      faceCoords.cropCenterY - (faceCoords.cropHeight / 2) - faceCoords.paddingY, //sy\n      faceCoords.cropWidth + faceCoords.paddingX * 2, // sw\n      faceCoords.cropHeight + faceCoords.paddingY * 2, // sh\n      -faceCropCanvas.width / 2 - faceCoords.paddingX, // dx\n      -faceCropCanvas.height / 2 - faceCoords.paddingY, // dy\n      faceCropCanvas.width + faceCoords.paddingX * 2, // dWidth\n      faceCropCanvas.height + faceCoords.paddingY * 2 // dHeight\n    );\n    faceCropContext.resetTransform();\n    // Here am assuming the resize is done automatically as dst size != src size\n    glassesDetectionContext.drawImage(faceCropCanvas,\n      0, 0, faceCropCanvas.width, faceCropCanvas.height,\n      0, 0, glassesDetectionCanvas.width, glassesDetectionCanvas.height);\n\n    GlassesDetectorTFData.img = await tf.browser.fromPixelsAsync(glassesDetectionCanvas);\n    GlassesDetectorTFData.input = tf.tidy(() => tf.sub(tf.div(GlassesDetectorTFData.img.toFloat(), 255.0), 0));\n    GlassesDetectorTFData.expanded = GlassesDetectorTFData.input.expandDims(0);\n    GlassesDetectorTFData.prediction = await detectModel.predict(GlassesDetectorTFData.expanded);\n    GlassesDetectorTFData.sumT = tf.tidy(() => tf.div(tf.sum(GlassesDetectorTFData.prediction), 256.0 * 256.0));\n    GlassesDetectorTFData.sum =  await GlassesDetectorTFData.sumT.data();\n    // const tfData = await GlassesDetectorTFData.prediction.array();\n    // const tfDataFlat = tfData.flat()[0]; // Flatten tfData matrix into array\n\n    // isDetectedGlasses = tfDataFlat < 0.5 ? true : false\n    GlassesDetector.dispose();\n\n    if (parameters.debug) {\n      previewCanvasDetectionGlass.width = faceCoords.cropWidth;\n      previewCanvasDetectionGlass.height = faceCoords.cropHeight;\n      previewContextDetectionGlass.drawImage(faceCropCanvas, 0, 0);\n    }\n\n    isDetectedGlasses = (GlassesDetectorTFData.sum[0] > threshold);\n    return isDetectedGlasses;\n  },\n      \n  dispose: () : void => {\n    tf.dispose(GlassesDetectorTFData);\n  },\n\n  disposeCanvases: (debug?: boolean, debugCanvasContainer: HTMLElement = undefined) => {\n    loadingStatus = 'FALSE';\n    detectModel = undefined;\n\n    if(faceCropCanvas) {\n      faceCropContext.clearRect(0, 0, faceCropCanvas.width, faceCropCanvas.height);\n      faceCropCanvas.width = 0;\n      faceCropCanvas.height = 0;\n      faceCropCanvas = null;\n      faceCropContext = null;\n    }\n\n    if(glassesDetectionCanvas) {\n      glassesDetectionContext.clearRect(0, 0, glassesDetectionCanvas.width, glassesDetectionCanvas.height);\n      glassesDetectionCanvas.width = 0;\n      glassesDetectionCanvas.height = 0;\n      glassesDetectionCanvas = null;\n      glassesDetectionContext = null;\n    }\n\n    if (debug && previewCanvasDetectionGlass) {\n      previewContextDetectionGlass.clearRect(0, 0, previewCanvasDetectionGlass.width, previewCanvasDetectionGlass.height);\n      previewCanvasDetectionGlass.width = 0;\n      previewCanvasDetectionGlass.height = 0;\n\n      if (debugCanvasContainer) {\n        debugCanvasContainer.removeChild(previewCanvasDetectionGlass);\n      } else {\n        document.body.removeChild(previewCanvasDetectionGlass);\n      }\n\n      previewCanvasDetectionGlass = null;\n      previewContextDetectionGlass = null;\n    }\n  }\n    \n};\n\nexport { GlassesDetector };\n","import { version } from '../package.json';\n\n// Interfaces\nimport {\n  GlassesRemovalInitializeParameters,\n  GlassesRemovalRenderParameters,\n  GlassesRemovalState,\n  GrCallback,\n  TGlassesDevModelsUrl\n} from './interfaces/GlassesRemovalConfig';\n\nimport { GlassesRemovalRenderer } from './components/GlassesRemovalRenderer';\nimport { GlassesDetector } from './components/GlassesDetector';\nimport { CallbackHelper, setCallbacks } from './helpers/CallbackHelper';\n\nlet glassesDetectionInterval = 2000;\nlet glassesRenderingDetectionInterval = 4000;\n\nlet glassesDetected = false;\nlet previousDetectionTimestamp = 0;\n\nlet previousPose;\n\nlet stopDetectionCounter: number;\nlet stopDetection = false;\n\nlet stopGlassesDetectionAfterMs = 10000;\n\n\nlet glassesRemovalState: GlassesRemovalState = 'off';\nlet actionCallback: GrCallback;\n\nconst callbackAction = () => {\n  if (!actionCallback) return;\n  actionCallback({\n    message: glassesRemovalState,\n    details: {\n      state: glassesRemovalState,\n      modelSize: GlassesRemovalRenderer.getCurrentModelSize(),\n    },\n    pluginId: 'glasses-removal',\n  });\n};\n\nconst shouldDetectGlasses = (glassesDetected: boolean, hasFace: boolean): boolean => {\n  if (stopDetectionCounter === undefined && hasFace && !stopDetection && stopGlassesDetectionAfterMs > 0) {\n    stopDetectionCounter = window.setTimeout(() => {\n      stopDetection = true;\n      stopDetectionCounter = undefined;\n    }, stopGlassesDetectionAfterMs);\n  } else if (!hasFace || glassesDetected) {\n    window.clearTimeout(stopDetectionCounter);\n    stopDetectionCounter = undefined;\n    stopDetection = false;\n  }\n  const shouldDetect = (glassesDetected) ?\n    (Date.now() - previousDetectionTimestamp) > glassesRenderingDetectionInterval\n      :\n    (Date.now() - previousDetectionTimestamp) > glassesDetectionInterval;\n\n  return shouldDetect && !stopDetection;\n};\n\nlet forceGlassesRendererEnabled = false;\nconst forceGlassesRenderer = (enabled: boolean) => {\n  forceGlassesRendererEnabled = enabled;\n};\n\nconst GlassesRemovalPlugin = {\n  version(): string {\n    return version;\n  },\n\n  initialize(parameters: GlassesRemovalInitializeParameters): Promise<void> {\n    console.log('GlassesRemoval version:', version);\n    if (parameters?.glassesDetectionInterval !== undefined) {\n      glassesDetectionInterval = parameters.glassesDetectionInterval;\n    }\n    if (parameters?.glassesRenderingDetectionInterval !== undefined) {\n      glassesRenderingDetectionInterval = parameters.glassesRenderingDetectionInterval;\n    }\n    if (parameters?.stopGlassesDetectionAfterMs !== undefined) {\n      stopGlassesDetectionAfterMs = parameters.stopGlassesDetectionAfterMs;\n    }\n\n    if(parameters?.glassesDevModelsUrl !== undefined) {\n      GlassesDetector.setModelsUrl(parameters.glassesDevModelsUrl);\n      GlassesRemovalRenderer.setModelsUrl(parameters.glassesDevModelsUrl);\n    }\n\n    actionCallback = parameters?.actionCallback;\n    callbackAction();\n\n    setCallbacks(parameters?.callbacks);\n\n    return GlassesDetector.initialize();\n  },\n\n  render(parameters: GlassesRemovalRenderParameters): Promise<CanvasRenderingContext2D> {\n    if (parameters?.stopGlassesDetectionAfterMs !== undefined) {\n      stopGlassesDetectionAfterMs = parameters.stopGlassesDetectionAfterMs;\n    }\n    if (GlassesDetector.ready() && !!parameters.faceMeshResults) {\n      \n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      const shouldDetect = shouldDetectGlasses(glassesDetected, (parameters.faceMeshResults as any).hasFace);\n\n      if (shouldDetect) {\n        previousDetectionTimestamp = Date.now();\n\n        // GlassesDetector infer glasses presence - [start]\n        CallbackHelper.onGlassesPresenceStart();\n\n        GlassesDetector.detectGlasses(parameters, previousPose)\n        .then((detectionResult) => {\n          glassesDetected = (detectionResult !== undefined) ? detectionResult : glassesDetected;\n\n          // GlassesDetector infer glasses presence - [end]\n          CallbackHelper.onGlassesPresenceEnd();\n\n          if (detectionResult === true && GlassesRemovalRenderer.shouldLoad()) {\n            GlassesRemovalRenderer.initialize(parameters.fps);\n          }\n        });\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      if ((parameters?.faceMeshResults as any)?.vtoPoseArray !== undefined) {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        previousPose = [...(parameters.faceMeshResults as any).vtoPoseArray];\n      }\n\n      if (forceGlassesRendererEnabled) {\n        if (GlassesRemovalRenderer.ready()) {\n          if (glassesRemovalState !== 'active') {\n            glassesRemovalState = 'active';\n            callbackAction();\n          }\n          return GlassesRemovalRenderer.render(parameters);\n        } else if (GlassesRemovalRenderer.shouldLoad()){\n          GlassesRemovalRenderer.initialize(parameters.fps);\n        }\n\n      } else if (GlassesRemovalRenderer.ready() && glassesDetected) {\n        if (glassesRemovalState !== 'active') {\n          glassesRemovalState = 'active';\n          callbackAction();\n        }\n        return GlassesRemovalRenderer.render(parameters);\n      }\n\n      // we did not detect glasses, are we still detecting?\n      // understand this internal state is useful for external listeners\n      if (glassesRemovalState !== 'detecting' && shouldDetect) {\n        glassesRemovalState = 'detecting';\n        callbackAction();\n      } else if (glassesRemovalState !== 'off' && !shouldDetect && !glassesDetected && stopDetection) {\n        glassesRemovalState = 'off';\n        callbackAction();\n      }\n    }\n\n    return Promise.resolve(parameters.context);\n  },\n\n  dispose(debug?: boolean, debugCanvasContainer?: HTMLElement) {\n    GlassesDetector.disposeCanvases(debug, debugCanvasContainer);\n    GlassesRemovalRenderer.disposeCanvases(debug, debugCanvasContainer);\n  }\n};\n\nwindow['forceGlassesRenderer'] = forceGlassesRenderer;\n\nexport {\n  GlassesRemovalPlugin,\n  GlassesRemovalInitializeParameters,\n  GlassesRemovalRenderParameters,\n  GrCallback,\n  TGlassesDevModelsUrl\n};\n","import { GlassesRemovalCallbacks } from '../interfaces/GlassesRemovalCallbacks';\n\nexport {\n  CallbackHelper,\n  setCallbacks\n};\n\nconst setCallbacks = (\n  callbacks: GlassesRemovalCallbacks\n) => {\n  if (callbacks) {\n    if (callbacks.onGlassesPresenceStart) { CallbackHelper.onGlassesPresenceStart = callbacks.onGlassesPresenceStart; }\n    if (callbacks.onGlassesPresenceEnd) { CallbackHelper.onGlassesPresenceEnd = callbacks.onGlassesPresenceEnd; }\n    if (callbacks.onDetectInitStart) { CallbackHelper.onDetectInitStart = callbacks.onDetectInitStart; }\n    if (callbacks.onDetectInitEnd) { CallbackHelper.onDetectInitEnd = callbacks.onDetectInitEnd; }\n    if (callbacks.onLoadSMModelStart) { CallbackHelper.onLoadSMModelStart = callbacks.onLoadSMModelStart; }\n    if (callbacks.onLoadSMModelEnd) { CallbackHelper.onLoadSMModelEnd = callbacks.onLoadSMModelEnd; }\n    if (callbacks.onLoadLGModelStart) { CallbackHelper.onLoadLGModelStart = callbacks.onLoadLGModelStart; }\n    if (callbacks.onLoadLGModelEnd) { CallbackHelper.onLoadLGModelEnd = callbacks.onLoadLGModelEnd; }\n  }\n};\n\nconst CallbackHelper: GlassesRemovalCallbacks = {\n  onGlassesPresenceStart: () => { return; },\n  onGlassesPresenceEnd: () => { return; },\n  onDetectInitStart: () => { return; },\n  onDetectInitEnd: () => { return; },\n  onLoadSMModelStart: () => { return; },\n  onLoadSMModelEnd: () => { return; },\n  onLoadLGModelStart: () => { return; },\n  onLoadLGModelEnd: () => { return; },\n};\n","import type { NormalizedLandmarkList } from '@mediapipe/face_mesh';\n\nconst pointsInUse = [\n  4, // nose\n  9, // forehead\n  71,\n  151, // upper forehead\n  123, // bottom right cheeck\n  143, // right temple\n  301,\n  352, // bottom left cheek\n  372, // left temple\n  433\n];\n\nconst clamp = (min: number, value: number, max: number) => {\n  return Math.min(Math.max(value, min), max);\n};\n\nconst scaledPointList = (\n  pts: NormalizedLandmarkList,\n  width: number,\n  height: number\n): PointList => {\n  const list = {};\n\n  pointsInUse.forEach(p => {\n    list[p] = {\n      x: pts[p].x * width,\n      y: pts[p].y * height,\n    };\n  });\n  return list;\n};\n\nconst getEyeAreaPath = (\n  pts: PointList,\n  pose\n) => {\n\n  const pitch = pose[0];\n  const yaw = pose[1];\n  const roll = pose[2];\n\n  const widthScalar = 1.17 + Math.abs(yaw);\n  const widthPadding = Math.min(widthScalar, 2.0);\n\n  // const heightScalar = 1.15 - pitch;\n  // const heightPadding =  Math.max(1.1, Math.min(heightScalar, 1.2));\n  const heightPadding = clamp(1.17, 1.17 - pitch, 1.3);\n  // const heightPadding = 1.17;\n\n  // const minX = Math.min(pts[71].x, pts[123].x);\n  // const maxX = Math.max(pts[301].x, pts[433].x);\n  // const minY = Math.min(pts[71].y, pts[301].y);\n  // const maxY = Math.max(pts[123].y, pts[352].y);\n  // const width = (maxX - minX) * widthCropPadding;\n\n  const top = {\n    x: pts[9].x,\n    y: (pts[9].y + pts[151].y) / 2\n  };\n  const bottom = {\n    x: pts[4].x,\n    y: (pts[123].y + pts[352].y) / 2,\n  };\n  const leftEye = pts[143];\n  const rightEye = pts[372];\n\n  const width = Math.sqrt(Math.pow(rightEye.x - leftEye.x, 2) + Math.pow(leftEye.y - rightEye.y, 2));\n  const height = Math.sqrt(Math.pow(bottom.x - top.x, 2) + Math.pow(bottom.y - top.y, 2));\n\n  // console.info({\n  //   widthPadding: widthPadding.toFixed(3),\n  //   heightPadding: heightPadding.toFixed(3)\n  // });\n\n  const cropWidth = width * widthPadding;\n  const cropHeight = height * heightPadding;\n\n  const cropCenterX = (leftEye.x + rightEye.x) / 2;\n  const cropCenterY = (top.y + bottom.y) / 2;\n\n  const maxCropWidth = (cropWidth * Math.cos(Math.abs(roll))) + (cropHeight * Math.sin(Math.abs(roll)));\n  const maxCropHeight = (cropWidth * Math.sin(Math.abs(roll))) + (cropHeight * Math.cos(Math.abs(roll)));\n\n  return {\n    cropCenterX: cropCenterX,\n    cropCenterY: cropCenterY,\n    cropWidth: cropWidth,\n    cropHeight: cropHeight,\n    paddingX: (maxCropWidth - cropWidth) / 2,\n    paddingY: (maxCropHeight - cropHeight) / 2,\n  };\n};\n\nconst getSqaurePath = (\n  pts,\n  pose\n) => {\n\n  // const pitch = pose[0];\n  const yaw = pose[1];\n  const roll = pose[2];\n\n  const widthScalar = 1.17 + Math.abs(yaw);\n  const widthPadding = Math.min(widthScalar, 1.5);\n\n  // const heightScalar = 1.15 - pitch;\n  // const heightPadding =  Math.max(1.1, Math.min(heightScalar, 1.2));\n  const heightPadding = 1.17;\n\n  // const minX = Math.min(pts[71].x, pts[123].x);\n  // const maxX = Math.max(pts[301].x, pts[433].x);\n  // const minY = Math.min(pts[71].y, pts[301].y);\n  // const maxY = Math.max(pts[123].y, pts[352].y);\n  // const width = (maxX - minX) * widthCropPadding;\n  \n  //123 x 352\n\n  // const top = {\n  //   x: pts[9].x,\n  //   y: (pts[9].y + pts[151].y) / 2\n  // };\n  // const bottom = {\n  //   x: pts[4].x,\n  //   y: (pts[123].y + pts[352].y) / 2,\n  // };\n  const leftCheek = pts[123];\n  const rightCheek = pts[352];\n\n  const width = Math.sqrt(Math.pow(leftCheek.x - rightCheek.x, 2) + Math.pow(leftCheek.y - rightCheek.y, 2));\n  const height = width;\n\n  const cropWidth = width * widthPadding;\n  const cropHeight = height * heightPadding;\n\n  const cropCenterX = (leftCheek.x + rightCheek.x) / 2;\n  const cropCenterY = (leftCheek.y + rightCheek.y) / 2;\n\n  const maxCropWidth = (cropWidth * Math.cos(Math.abs(roll))) + (cropHeight * Math.sin(Math.abs(roll)));\n  const maxCropHeight = (cropWidth * Math.sin(Math.abs(roll))) + (cropHeight * Math.cos(Math.abs(roll)));\n\n  return {\n    cropCenterX: cropCenterX,\n    cropCenterY: cropCenterY,\n    cropWidth: cropWidth,\n    cropHeight: cropHeight,\n    paddingX: (maxCropWidth - cropWidth) / 2,\n    paddingY: (maxCropHeight - cropHeight) / 2,\n  };\n};\n\nconst pitchRange = (Math.PI / 180) * 15;\nconst yawRange = (Math.PI / 180) * 30;\nconst rollRange = (Math.PI / 180) * 30;\nconst velocityPositionThreshold = 0.01;\nconst velocityAngleThreshold = 0.02;\nconst shouldDetect = (\n  screenSize: { width: number; height: number },\n  faceCoords: {\n    cropCenterX: number;\n    cropCenterY: number;\n    cropWidth: number;\n    cropHeight: number;\n    paddingX: number;\n    paddingY: number;\n  },\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  currentPose: any,\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  previousPose: any\n): boolean => {\n    if (previousPose === undefined) {\n      return true;\n    }\n\n    const pitch = currentPose[0];\n    const yaw = currentPose[1];\n    const roll = currentPose[2];\n    const x = currentPose[3];\n    const y = currentPose[4];\n\n    const pitchDiff = Math.abs(previousPose[0] - pitch) / Math.PI;\n    const yawDiff = Math.abs(previousPose[1] - yaw) / Math.PI;\n    const rollDiff = Math.abs(previousPose[2] - roll) / Math.PI;\n    const xDiff = Math.abs(previousPose[3] - x) / screenSize.width;\n    const yDiff = Math.abs(previousPose[4] - y) / screenSize.height;\n\n    console.debug('poseDiff', {\n      pitch: pitchDiff.toFixed(3),\n      yaw: yawDiff.toFixed(3),\n      roll: rollDiff.toFixed(3),\n      x: xDiff.toFixed(3),\n      y: yDiff.toFixed(3),\n    });\n\n    return (\n      (faceCoords.cropCenterX - (faceCoords.cropWidth / 2)) > 0\n      && (faceCoords.cropCenterX + (faceCoords.cropWidth / 2)) < screenSize.width\n      && (faceCoords.cropCenterY - (faceCoords.cropHeight / 2)) > 0\n      && (faceCoords.cropCenterY + (faceCoords.cropHeight / 2)) < screenSize.height\n      && Math.abs(currentPose[0]) < pitchRange\n      && Math.abs(currentPose[1]) < yawRange\n      && Math.abs(currentPose[2]) < rollRange\n      && pitchDiff < velocityAngleThreshold\n      && yawDiff < velocityAngleThreshold\n      && rollDiff < velocityAngleThreshold\n      && xDiff < velocityPositionThreshold\n      && yDiff < velocityPositionThreshold\n    );\n};\n\n\nconst shouldRender = (\n  scrSize: {\n    width: number;\n    height: number;\n  },\n  faceCoords: {\n    cropCenterX: number;\n    cropCenterY: number;\n    cropWidth: number;\n    cropHeight: number;\n    paddingX: number;\n    paddingY: number;\n  }\n): boolean => (\n  (faceCoords.cropCenterX - (faceCoords.cropWidth / 2)) > 0\n  && (faceCoords.cropCenterX + (faceCoords.cropWidth / 2)) < scrSize.width\n  && (faceCoords.cropCenterY - (faceCoords.cropHeight / 2)) > 0\n  && (faceCoords.cropCenterY + (faceCoords.cropHeight / 2)) < scrSize.height\n);\n\nconst getPathSize = (pts: PointList) => {\n  let minx = Math.min(pts[71].x, pts[123].x)\n  let maxx = Math.max(pts[301].x, pts[433].x)\n  let miny = Math.min(pts[71].y, pts[301].y)\n  let maxy = Math.max(pts[123].y, pts[352].y)\n\n  const width = maxx - minx;\n  const height = maxy - miny;\n  const max = Math.max(width, height);\n  const min = Math.min(width, height);\n\n  return {\n      minx: minx,\n      maxx: maxx,\n      miny: miny,\n      maxy: maxy,\n      width: width,\n      height: height,\n      max: max,\n      min: min,\n  };\n}\n\nexport {\n  scaledPointList,\n  getEyeAreaPath,\n  getSqaurePath,\n  getPathSize,\n  shouldDetect,\n  shouldRender\n};","import { GlassesRemovalInitializeParameters, GlassesRemovalPlugin } from '@luxottica/vm-plugin-glasses-removal';\nimport { PoseResponse } from '@luxottica/vm-posetracker-faceweb';\nimport { PluginPayload, VmEffect } from '../interfaces/PluginInterface';\nimport { PluginOptions } from '../interfaces/MirrorOptions';\n\n/* #if _PERFORMANCE_MEASUREMENTS\nimport { dispatchEvent } from '../helpers/CallbackHelper'\nimport { glassesRemovalPerformanceEvents as PEVGR } from '../constants/DOMEvents'\n// #endif */\n\nexport class GlassesRemovalEffect implements VmEffect {\n  public orderOfExecution: number;\n\n  constructor(orderOfExecution: number) {\n    this.orderOfExecution = orderOfExecution;\n  }\n\n  initialize(payload: PluginPayload & GlassesRemovalInitializeParameters) {\n    return GlassesRemovalPlugin.initialize({ ...payload, \n      //performance analysis code\n      /* #if _PERFORMANCE_MEASUREMENTS\n      callbacks: {\n        onGlassesPresenceStart: () => (dispatchEvent(PEVGR.onGlassesPresenceStart)),\n        onGlassesPresenceEnd: () => (dispatchEvent(PEVGR.onGlassesPresenceEnd)),\n        onDetectInitStart: () => (dispatchEvent(PEVGR.onDetectInitStart)),\n        onDetectInitEnd: () => (dispatchEvent(PEVGR.onDetectInitEnd)),\n        onLoadSMModelStart: () => (dispatchEvent(PEVGR.onLoadSMModelStart)),\n        onLoadSMModelEnd: () => (dispatchEvent(PEVGR.onLoadSMModelEnd)),\n        onLoadLGModelStart: () => (dispatchEvent(PEVGR.onLoadLGModelStart)),\n        onLoadLGModelEnd: () => (dispatchEvent(PEVGR.onLoadLGModelEnd))\n      }\n      // #endif */\n    });\n  }\n\n  finalize(context?: CanvasRenderingContext2D) {\n    return context;\n  }\n\n  applyFilter(\n    context: CanvasRenderingContext2D,\n    pose: PoseResponse,\n    fps: number,\n    options: PluginOptions\n  ) {\n    return GlassesRemovalPlugin.render({\n      context: context,\n      faceMeshResults: pose?.result,\n      fps: fps,\n      debug: options.debug,\n      stopGlassesDetectionAfterMs: options.stopGlassesDetectionAfterMs,\n    });\n  }\n}","\"use strict\";\r\nmodule.exports = asPromise;\r\n\r\n/**\r\n * Callback as used by {@link util.asPromise}.\r\n * @typedef asPromiseCallback\r\n * @type {function}\r\n * @param {Error|null} error Error, if any\r\n * @param {...*} params Additional arguments\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Returns a promise from a node-style callback function.\r\n * @memberof util\r\n * @param {asPromiseCallback} fn Function to call\r\n * @param {*} ctx Function context\r\n * @param {...*} params Function arguments\r\n * @returns {Promise<*>} Promisified function\r\n */\r\nfunction asPromise(fn, ctx/*, varargs */) {\r\n    var params  = new Array(arguments.length - 1),\r\n        offset  = 0,\r\n        index   = 2,\r\n        pending = true;\r\n    while (index < arguments.length)\r\n        params[offset++] = arguments[index++];\r\n    return new Promise(function executor(resolve, reject) {\r\n        params[offset] = function callback(err/*, varargs */) {\r\n            if (pending) {\r\n                pending = false;\r\n                if (err)\r\n                    reject(err);\r\n                else {\r\n                    var params = new Array(arguments.length - 1),\r\n                        offset = 0;\r\n                    while (offset < params.length)\r\n                        params[offset++] = arguments[offset];\r\n                    resolve.apply(null, params);\r\n                }\r\n            }\r\n        };\r\n        try {\r\n            fn.apply(ctx || null, params);\r\n        } catch (err) {\r\n            if (pending) {\r\n                pending = false;\r\n                reject(err);\r\n            }\r\n        }\r\n    });\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal base64 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar base64 = exports;\r\n\r\n/**\r\n * Calculates the byte length of a base64 encoded string.\r\n * @param {string} string Base64 encoded string\r\n * @returns {number} Byte length\r\n */\r\nbase64.length = function length(string) {\r\n    var p = string.length;\r\n    if (!p)\r\n        return 0;\r\n    var n = 0;\r\n    while (--p % 4 > 1 && string.charAt(p) === \"=\")\r\n        ++n;\r\n    return Math.ceil(string.length * 3) / 4 - n;\r\n};\r\n\r\n// Base64 encoding table\r\nvar b64 = new Array(64);\r\n\r\n// Base64 decoding table\r\nvar s64 = new Array(123);\r\n\r\n// 65..90, 97..122, 48..57, 43, 47\r\nfor (var i = 0; i < 64;)\r\n    s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;\r\n\r\n/**\r\n * Encodes a buffer to a base64 encoded string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} Base64 encoded string\r\n */\r\nbase64.encode = function encode(buffer, start, end) {\r\n    var parts = null,\r\n        chunk = [];\r\n    var i = 0, // output index\r\n        j = 0, // goto index\r\n        t;     // temporary\r\n    while (start < end) {\r\n        var b = buffer[start++];\r\n        switch (j) {\r\n            case 0:\r\n                chunk[i++] = b64[b >> 2];\r\n                t = (b & 3) << 4;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                chunk[i++] = b64[t | b >> 4];\r\n                t = (b & 15) << 2;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                chunk[i++] = b64[t | b >> 6];\r\n                chunk[i++] = b64[b & 63];\r\n                j = 0;\r\n                break;\r\n        }\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (j) {\r\n        chunk[i++] = b64[t];\r\n        chunk[i++] = 61;\r\n        if (j === 1)\r\n            chunk[i++] = 61;\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\nvar invalidEncoding = \"invalid encoding\";\r\n\r\n/**\r\n * Decodes a base64 encoded string to a buffer.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Number of bytes written\r\n * @throws {Error} If encoding is invalid\r\n */\r\nbase64.decode = function decode(string, buffer, offset) {\r\n    var start = offset;\r\n    var j = 0, // goto index\r\n        t;     // temporary\r\n    for (var i = 0; i < string.length;) {\r\n        var c = string.charCodeAt(i++);\r\n        if (c === 61 && j > 1)\r\n            break;\r\n        if ((c = s64[c]) === undefined)\r\n            throw Error(invalidEncoding);\r\n        switch (j) {\r\n            case 0:\r\n                t = c;\r\n                j = 1;\r\n                break;\r\n            case 1:\r\n                buffer[offset++] = t << 2 | (c & 48) >> 4;\r\n                t = c;\r\n                j = 2;\r\n                break;\r\n            case 2:\r\n                buffer[offset++] = (t & 15) << 4 | (c & 60) >> 2;\r\n                t = c;\r\n                j = 3;\r\n                break;\r\n            case 3:\r\n                buffer[offset++] = (t & 3) << 6 | c;\r\n                j = 0;\r\n                break;\r\n        }\r\n    }\r\n    if (j === 1)\r\n        throw Error(invalidEncoding);\r\n    return offset - start;\r\n};\r\n\r\n/**\r\n * Tests if the specified string appears to be base64 encoded.\r\n * @param {string} string String to test\r\n * @returns {boolean} `true` if probably base64 encoded, otherwise false\r\n */\r\nbase64.test = function test(string) {\r\n    return /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(string);\r\n};\r\n","\"use strict\";\r\nmodule.exports = EventEmitter;\r\n\r\n/**\r\n * Constructs a new event emitter instance.\r\n * @classdesc A minimal event emitter.\r\n * @memberof util\r\n * @constructor\r\n */\r\nfunction EventEmitter() {\r\n\r\n    /**\r\n     * Registered listeners.\r\n     * @type {Object.<string,*>}\r\n     * @private\r\n     */\r\n    this._listeners = {};\r\n}\r\n\r\n/**\r\n * Registers an event listener.\r\n * @param {string} evt Event name\r\n * @param {function} fn Listener\r\n * @param {*} [ctx] Listener context\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.on = function on(evt, fn, ctx) {\r\n    (this._listeners[evt] || (this._listeners[evt] = [])).push({\r\n        fn  : fn,\r\n        ctx : ctx || this\r\n    });\r\n    return this;\r\n};\r\n\r\n/**\r\n * Removes an event listener or any matching listeners if arguments are omitted.\r\n * @param {string} [evt] Event name. Removes all listeners if omitted.\r\n * @param {function} [fn] Listener to remove. Removes all listeners of `evt` if omitted.\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.off = function off(evt, fn) {\r\n    if (evt === undefined)\r\n        this._listeners = {};\r\n    else {\r\n        if (fn === undefined)\r\n            this._listeners[evt] = [];\r\n        else {\r\n            var listeners = this._listeners[evt];\r\n            for (var i = 0; i < listeners.length;)\r\n                if (listeners[i].fn === fn)\r\n                    listeners.splice(i, 1);\r\n                else\r\n                    ++i;\r\n        }\r\n    }\r\n    return this;\r\n};\r\n\r\n/**\r\n * Emits an event by calling its listeners with the specified arguments.\r\n * @param {string} evt Event name\r\n * @param {...*} args Arguments\r\n * @returns {util.EventEmitter} `this`\r\n */\r\nEventEmitter.prototype.emit = function emit(evt) {\r\n    var listeners = this._listeners[evt];\r\n    if (listeners) {\r\n        var args = [],\r\n            i = 1;\r\n        for (; i < arguments.length;)\r\n            args.push(arguments[i++]);\r\n        for (i = 0; i < listeners.length;)\r\n            listeners[i].fn.apply(listeners[i++].ctx, args);\r\n    }\r\n    return this;\r\n};\r\n","\"use strict\";\r\n\r\nmodule.exports = factory(factory);\r\n\r\n/**\r\n * Reads / writes floats / doubles from / to buffers.\r\n * @name util.float\r\n * @namespace\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using little endian byte order.\r\n * @name util.float.writeFloatLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 32 bit float to a buffer using big endian byte order.\r\n * @name util.float.writeFloatBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using little endian byte order.\r\n * @name util.float.readFloatLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 32 bit float from a buffer using big endian byte order.\r\n * @name util.float.readFloatBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using little endian byte order.\r\n * @name util.float.writeDoubleLE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Writes a 64 bit double to a buffer using big endian byte order.\r\n * @name util.float.writeDoubleBE\r\n * @function\r\n * @param {number} val Value to write\r\n * @param {Uint8Array} buf Target buffer\r\n * @param {number} pos Target buffer offset\r\n * @returns {undefined}\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using little endian byte order.\r\n * @name util.float.readDoubleLE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n/**\r\n * Reads a 64 bit double from a buffer using big endian byte order.\r\n * @name util.float.readDoubleBE\r\n * @function\r\n * @param {Uint8Array} buf Source buffer\r\n * @param {number} pos Source buffer offset\r\n * @returns {number} Value read\r\n */\r\n\r\n// Factory function for the purpose of node-based testing in modified global environments\r\nfunction factory(exports) {\r\n\r\n    // float: typed array\r\n    if (typeof Float32Array !== \"undefined\") (function() {\r\n\r\n        var f32 = new Float32Array([ -0 ]),\r\n            f8b = new Uint8Array(f32.buffer),\r\n            le  = f8b[3] === 128;\r\n\r\n        function writeFloat_f32_cpy(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n        }\r\n\r\n        function writeFloat_f32_rev(val, buf, pos) {\r\n            f32[0] = val;\r\n            buf[pos    ] = f8b[3];\r\n            buf[pos + 1] = f8b[2];\r\n            buf[pos + 2] = f8b[1];\r\n            buf[pos + 3] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;\r\n\r\n        function readFloat_f32_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        function readFloat_f32_rev(buf, pos) {\r\n            f8b[3] = buf[pos    ];\r\n            f8b[2] = buf[pos + 1];\r\n            f8b[1] = buf[pos + 2];\r\n            f8b[0] = buf[pos + 3];\r\n            return f32[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;\r\n        /* istanbul ignore next */\r\n        exports.readFloatBE = le ? readFloat_f32_rev : readFloat_f32_cpy;\r\n\r\n    // float: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeFloat_ieee754(writeUint, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0)\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos);\r\n            else if (isNaN(val))\r\n                writeUint(2143289344, buf, pos);\r\n            else if (val > 3.4028234663852886e+38) // +-Infinity\r\n                writeUint((sign << 31 | 2139095040) >>> 0, buf, pos);\r\n            else if (val < 1.1754943508222875e-38) // denormal\r\n                writeUint((sign << 31 | Math.round(val / 1.401298464324817e-45)) >>> 0, buf, pos);\r\n            else {\r\n                var exponent = Math.floor(Math.log(val) / Math.LN2),\r\n                    mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;\r\n                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf, pos);\r\n            }\r\n        }\r\n\r\n        exports.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);\r\n        exports.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);\r\n\r\n        function readFloat_ieee754(readUint, buf, pos) {\r\n            var uint = readUint(buf, pos),\r\n                sign = (uint >> 31) * 2 + 1,\r\n                exponent = uint >>> 23 & 255,\r\n                mantissa = uint & 8388607;\r\n            return exponent === 255\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 1.401298464324817e-45 * mantissa\r\n                : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);\r\n        }\r\n\r\n        exports.readFloatLE = readFloat_ieee754.bind(null, readUintLE);\r\n        exports.readFloatBE = readFloat_ieee754.bind(null, readUintBE);\r\n\r\n    })();\r\n\r\n    // double: typed array\r\n    if (typeof Float64Array !== \"undefined\") (function() {\r\n\r\n        var f64 = new Float64Array([-0]),\r\n            f8b = new Uint8Array(f64.buffer),\r\n            le  = f8b[7] === 128;\r\n\r\n        function writeDouble_f64_cpy(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[0];\r\n            buf[pos + 1] = f8b[1];\r\n            buf[pos + 2] = f8b[2];\r\n            buf[pos + 3] = f8b[3];\r\n            buf[pos + 4] = f8b[4];\r\n            buf[pos + 5] = f8b[5];\r\n            buf[pos + 6] = f8b[6];\r\n            buf[pos + 7] = f8b[7];\r\n        }\r\n\r\n        function writeDouble_f64_rev(val, buf, pos) {\r\n            f64[0] = val;\r\n            buf[pos    ] = f8b[7];\r\n            buf[pos + 1] = f8b[6];\r\n            buf[pos + 2] = f8b[5];\r\n            buf[pos + 3] = f8b[4];\r\n            buf[pos + 4] = f8b[3];\r\n            buf[pos + 5] = f8b[2];\r\n            buf[pos + 6] = f8b[1];\r\n            buf[pos + 7] = f8b[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;\r\n\r\n        function readDouble_f64_cpy(buf, pos) {\r\n            f8b[0] = buf[pos    ];\r\n            f8b[1] = buf[pos + 1];\r\n            f8b[2] = buf[pos + 2];\r\n            f8b[3] = buf[pos + 3];\r\n            f8b[4] = buf[pos + 4];\r\n            f8b[5] = buf[pos + 5];\r\n            f8b[6] = buf[pos + 6];\r\n            f8b[7] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        function readDouble_f64_rev(buf, pos) {\r\n            f8b[7] = buf[pos    ];\r\n            f8b[6] = buf[pos + 1];\r\n            f8b[5] = buf[pos + 2];\r\n            f8b[4] = buf[pos + 3];\r\n            f8b[3] = buf[pos + 4];\r\n            f8b[2] = buf[pos + 5];\r\n            f8b[1] = buf[pos + 6];\r\n            f8b[0] = buf[pos + 7];\r\n            return f64[0];\r\n        }\r\n\r\n        /* istanbul ignore next */\r\n        exports.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;\r\n        /* istanbul ignore next */\r\n        exports.readDoubleBE = le ? readDouble_f64_rev : readDouble_f64_cpy;\r\n\r\n    // double: ieee754\r\n    })(); else (function() {\r\n\r\n        function writeDouble_ieee754(writeUint, off0, off1, val, buf, pos) {\r\n            var sign = val < 0 ? 1 : 0;\r\n            if (sign)\r\n                val = -val;\r\n            if (val === 0) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(1 / val > 0 ? /* positive */ 0 : /* negative 0 */ 2147483648, buf, pos + off1);\r\n            } else if (isNaN(val)) {\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint(2146959360, buf, pos + off1);\r\n            } else if (val > 1.7976931348623157e+308) { // +-Infinity\r\n                writeUint(0, buf, pos + off0);\r\n                writeUint((sign << 31 | 2146435072) >>> 0, buf, pos + off1);\r\n            } else {\r\n                var mantissa;\r\n                if (val < 2.2250738585072014e-308) { // denormal\r\n                    mantissa = val / 5e-324;\r\n                    writeUint(mantissa >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf, pos + off1);\r\n                } else {\r\n                    var exponent = Math.floor(Math.log(val) / Math.LN2);\r\n                    if (exponent === 1024)\r\n                        exponent = 1023;\r\n                    mantissa = val * Math.pow(2, -exponent);\r\n                    writeUint(mantissa * 4503599627370496 >>> 0, buf, pos + off0);\r\n                    writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf, pos + off1);\r\n                }\r\n            }\r\n        }\r\n\r\n        exports.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);\r\n        exports.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);\r\n\r\n        function readDouble_ieee754(readUint, off0, off1, buf, pos) {\r\n            var lo = readUint(buf, pos + off0),\r\n                hi = readUint(buf, pos + off1);\r\n            var sign = (hi >> 31) * 2 + 1,\r\n                exponent = hi >>> 20 & 2047,\r\n                mantissa = 4294967296 * (hi & 1048575) + lo;\r\n            return exponent === 2047\r\n                ? mantissa\r\n                ? NaN\r\n                : sign * Infinity\r\n                : exponent === 0 // denormal\r\n                ? sign * 5e-324 * mantissa\r\n                : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);\r\n        }\r\n\r\n        exports.readDoubleLE = readDouble_ieee754.bind(null, readUintLE, 0, 4);\r\n        exports.readDoubleBE = readDouble_ieee754.bind(null, readUintBE, 4, 0);\r\n\r\n    })();\r\n\r\n    return exports;\r\n}\r\n\r\n// uint helpers\r\n\r\nfunction writeUintLE(val, buf, pos) {\r\n    buf[pos    ] =  val        & 255;\r\n    buf[pos + 1] =  val >>> 8  & 255;\r\n    buf[pos + 2] =  val >>> 16 & 255;\r\n    buf[pos + 3] =  val >>> 24;\r\n}\r\n\r\nfunction writeUintBE(val, buf, pos) {\r\n    buf[pos    ] =  val >>> 24;\r\n    buf[pos + 1] =  val >>> 16 & 255;\r\n    buf[pos + 2] =  val >>> 8  & 255;\r\n    buf[pos + 3] =  val        & 255;\r\n}\r\n\r\nfunction readUintLE(buf, pos) {\r\n    return (buf[pos    ]\r\n          | buf[pos + 1] << 8\r\n          | buf[pos + 2] << 16\r\n          | buf[pos + 3] << 24) >>> 0;\r\n}\r\n\r\nfunction readUintBE(buf, pos) {\r\n    return (buf[pos    ] << 24\r\n          | buf[pos + 1] << 16\r\n          | buf[pos + 2] << 8\r\n          | buf[pos + 3]) >>> 0;\r\n}\r\n","\"use strict\";\r\nmodule.exports = inquire;\r\n\r\n/**\r\n * Requires a module only if available.\r\n * @memberof util\r\n * @param {string} moduleName Module to require\r\n * @returns {?Object} Required module if available and not empty, otherwise `null`\r\n */\r\nfunction inquire(moduleName) {\r\n    try {\r\n        var mod = eval(\"quire\".replace(/^/,\"re\"))(moduleName); // eslint-disable-line no-eval\r\n        if (mod && (mod.length || Object.keys(mod).length))\r\n            return mod;\r\n    } catch (e) {} // eslint-disable-line no-empty\r\n    return null;\r\n}\r\n","\"use strict\";\r\nmodule.exports = pool;\r\n\r\n/**\r\n * An allocator as used by {@link util.pool}.\r\n * @typedef PoolAllocator\r\n * @type {function}\r\n * @param {number} size Buffer size\r\n * @returns {Uint8Array} Buffer\r\n */\r\n\r\n/**\r\n * A slicer as used by {@link util.pool}.\r\n * @typedef PoolSlicer\r\n * @type {function}\r\n * @param {number} start Start offset\r\n * @param {number} end End offset\r\n * @returns {Uint8Array} Buffer slice\r\n * @this {Uint8Array}\r\n */\r\n\r\n/**\r\n * A general purpose buffer pool.\r\n * @memberof util\r\n * @function\r\n * @param {PoolAllocator} alloc Allocator\r\n * @param {PoolSlicer} slice Slicer\r\n * @param {number} [size=8192] Slab size\r\n * @returns {PoolAllocator} Pooled allocator\r\n */\r\nfunction pool(alloc, slice, size) {\r\n    var SIZE   = size || 8192;\r\n    var MAX    = SIZE >>> 1;\r\n    var slab   = null;\r\n    var offset = SIZE;\r\n    return function pool_alloc(size) {\r\n        if (size < 1 || size > MAX)\r\n            return alloc(size);\r\n        if (offset + size > SIZE) {\r\n            slab = alloc(SIZE);\r\n            offset = 0;\r\n        }\r\n        var buf = slice.call(slab, offset, offset += size);\r\n        if (offset & 7) // align to 32 bit\r\n            offset = (offset | 7) + 1;\r\n        return buf;\r\n    };\r\n}\r\n","\"use strict\";\r\n\r\n/**\r\n * A minimal UTF8 implementation for number arrays.\r\n * @memberof util\r\n * @namespace\r\n */\r\nvar utf8 = exports;\r\n\r\n/**\r\n * Calculates the UTF8 byte length of a string.\r\n * @param {string} string String\r\n * @returns {number} Byte length\r\n */\r\nutf8.length = function utf8_length(string) {\r\n    var len = 0,\r\n        c = 0;\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c = string.charCodeAt(i);\r\n        if (c < 128)\r\n            len += 1;\r\n        else if (c < 2048)\r\n            len += 2;\r\n        else if ((c & 0xFC00) === 0xD800 && (string.charCodeAt(i + 1) & 0xFC00) === 0xDC00) {\r\n            ++i;\r\n            len += 4;\r\n        } else\r\n            len += 3;\r\n    }\r\n    return len;\r\n};\r\n\r\n/**\r\n * Reads UTF8 bytes as a string.\r\n * @param {Uint8Array} buffer Source buffer\r\n * @param {number} start Source start\r\n * @param {number} end Source end\r\n * @returns {string} String read\r\n */\r\nutf8.read = function utf8_read(buffer, start, end) {\r\n    var len = end - start;\r\n    if (len < 1)\r\n        return \"\";\r\n    var parts = null,\r\n        chunk = [],\r\n        i = 0, // char offset\r\n        t;     // temporary\r\n    while (start < end) {\r\n        t = buffer[start++];\r\n        if (t < 128)\r\n            chunk[i++] = t;\r\n        else if (t > 191 && t < 224)\r\n            chunk[i++] = (t & 31) << 6 | buffer[start++] & 63;\r\n        else if (t > 239 && t < 365) {\r\n            t = ((t & 7) << 18 | (buffer[start++] & 63) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63) - 0x10000;\r\n            chunk[i++] = 0xD800 + (t >> 10);\r\n            chunk[i++] = 0xDC00 + (t & 1023);\r\n        } else\r\n            chunk[i++] = (t & 15) << 12 | (buffer[start++] & 63) << 6 | buffer[start++] & 63;\r\n        if (i > 8191) {\r\n            (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));\r\n            i = 0;\r\n        }\r\n    }\r\n    if (parts) {\r\n        if (i)\r\n            parts.push(String.fromCharCode.apply(String, chunk.slice(0, i)));\r\n        return parts.join(\"\");\r\n    }\r\n    return String.fromCharCode.apply(String, chunk.slice(0, i));\r\n};\r\n\r\n/**\r\n * Writes a string as UTF8 bytes.\r\n * @param {string} string Source string\r\n * @param {Uint8Array} buffer Destination buffer\r\n * @param {number} offset Destination offset\r\n * @returns {number} Bytes written\r\n */\r\nutf8.write = function utf8_write(string, buffer, offset) {\r\n    var start = offset,\r\n        c1, // character 1\r\n        c2; // character 2\r\n    for (var i = 0; i < string.length; ++i) {\r\n        c1 = string.charCodeAt(i);\r\n        if (c1 < 128) {\r\n            buffer[offset++] = c1;\r\n        } else if (c1 < 2048) {\r\n            buffer[offset++] = c1 >> 6       | 192;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else if ((c1 & 0xFC00) === 0xD800 && ((c2 = string.charCodeAt(i + 1)) & 0xFC00) === 0xDC00) {\r\n            c1 = 0x10000 + ((c1 & 0x03FF) << 10) + (c2 & 0x03FF);\r\n            ++i;\r\n            buffer[offset++] = c1 >> 18      | 240;\r\n            buffer[offset++] = c1 >> 12 & 63 | 128;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        } else {\r\n            buffer[offset++] = c1 >> 12      | 224;\r\n            buffer[offset++] = c1 >> 6  & 63 | 128;\r\n            buffer[offset++] = c1       & 63 | 128;\r\n        }\r\n    }\r\n    return offset - start;\r\n};\r\n","/**\n * Common utilities\n * @module glMatrix\n */\n// Configuration Constants\nexport var EPSILON = 0.000001;\nexport var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;\nexport var RANDOM = Math.random;\n/**\n * Sets the type of array used when creating new vectors and matrices\n *\n * @param {Float32ArrayConstructor | ArrayConstructor} type Array type, such as Float32Array or Array\n */\n\nexport function setMatrixArrayType(type) {\n  ARRAY_TYPE = type;\n}\nvar degree = Math.PI / 180;\n/**\n * Convert Degree To Radian\n *\n * @param {Number} a Angle in Degrees\n */\n\nexport function toRadian(a) {\n  return a * degree;\n}\n/**\n * Tests whether or not the arguments have approximately the same value, within an absolute\n * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less\n * than or equal to 1.0, and a relative tolerance is used for larger values)\n *\n * @param {Number} a The first number to test.\n * @param {Number} b The second number to test.\n * @returns {Boolean} True if the numbers are approximately equal, false otherwise.\n */\n\nexport function equals(a, b) {\n  return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\n}\nif (!Math.hypot) Math.hypot = function () {\n  var y = 0,\n      i = arguments.length;\n\n  while (i--) {\n    y += arguments[i] * arguments[i];\n  }\n\n  return Math.sqrt(y);\n};","import * as glMatrix from \"./common.js\";\n/**\n * 3x3 Matrix\n * @module mat3\n */\n\n/**\n * Creates a new identity mat3\n *\n * @returns {mat3} a new 3x3 matrix\n */\n\nexport function create() {\n  var out = new glMatrix.ARRAY_TYPE(9);\n\n  if (glMatrix.ARRAY_TYPE != Float32Array) {\n    out[1] = 0;\n    out[2] = 0;\n    out[3] = 0;\n    out[5] = 0;\n    out[6] = 0;\n    out[7] = 0;\n  }\n\n  out[0] = 1;\n  out[4] = 1;\n  out[8] = 1;\n  return out;\n}\n/**\n * Copies the upper-left 3x3 values into the given mat3.\n *\n * @param {mat3} out the receiving 3x3 matrix\n * @param {ReadonlyMat4} a   the source 4x4 matrix\n * @returns {mat3} out\n */\n\nexport function fromMat4(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[4];\n  out[4] = a[5];\n  out[5] = a[6];\n  out[6] = a[8];\n  out[7] = a[9];\n  out[8] = a[10];\n  return out;\n}\n/**\n * Creates a new mat3 initialized with values from an existing matrix\n *\n * @param {ReadonlyMat3} a matrix to clone\n * @returns {mat3} a new 3x3 matrix\n */\n\nexport function clone(a) {\n  var out = new glMatrix.ARRAY_TYPE(9);\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4];\n  out[5] = a[5];\n  out[6] = a[6];\n  out[7] = a[7];\n  out[8] = a[8];\n  return out;\n}\n/**\n * Copy the values from one mat3 to another\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the source matrix\n * @returns {mat3} out\n */\n\nexport function copy(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4];\n  out[5] = a[5];\n  out[6] = a[6];\n  out[7] = a[7];\n  out[8] = a[8];\n  return out;\n}\n/**\n * Create a new mat3 with the given values\n *\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\n * @returns {mat3} A new mat3\n */\n\nexport function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n  var out = new glMatrix.ARRAY_TYPE(9);\n  out[0] = m00;\n  out[1] = m01;\n  out[2] = m02;\n  out[3] = m10;\n  out[4] = m11;\n  out[5] = m12;\n  out[6] = m20;\n  out[7] = m21;\n  out[8] = m22;\n  return out;\n}\n/**\n * Set the components of a mat3 to the given values\n *\n * @param {mat3} out the receiving matrix\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\n * @returns {mat3} out\n */\n\nexport function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {\n  out[0] = m00;\n  out[1] = m01;\n  out[2] = m02;\n  out[3] = m10;\n  out[4] = m11;\n  out[5] = m12;\n  out[6] = m20;\n  out[7] = m21;\n  out[8] = m22;\n  return out;\n}\n/**\n * Set a mat3 to the identity matrix\n *\n * @param {mat3} out the receiving matrix\n * @returns {mat3} out\n */\n\nexport function identity(out) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 1;\n  out[5] = 0;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 1;\n  return out;\n}\n/**\n * Transpose the values of a mat3\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the source matrix\n * @returns {mat3} out\n */\n\nexport function transpose(out, a) {\n  // If we are transposing ourselves we can skip a few steps but have to cache some values\n  if (out === a) {\n    var a01 = a[1],\n        a02 = a[2],\n        a12 = a[5];\n    out[1] = a[3];\n    out[2] = a[6];\n    out[3] = a01;\n    out[5] = a[7];\n    out[6] = a02;\n    out[7] = a12;\n  } else {\n    out[0] = a[0];\n    out[1] = a[3];\n    out[2] = a[6];\n    out[3] = a[1];\n    out[4] = a[4];\n    out[5] = a[7];\n    out[6] = a[2];\n    out[7] = a[5];\n    out[8] = a[8];\n  }\n\n  return out;\n}\n/**\n * Inverts a mat3\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the source matrix\n * @returns {mat3} out\n */\n\nexport function invert(out, a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2];\n  var a10 = a[3],\n      a11 = a[4],\n      a12 = a[5];\n  var a20 = a[6],\n      a21 = a[7],\n      a22 = a[8];\n  var b01 = a22 * a11 - a12 * a21;\n  var b11 = -a22 * a10 + a12 * a20;\n  var b21 = a21 * a10 - a11 * a20; // Calculate the determinant\n\n  var det = a00 * b01 + a01 * b11 + a02 * b21;\n\n  if (!det) {\n    return null;\n  }\n\n  det = 1.0 / det;\n  out[0] = b01 * det;\n  out[1] = (-a22 * a01 + a02 * a21) * det;\n  out[2] = (a12 * a01 - a02 * a11) * det;\n  out[3] = b11 * det;\n  out[4] = (a22 * a00 - a02 * a20) * det;\n  out[5] = (-a12 * a00 + a02 * a10) * det;\n  out[6] = b21 * det;\n  out[7] = (-a21 * a00 + a01 * a20) * det;\n  out[8] = (a11 * a00 - a01 * a10) * det;\n  return out;\n}\n/**\n * Calculates the adjugate of a mat3\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the source matrix\n * @returns {mat3} out\n */\n\nexport function adjoint(out, a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2];\n  var a10 = a[3],\n      a11 = a[4],\n      a12 = a[5];\n  var a20 = a[6],\n      a21 = a[7],\n      a22 = a[8];\n  out[0] = a11 * a22 - a12 * a21;\n  out[1] = a02 * a21 - a01 * a22;\n  out[2] = a01 * a12 - a02 * a11;\n  out[3] = a12 * a20 - a10 * a22;\n  out[4] = a00 * a22 - a02 * a20;\n  out[5] = a02 * a10 - a00 * a12;\n  out[6] = a10 * a21 - a11 * a20;\n  out[7] = a01 * a20 - a00 * a21;\n  out[8] = a00 * a11 - a01 * a10;\n  return out;\n}\n/**\n * Calculates the determinant of a mat3\n *\n * @param {ReadonlyMat3} a the source matrix\n * @returns {Number} determinant of a\n */\n\nexport function determinant(a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2];\n  var a10 = a[3],\n      a11 = a[4],\n      a12 = a[5];\n  var a20 = a[6],\n      a21 = a[7],\n      a22 = a[8];\n  return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);\n}\n/**\n * Multiplies two mat3's\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the first operand\n * @param {ReadonlyMat3} b the second operand\n * @returns {mat3} out\n */\n\nexport function multiply(out, a, b) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2];\n  var a10 = a[3],\n      a11 = a[4],\n      a12 = a[5];\n  var a20 = a[6],\n      a21 = a[7],\n      a22 = a[8];\n  var b00 = b[0],\n      b01 = b[1],\n      b02 = b[2];\n  var b10 = b[3],\n      b11 = b[4],\n      b12 = b[5];\n  var b20 = b[6],\n      b21 = b[7],\n      b22 = b[8];\n  out[0] = b00 * a00 + b01 * a10 + b02 * a20;\n  out[1] = b00 * a01 + b01 * a11 + b02 * a21;\n  out[2] = b00 * a02 + b01 * a12 + b02 * a22;\n  out[3] = b10 * a00 + b11 * a10 + b12 * a20;\n  out[4] = b10 * a01 + b11 * a11 + b12 * a21;\n  out[5] = b10 * a02 + b11 * a12 + b12 * a22;\n  out[6] = b20 * a00 + b21 * a10 + b22 * a20;\n  out[7] = b20 * a01 + b21 * a11 + b22 * a21;\n  out[8] = b20 * a02 + b21 * a12 + b22 * a22;\n  return out;\n}\n/**\n * Translate a mat3 by the given vector\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the matrix to translate\n * @param {ReadonlyVec2} v vector to translate by\n * @returns {mat3} out\n */\n\nexport function translate(out, a, v) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a10 = a[3],\n      a11 = a[4],\n      a12 = a[5],\n      a20 = a[6],\n      a21 = a[7],\n      a22 = a[8],\n      x = v[0],\n      y = v[1];\n  out[0] = a00;\n  out[1] = a01;\n  out[2] = a02;\n  out[3] = a10;\n  out[4] = a11;\n  out[5] = a12;\n  out[6] = x * a00 + y * a10 + a20;\n  out[7] = x * a01 + y * a11 + a21;\n  out[8] = x * a02 + y * a12 + a22;\n  return out;\n}\n/**\n * Rotates a mat3 by the given angle\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the matrix to rotate\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat3} out\n */\n\nexport function rotate(out, a, rad) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a10 = a[3],\n      a11 = a[4],\n      a12 = a[5],\n      a20 = a[6],\n      a21 = a[7],\n      a22 = a[8],\n      s = Math.sin(rad),\n      c = Math.cos(rad);\n  out[0] = c * a00 + s * a10;\n  out[1] = c * a01 + s * a11;\n  out[2] = c * a02 + s * a12;\n  out[3] = c * a10 - s * a00;\n  out[4] = c * a11 - s * a01;\n  out[5] = c * a12 - s * a02;\n  out[6] = a20;\n  out[7] = a21;\n  out[8] = a22;\n  return out;\n}\n/**\n * Scales the mat3 by the dimensions in the given vec2\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the matrix to rotate\n * @param {ReadonlyVec2} v the vec2 to scale the matrix by\n * @returns {mat3} out\n **/\n\nexport function scale(out, a, v) {\n  var x = v[0],\n      y = v[1];\n  out[0] = x * a[0];\n  out[1] = x * a[1];\n  out[2] = x * a[2];\n  out[3] = y * a[3];\n  out[4] = y * a[4];\n  out[5] = y * a[5];\n  out[6] = a[6];\n  out[7] = a[7];\n  out[8] = a[8];\n  return out;\n}\n/**\n * Creates a matrix from a vector translation\n * This is equivalent to (but much faster than):\n *\n *     mat3.identity(dest);\n *     mat3.translate(dest, dest, vec);\n *\n * @param {mat3} out mat3 receiving operation result\n * @param {ReadonlyVec2} v Translation vector\n * @returns {mat3} out\n */\n\nexport function fromTranslation(out, v) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 1;\n  out[5] = 0;\n  out[6] = v[0];\n  out[7] = v[1];\n  out[8] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a given angle\n * This is equivalent to (but much faster than):\n *\n *     mat3.identity(dest);\n *     mat3.rotate(dest, dest, rad);\n *\n * @param {mat3} out mat3 receiving operation result\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat3} out\n */\n\nexport function fromRotation(out, rad) {\n  var s = Math.sin(rad),\n      c = Math.cos(rad);\n  out[0] = c;\n  out[1] = s;\n  out[2] = 0;\n  out[3] = -s;\n  out[4] = c;\n  out[5] = 0;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a vector scaling\n * This is equivalent to (but much faster than):\n *\n *     mat3.identity(dest);\n *     mat3.scale(dest, dest, vec);\n *\n * @param {mat3} out mat3 receiving operation result\n * @param {ReadonlyVec2} v Scaling vector\n * @returns {mat3} out\n */\n\nexport function fromScaling(out, v) {\n  out[0] = v[0];\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = v[1];\n  out[5] = 0;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 1;\n  return out;\n}\n/**\n * Copies the values from a mat2d into a mat3\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat2d} a the matrix to copy\n * @returns {mat3} out\n **/\n\nexport function fromMat2d(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = 0;\n  out[3] = a[2];\n  out[4] = a[3];\n  out[5] = 0;\n  out[6] = a[4];\n  out[7] = a[5];\n  out[8] = 1;\n  return out;\n}\n/**\n * Calculates a 3x3 matrix from the given quaternion\n *\n * @param {mat3} out mat3 receiving operation result\n * @param {ReadonlyQuat} q Quaternion to create matrix from\n *\n * @returns {mat3} out\n */\n\nexport function fromQuat(out, q) {\n  var x = q[0],\n      y = q[1],\n      z = q[2],\n      w = q[3];\n  var x2 = x + x;\n  var y2 = y + y;\n  var z2 = z + z;\n  var xx = x * x2;\n  var yx = y * x2;\n  var yy = y * y2;\n  var zx = z * x2;\n  var zy = z * y2;\n  var zz = z * z2;\n  var wx = w * x2;\n  var wy = w * y2;\n  var wz = w * z2;\n  out[0] = 1 - yy - zz;\n  out[3] = yx - wz;\n  out[6] = zx + wy;\n  out[1] = yx + wz;\n  out[4] = 1 - xx - zz;\n  out[7] = zy - wx;\n  out[2] = zx - wy;\n  out[5] = zy + wx;\n  out[8] = 1 - xx - yy;\n  return out;\n}\n/**\n * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix\n *\n * @param {mat3} out mat3 receiving operation result\n * @param {ReadonlyMat4} a Mat4 to derive the normal matrix from\n *\n * @returns {mat3} out\n */\n\nexport function normalFromMat4(out, a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a03 = a[3];\n  var a10 = a[4],\n      a11 = a[5],\n      a12 = a[6],\n      a13 = a[7];\n  var a20 = a[8],\n      a21 = a[9],\n      a22 = a[10],\n      a23 = a[11];\n  var a30 = a[12],\n      a31 = a[13],\n      a32 = a[14],\n      a33 = a[15];\n  var b00 = a00 * a11 - a01 * a10;\n  var b01 = a00 * a12 - a02 * a10;\n  var b02 = a00 * a13 - a03 * a10;\n  var b03 = a01 * a12 - a02 * a11;\n  var b04 = a01 * a13 - a03 * a11;\n  var b05 = a02 * a13 - a03 * a12;\n  var b06 = a20 * a31 - a21 * a30;\n  var b07 = a20 * a32 - a22 * a30;\n  var b08 = a20 * a33 - a23 * a30;\n  var b09 = a21 * a32 - a22 * a31;\n  var b10 = a21 * a33 - a23 * a31;\n  var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n  if (!det) {\n    return null;\n  }\n\n  det = 1.0 / det;\n  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n  out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n  out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n  out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n  out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n  out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n  out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n  out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n  out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n  return out;\n}\n/**\n * Generates a 2D projection matrix with the given bounds\n *\n * @param {mat3} out mat3 frustum matrix will be written into\n * @param {number} width Width of your gl context\n * @param {number} height Height of gl context\n * @returns {mat3} out\n */\n\nexport function projection(out, width, height) {\n  out[0] = 2 / width;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = -2 / height;\n  out[5] = 0;\n  out[6] = -1;\n  out[7] = 1;\n  out[8] = 1;\n  return out;\n}\n/**\n * Returns a string representation of a mat3\n *\n * @param {ReadonlyMat3} a matrix to represent as a string\n * @returns {String} string representation of the matrix\n */\n\nexport function str(a) {\n  return \"mat3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \")\";\n}\n/**\n * Returns Frobenius norm of a mat3\n *\n * @param {ReadonlyMat3} a the matrix to calculate Frobenius norm of\n * @returns {Number} Frobenius norm\n */\n\nexport function frob(a) {\n  return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8]);\n}\n/**\n * Adds two mat3's\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the first operand\n * @param {ReadonlyMat3} b the second operand\n * @returns {mat3} out\n */\n\nexport function add(out, a, b) {\n  out[0] = a[0] + b[0];\n  out[1] = a[1] + b[1];\n  out[2] = a[2] + b[2];\n  out[3] = a[3] + b[3];\n  out[4] = a[4] + b[4];\n  out[5] = a[5] + b[5];\n  out[6] = a[6] + b[6];\n  out[7] = a[7] + b[7];\n  out[8] = a[8] + b[8];\n  return out;\n}\n/**\n * Subtracts matrix b from matrix a\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the first operand\n * @param {ReadonlyMat3} b the second operand\n * @returns {mat3} out\n */\n\nexport function subtract(out, a, b) {\n  out[0] = a[0] - b[0];\n  out[1] = a[1] - b[1];\n  out[2] = a[2] - b[2];\n  out[3] = a[3] - b[3];\n  out[4] = a[4] - b[4];\n  out[5] = a[5] - b[5];\n  out[6] = a[6] - b[6];\n  out[7] = a[7] - b[7];\n  out[8] = a[8] - b[8];\n  return out;\n}\n/**\n * Multiply each element of the matrix by a scalar.\n *\n * @param {mat3} out the receiving matrix\n * @param {ReadonlyMat3} a the matrix to scale\n * @param {Number} b amount to scale the matrix's elements by\n * @returns {mat3} out\n */\n\nexport function multiplyScalar(out, a, b) {\n  out[0] = a[0] * b;\n  out[1] = a[1] * b;\n  out[2] = a[2] * b;\n  out[3] = a[3] * b;\n  out[4] = a[4] * b;\n  out[5] = a[5] * b;\n  out[6] = a[6] * b;\n  out[7] = a[7] * b;\n  out[8] = a[8] * b;\n  return out;\n}\n/**\n * Adds two mat3's after multiplying each element of the second operand by a scalar value.\n *\n * @param {mat3} out the receiving vector\n * @param {ReadonlyMat3} a the first operand\n * @param {ReadonlyMat3} b the second operand\n * @param {Number} scale the amount to scale b's elements by before adding\n * @returns {mat3} out\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n  out[0] = a[0] + b[0] * scale;\n  out[1] = a[1] + b[1] * scale;\n  out[2] = a[2] + b[2] * scale;\n  out[3] = a[3] + b[3] * scale;\n  out[4] = a[4] + b[4] * scale;\n  out[5] = a[5] + b[5] * scale;\n  out[6] = a[6] + b[6] * scale;\n  out[7] = a[7] + b[7] * scale;\n  out[8] = a[8] + b[8] * scale;\n  return out;\n}\n/**\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\n *\n * @param {ReadonlyMat3} a The first matrix.\n * @param {ReadonlyMat3} b The second matrix.\n * @returns {Boolean} True if the matrices are equal, false otherwise.\n */\n\nexport function exactEquals(a, b) {\n  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];\n}\n/**\n * Returns whether or not the matrices have approximately the same elements in the same position.\n *\n * @param {ReadonlyMat3} a The first matrix.\n * @param {ReadonlyMat3} b The second matrix.\n * @returns {Boolean} True if the matrices are equal, false otherwise.\n */\n\nexport function equals(a, b) {\n  var a0 = a[0],\n      a1 = a[1],\n      a2 = a[2],\n      a3 = a[3],\n      a4 = a[4],\n      a5 = a[5],\n      a6 = a[6],\n      a7 = a[7],\n      a8 = a[8];\n  var b0 = b[0],\n      b1 = b[1],\n      b2 = b[2],\n      b3 = b[3],\n      b4 = b[4],\n      b5 = b[5],\n      b6 = b[6],\n      b7 = b[7],\n      b8 = b[8];\n  return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));\n}\n/**\n * Alias for {@link mat3.multiply}\n * @function\n */\n\nexport var mul = multiply;\n/**\n * Alias for {@link mat3.subtract}\n * @function\n */\n\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\n/**\n * 4x4 Matrix<br>Format: column-major, when typed out it looks like row-major<br>The matrices are being post multiplied.\n * @module mat4\n */\n\n/**\n * Creates a new identity mat4\n *\n * @returns {mat4} a new 4x4 matrix\n */\n\nexport function create() {\n  var out = new glMatrix.ARRAY_TYPE(16);\n\n  if (glMatrix.ARRAY_TYPE != Float32Array) {\n    out[1] = 0;\n    out[2] = 0;\n    out[3] = 0;\n    out[4] = 0;\n    out[6] = 0;\n    out[7] = 0;\n    out[8] = 0;\n    out[9] = 0;\n    out[11] = 0;\n    out[12] = 0;\n    out[13] = 0;\n    out[14] = 0;\n  }\n\n  out[0] = 1;\n  out[5] = 1;\n  out[10] = 1;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a new mat4 initialized with values from an existing matrix\n *\n * @param {ReadonlyMat4} a matrix to clone\n * @returns {mat4} a new 4x4 matrix\n */\n\nexport function clone(a) {\n  var out = new glMatrix.ARRAY_TYPE(16);\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4];\n  out[5] = a[5];\n  out[6] = a[6];\n  out[7] = a[7];\n  out[8] = a[8];\n  out[9] = a[9];\n  out[10] = a[10];\n  out[11] = a[11];\n  out[12] = a[12];\n  out[13] = a[13];\n  out[14] = a[14];\n  out[15] = a[15];\n  return out;\n}\n/**\n * Copy the values from one mat4 to another\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the source matrix\n * @returns {mat4} out\n */\n\nexport function copy(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  out[4] = a[4];\n  out[5] = a[5];\n  out[6] = a[6];\n  out[7] = a[7];\n  out[8] = a[8];\n  out[9] = a[9];\n  out[10] = a[10];\n  out[11] = a[11];\n  out[12] = a[12];\n  out[13] = a[13];\n  out[14] = a[14];\n  out[15] = a[15];\n  return out;\n}\n/**\n * Create a new mat4 with the given values\n *\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\n * @returns {mat4} A new mat4\n */\n\nexport function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n  var out = new glMatrix.ARRAY_TYPE(16);\n  out[0] = m00;\n  out[1] = m01;\n  out[2] = m02;\n  out[3] = m03;\n  out[4] = m10;\n  out[5] = m11;\n  out[6] = m12;\n  out[7] = m13;\n  out[8] = m20;\n  out[9] = m21;\n  out[10] = m22;\n  out[11] = m23;\n  out[12] = m30;\n  out[13] = m31;\n  out[14] = m32;\n  out[15] = m33;\n  return out;\n}\n/**\n * Set the components of a mat4 to the given values\n *\n * @param {mat4} out the receiving matrix\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\n * @returns {mat4} out\n */\n\nexport function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\n  out[0] = m00;\n  out[1] = m01;\n  out[2] = m02;\n  out[3] = m03;\n  out[4] = m10;\n  out[5] = m11;\n  out[6] = m12;\n  out[7] = m13;\n  out[8] = m20;\n  out[9] = m21;\n  out[10] = m22;\n  out[11] = m23;\n  out[12] = m30;\n  out[13] = m31;\n  out[14] = m32;\n  out[15] = m33;\n  return out;\n}\n/**\n * Set a mat4 to the identity matrix\n *\n * @param {mat4} out the receiving matrix\n * @returns {mat4} out\n */\n\nexport function identity(out) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = 1;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = 1;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Transpose the values of a mat4\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the source matrix\n * @returns {mat4} out\n */\n\nexport function transpose(out, a) {\n  // If we are transposing ourselves we can skip a few steps but have to cache some values\n  if (out === a) {\n    var a01 = a[1],\n        a02 = a[2],\n        a03 = a[3];\n    var a12 = a[6],\n        a13 = a[7];\n    var a23 = a[11];\n    out[1] = a[4];\n    out[2] = a[8];\n    out[3] = a[12];\n    out[4] = a01;\n    out[6] = a[9];\n    out[7] = a[13];\n    out[8] = a02;\n    out[9] = a12;\n    out[11] = a[14];\n    out[12] = a03;\n    out[13] = a13;\n    out[14] = a23;\n  } else {\n    out[0] = a[0];\n    out[1] = a[4];\n    out[2] = a[8];\n    out[3] = a[12];\n    out[4] = a[1];\n    out[5] = a[5];\n    out[6] = a[9];\n    out[7] = a[13];\n    out[8] = a[2];\n    out[9] = a[6];\n    out[10] = a[10];\n    out[11] = a[14];\n    out[12] = a[3];\n    out[13] = a[7];\n    out[14] = a[11];\n    out[15] = a[15];\n  }\n\n  return out;\n}\n/**\n * Inverts a mat4\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the source matrix\n * @returns {mat4} out\n */\n\nexport function invert(out, a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a03 = a[3];\n  var a10 = a[4],\n      a11 = a[5],\n      a12 = a[6],\n      a13 = a[7];\n  var a20 = a[8],\n      a21 = a[9],\n      a22 = a[10],\n      a23 = a[11];\n  var a30 = a[12],\n      a31 = a[13],\n      a32 = a[14],\n      a33 = a[15];\n  var b00 = a00 * a11 - a01 * a10;\n  var b01 = a00 * a12 - a02 * a10;\n  var b02 = a00 * a13 - a03 * a10;\n  var b03 = a01 * a12 - a02 * a11;\n  var b04 = a01 * a13 - a03 * a11;\n  var b05 = a02 * a13 - a03 * a12;\n  var b06 = a20 * a31 - a21 * a30;\n  var b07 = a20 * a32 - a22 * a30;\n  var b08 = a20 * a33 - a23 * a30;\n  var b09 = a21 * a32 - a22 * a31;\n  var b10 = a21 * a33 - a23 * a31;\n  var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n  var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n\n  if (!det) {\n    return null;\n  }\n\n  det = 1.0 / det;\n  out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\n  out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\n  out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\n  out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;\n  out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\n  out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\n  out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\n  out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;\n  out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\n  out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\n  out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\n  out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;\n  out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;\n  out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;\n  out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;\n  out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;\n  return out;\n}\n/**\n * Calculates the adjugate of a mat4\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the source matrix\n * @returns {mat4} out\n */\n\nexport function adjoint(out, a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a03 = a[3];\n  var a10 = a[4],\n      a11 = a[5],\n      a12 = a[6],\n      a13 = a[7];\n  var a20 = a[8],\n      a21 = a[9],\n      a22 = a[10],\n      a23 = a[11];\n  var a30 = a[12],\n      a31 = a[13],\n      a32 = a[14],\n      a33 = a[15];\n  out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);\n  out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));\n  out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);\n  out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));\n  out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));\n  out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);\n  out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));\n  out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);\n  out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);\n  out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));\n  out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);\n  out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));\n  out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));\n  out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);\n  out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));\n  out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);\n  return out;\n}\n/**\n * Calculates the determinant of a mat4\n *\n * @param {ReadonlyMat4} a the source matrix\n * @returns {Number} determinant of a\n */\n\nexport function determinant(a) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a03 = a[3];\n  var a10 = a[4],\n      a11 = a[5],\n      a12 = a[6],\n      a13 = a[7];\n  var a20 = a[8],\n      a21 = a[9],\n      a22 = a[10],\n      a23 = a[11];\n  var a30 = a[12],\n      a31 = a[13],\n      a32 = a[14],\n      a33 = a[15];\n  var b00 = a00 * a11 - a01 * a10;\n  var b01 = a00 * a12 - a02 * a10;\n  var b02 = a00 * a13 - a03 * a10;\n  var b03 = a01 * a12 - a02 * a11;\n  var b04 = a01 * a13 - a03 * a11;\n  var b05 = a02 * a13 - a03 * a12;\n  var b06 = a20 * a31 - a21 * a30;\n  var b07 = a20 * a32 - a22 * a30;\n  var b08 = a20 * a33 - a23 * a30;\n  var b09 = a21 * a32 - a22 * a31;\n  var b10 = a21 * a33 - a23 * a31;\n  var b11 = a22 * a33 - a23 * a32; // Calculate the determinant\n\n  return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\n}\n/**\n * Multiplies two mat4s\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the first operand\n * @param {ReadonlyMat4} b the second operand\n * @returns {mat4} out\n */\n\nexport function multiply(out, a, b) {\n  var a00 = a[0],\n      a01 = a[1],\n      a02 = a[2],\n      a03 = a[3];\n  var a10 = a[4],\n      a11 = a[5],\n      a12 = a[6],\n      a13 = a[7];\n  var a20 = a[8],\n      a21 = a[9],\n      a22 = a[10],\n      a23 = a[11];\n  var a30 = a[12],\n      a31 = a[13],\n      a32 = a[14],\n      a33 = a[15]; // Cache only the current line of the second matrix\n\n  var b0 = b[0],\n      b1 = b[1],\n      b2 = b[2],\n      b3 = b[3];\n  out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n  out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n  out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n  out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n  b0 = b[4];\n  b1 = b[5];\n  b2 = b[6];\n  b3 = b[7];\n  out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n  out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n  out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n  out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n  b0 = b[8];\n  b1 = b[9];\n  b2 = b[10];\n  b3 = b[11];\n  out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n  out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n  out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n  out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n  b0 = b[12];\n  b1 = b[13];\n  b2 = b[14];\n  b3 = b[15];\n  out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\n  out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\n  out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\n  out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\n  return out;\n}\n/**\n * Translate a mat4 by the given vector\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to translate\n * @param {ReadonlyVec3} v vector to translate by\n * @returns {mat4} out\n */\n\nexport function translate(out, a, v) {\n  var x = v[0],\n      y = v[1],\n      z = v[2];\n  var a00, a01, a02, a03;\n  var a10, a11, a12, a13;\n  var a20, a21, a22, a23;\n\n  if (a === out) {\n    out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];\n    out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];\n    out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];\n    out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];\n  } else {\n    a00 = a[0];\n    a01 = a[1];\n    a02 = a[2];\n    a03 = a[3];\n    a10 = a[4];\n    a11 = a[5];\n    a12 = a[6];\n    a13 = a[7];\n    a20 = a[8];\n    a21 = a[9];\n    a22 = a[10];\n    a23 = a[11];\n    out[0] = a00;\n    out[1] = a01;\n    out[2] = a02;\n    out[3] = a03;\n    out[4] = a10;\n    out[5] = a11;\n    out[6] = a12;\n    out[7] = a13;\n    out[8] = a20;\n    out[9] = a21;\n    out[10] = a22;\n    out[11] = a23;\n    out[12] = a00 * x + a10 * y + a20 * z + a[12];\n    out[13] = a01 * x + a11 * y + a21 * z + a[13];\n    out[14] = a02 * x + a12 * y + a22 * z + a[14];\n    out[15] = a03 * x + a13 * y + a23 * z + a[15];\n  }\n\n  return out;\n}\n/**\n * Scales the mat4 by the dimensions in the given vec3 not using vectorization\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to scale\n * @param {ReadonlyVec3} v the vec3 to scale the matrix by\n * @returns {mat4} out\n **/\n\nexport function scale(out, a, v) {\n  var x = v[0],\n      y = v[1],\n      z = v[2];\n  out[0] = a[0] * x;\n  out[1] = a[1] * x;\n  out[2] = a[2] * x;\n  out[3] = a[3] * x;\n  out[4] = a[4] * y;\n  out[5] = a[5] * y;\n  out[6] = a[6] * y;\n  out[7] = a[7] * y;\n  out[8] = a[8] * z;\n  out[9] = a[9] * z;\n  out[10] = a[10] * z;\n  out[11] = a[11] * z;\n  out[12] = a[12];\n  out[13] = a[13];\n  out[14] = a[14];\n  out[15] = a[15];\n  return out;\n}\n/**\n * Rotates a mat4 by the given angle around the given axis\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to rotate\n * @param {Number} rad the angle to rotate the matrix by\n * @param {ReadonlyVec3} axis the axis to rotate around\n * @returns {mat4} out\n */\n\nexport function rotate(out, a, rad, axis) {\n  var x = axis[0],\n      y = axis[1],\n      z = axis[2];\n  var len = Math.hypot(x, y, z);\n  var s, c, t;\n  var a00, a01, a02, a03;\n  var a10, a11, a12, a13;\n  var a20, a21, a22, a23;\n  var b00, b01, b02;\n  var b10, b11, b12;\n  var b20, b21, b22;\n\n  if (len < glMatrix.EPSILON) {\n    return null;\n  }\n\n  len = 1 / len;\n  x *= len;\n  y *= len;\n  z *= len;\n  s = Math.sin(rad);\n  c = Math.cos(rad);\n  t = 1 - c;\n  a00 = a[0];\n  a01 = a[1];\n  a02 = a[2];\n  a03 = a[3];\n  a10 = a[4];\n  a11 = a[5];\n  a12 = a[6];\n  a13 = a[7];\n  a20 = a[8];\n  a21 = a[9];\n  a22 = a[10];\n  a23 = a[11]; // Construct the elements of the rotation matrix\n\n  b00 = x * x * t + c;\n  b01 = y * x * t + z * s;\n  b02 = z * x * t - y * s;\n  b10 = x * y * t - z * s;\n  b11 = y * y * t + c;\n  b12 = z * y * t + x * s;\n  b20 = x * z * t + y * s;\n  b21 = y * z * t - x * s;\n  b22 = z * z * t + c; // Perform rotation-specific matrix multiplication\n\n  out[0] = a00 * b00 + a10 * b01 + a20 * b02;\n  out[1] = a01 * b00 + a11 * b01 + a21 * b02;\n  out[2] = a02 * b00 + a12 * b01 + a22 * b02;\n  out[3] = a03 * b00 + a13 * b01 + a23 * b02;\n  out[4] = a00 * b10 + a10 * b11 + a20 * b12;\n  out[5] = a01 * b10 + a11 * b11 + a21 * b12;\n  out[6] = a02 * b10 + a12 * b11 + a22 * b12;\n  out[7] = a03 * b10 + a13 * b11 + a23 * b12;\n  out[8] = a00 * b20 + a10 * b21 + a20 * b22;\n  out[9] = a01 * b20 + a11 * b21 + a21 * b22;\n  out[10] = a02 * b20 + a12 * b21 + a22 * b22;\n  out[11] = a03 * b20 + a13 * b21 + a23 * b22;\n\n  if (a !== out) {\n    // If the source and destination differ, copy the unchanged last row\n    out[12] = a[12];\n    out[13] = a[13];\n    out[14] = a[14];\n    out[15] = a[15];\n  }\n\n  return out;\n}\n/**\n * Rotates a matrix by the given angle around the X axis\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to rotate\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function rotateX(out, a, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad);\n  var a10 = a[4];\n  var a11 = a[5];\n  var a12 = a[6];\n  var a13 = a[7];\n  var a20 = a[8];\n  var a21 = a[9];\n  var a22 = a[10];\n  var a23 = a[11];\n\n  if (a !== out) {\n    // If the source and destination differ, copy the unchanged rows\n    out[0] = a[0];\n    out[1] = a[1];\n    out[2] = a[2];\n    out[3] = a[3];\n    out[12] = a[12];\n    out[13] = a[13];\n    out[14] = a[14];\n    out[15] = a[15];\n  } // Perform axis-specific matrix multiplication\n\n\n  out[4] = a10 * c + a20 * s;\n  out[5] = a11 * c + a21 * s;\n  out[6] = a12 * c + a22 * s;\n  out[7] = a13 * c + a23 * s;\n  out[8] = a20 * c - a10 * s;\n  out[9] = a21 * c - a11 * s;\n  out[10] = a22 * c - a12 * s;\n  out[11] = a23 * c - a13 * s;\n  return out;\n}\n/**\n * Rotates a matrix by the given angle around the Y axis\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to rotate\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function rotateY(out, a, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad);\n  var a00 = a[0];\n  var a01 = a[1];\n  var a02 = a[2];\n  var a03 = a[3];\n  var a20 = a[8];\n  var a21 = a[9];\n  var a22 = a[10];\n  var a23 = a[11];\n\n  if (a !== out) {\n    // If the source and destination differ, copy the unchanged rows\n    out[4] = a[4];\n    out[5] = a[5];\n    out[6] = a[6];\n    out[7] = a[7];\n    out[12] = a[12];\n    out[13] = a[13];\n    out[14] = a[14];\n    out[15] = a[15];\n  } // Perform axis-specific matrix multiplication\n\n\n  out[0] = a00 * c - a20 * s;\n  out[1] = a01 * c - a21 * s;\n  out[2] = a02 * c - a22 * s;\n  out[3] = a03 * c - a23 * s;\n  out[8] = a00 * s + a20 * c;\n  out[9] = a01 * s + a21 * c;\n  out[10] = a02 * s + a22 * c;\n  out[11] = a03 * s + a23 * c;\n  return out;\n}\n/**\n * Rotates a matrix by the given angle around the Z axis\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to rotate\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function rotateZ(out, a, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad);\n  var a00 = a[0];\n  var a01 = a[1];\n  var a02 = a[2];\n  var a03 = a[3];\n  var a10 = a[4];\n  var a11 = a[5];\n  var a12 = a[6];\n  var a13 = a[7];\n\n  if (a !== out) {\n    // If the source and destination differ, copy the unchanged last row\n    out[8] = a[8];\n    out[9] = a[9];\n    out[10] = a[10];\n    out[11] = a[11];\n    out[12] = a[12];\n    out[13] = a[13];\n    out[14] = a[14];\n    out[15] = a[15];\n  } // Perform axis-specific matrix multiplication\n\n\n  out[0] = a00 * c + a10 * s;\n  out[1] = a01 * c + a11 * s;\n  out[2] = a02 * c + a12 * s;\n  out[3] = a03 * c + a13 * s;\n  out[4] = a10 * c - a00 * s;\n  out[5] = a11 * c - a01 * s;\n  out[6] = a12 * c - a02 * s;\n  out[7] = a13 * c - a03 * s;\n  return out;\n}\n/**\n * Creates a matrix from a vector translation\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.translate(dest, dest, vec);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {ReadonlyVec3} v Translation vector\n * @returns {mat4} out\n */\n\nexport function fromTranslation(out, v) {\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = 1;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = 1;\n  out[11] = 0;\n  out[12] = v[0];\n  out[13] = v[1];\n  out[14] = v[2];\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a vector scaling\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.scale(dest, dest, vec);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {ReadonlyVec3} v Scaling vector\n * @returns {mat4} out\n */\n\nexport function fromScaling(out, v) {\n  out[0] = v[0];\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = v[1];\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = v[2];\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a given angle around a given axis\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.rotate(dest, dest, rad, axis);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {Number} rad the angle to rotate the matrix by\n * @param {ReadonlyVec3} axis the axis to rotate around\n * @returns {mat4} out\n */\n\nexport function fromRotation(out, rad, axis) {\n  var x = axis[0],\n      y = axis[1],\n      z = axis[2];\n  var len = Math.hypot(x, y, z);\n  var s, c, t;\n\n  if (len < glMatrix.EPSILON) {\n    return null;\n  }\n\n  len = 1 / len;\n  x *= len;\n  y *= len;\n  z *= len;\n  s = Math.sin(rad);\n  c = Math.cos(rad);\n  t = 1 - c; // Perform rotation-specific matrix multiplication\n\n  out[0] = x * x * t + c;\n  out[1] = y * x * t + z * s;\n  out[2] = z * x * t - y * s;\n  out[3] = 0;\n  out[4] = x * y * t - z * s;\n  out[5] = y * y * t + c;\n  out[6] = z * y * t + x * s;\n  out[7] = 0;\n  out[8] = x * z * t + y * s;\n  out[9] = y * z * t - x * s;\n  out[10] = z * z * t + c;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from the given angle around the X axis\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.rotateX(dest, dest, rad);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function fromXRotation(out, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n  out[0] = 1;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = c;\n  out[6] = s;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = -s;\n  out[10] = c;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from the given angle around the Y axis\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.rotateY(dest, dest, rad);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function fromYRotation(out, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n  out[0] = c;\n  out[1] = 0;\n  out[2] = -s;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = 1;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = s;\n  out[9] = 0;\n  out[10] = c;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from the given angle around the Z axis\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.rotateZ(dest, dest, rad);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {Number} rad the angle to rotate the matrix by\n * @returns {mat4} out\n */\n\nexport function fromZRotation(out, rad) {\n  var s = Math.sin(rad);\n  var c = Math.cos(rad); // Perform axis-specific matrix multiplication\n\n  out[0] = c;\n  out[1] = s;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = -s;\n  out[5] = c;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = 1;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a quaternion rotation and vector translation\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.translate(dest, vec);\n *     let quatMat = mat4.create();\n *     quat4.toMat4(quat, quatMat);\n *     mat4.multiply(dest, quatMat);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {quat4} q Rotation quaternion\n * @param {ReadonlyVec3} v Translation vector\n * @returns {mat4} out\n */\n\nexport function fromRotationTranslation(out, q, v) {\n  // Quaternion math\n  var x = q[0],\n      y = q[1],\n      z = q[2],\n      w = q[3];\n  var x2 = x + x;\n  var y2 = y + y;\n  var z2 = z + z;\n  var xx = x * x2;\n  var xy = x * y2;\n  var xz = x * z2;\n  var yy = y * y2;\n  var yz = y * z2;\n  var zz = z * z2;\n  var wx = w * x2;\n  var wy = w * y2;\n  var wz = w * z2;\n  out[0] = 1 - (yy + zz);\n  out[1] = xy + wz;\n  out[2] = xz - wy;\n  out[3] = 0;\n  out[4] = xy - wz;\n  out[5] = 1 - (xx + zz);\n  out[6] = yz + wx;\n  out[7] = 0;\n  out[8] = xz + wy;\n  out[9] = yz - wx;\n  out[10] = 1 - (xx + yy);\n  out[11] = 0;\n  out[12] = v[0];\n  out[13] = v[1];\n  out[14] = v[2];\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a new mat4 from a dual quat.\n *\n * @param {mat4} out Matrix\n * @param {ReadonlyQuat2} a Dual Quaternion\n * @returns {mat4} mat4 receiving operation result\n */\n\nexport function fromQuat2(out, a) {\n  var translation = new glMatrix.ARRAY_TYPE(3);\n  var bx = -a[0],\n      by = -a[1],\n      bz = -a[2],\n      bw = a[3],\n      ax = a[4],\n      ay = a[5],\n      az = a[6],\n      aw = a[7];\n  var magnitude = bx * bx + by * by + bz * bz + bw * bw; //Only scale if it makes sense\n\n  if (magnitude > 0) {\n    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;\n    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;\n    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;\n  } else {\n    translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;\n    translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;\n    translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;\n  }\n\n  fromRotationTranslation(out, a, translation);\n  return out;\n}\n/**\n * Returns the translation vector component of a transformation\n *  matrix. If a matrix is built with fromRotationTranslation,\n *  the returned vector will be the same as the translation vector\n *  originally supplied.\n * @param  {vec3} out Vector to receive translation component\n * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)\n * @return {vec3} out\n */\n\nexport function getTranslation(out, mat) {\n  out[0] = mat[12];\n  out[1] = mat[13];\n  out[2] = mat[14];\n  return out;\n}\n/**\n * Returns the scaling factor component of a transformation\n *  matrix. If a matrix is built with fromRotationTranslationScale\n *  with a normalized Quaternion paramter, the returned vector will be\n *  the same as the scaling vector\n *  originally supplied.\n * @param  {vec3} out Vector to receive scaling factor component\n * @param  {ReadonlyMat4} mat Matrix to be decomposed (input)\n * @return {vec3} out\n */\n\nexport function getScaling(out, mat) {\n  var m11 = mat[0];\n  var m12 = mat[1];\n  var m13 = mat[2];\n  var m21 = mat[4];\n  var m22 = mat[5];\n  var m23 = mat[6];\n  var m31 = mat[8];\n  var m32 = mat[9];\n  var m33 = mat[10];\n  out[0] = Math.hypot(m11, m12, m13);\n  out[1] = Math.hypot(m21, m22, m23);\n  out[2] = Math.hypot(m31, m32, m33);\n  return out;\n}\n/**\n * Returns a quaternion representing the rotational component\n *  of a transformation matrix. If a matrix is built with\n *  fromRotationTranslation, the returned quaternion will be the\n *  same as the quaternion originally supplied.\n * @param {quat} out Quaternion to receive the rotation component\n * @param {ReadonlyMat4} mat Matrix to be decomposed (input)\n * @return {quat} out\n */\n\nexport function getRotation(out, mat) {\n  var scaling = new glMatrix.ARRAY_TYPE(3);\n  getScaling(scaling, mat);\n  var is1 = 1 / scaling[0];\n  var is2 = 1 / scaling[1];\n  var is3 = 1 / scaling[2];\n  var sm11 = mat[0] * is1;\n  var sm12 = mat[1] * is2;\n  var sm13 = mat[2] * is3;\n  var sm21 = mat[4] * is1;\n  var sm22 = mat[5] * is2;\n  var sm23 = mat[6] * is3;\n  var sm31 = mat[8] * is1;\n  var sm32 = mat[9] * is2;\n  var sm33 = mat[10] * is3;\n  var trace = sm11 + sm22 + sm33;\n  var S = 0;\n\n  if (trace > 0) {\n    S = Math.sqrt(trace + 1.0) * 2;\n    out[3] = 0.25 * S;\n    out[0] = (sm23 - sm32) / S;\n    out[1] = (sm31 - sm13) / S;\n    out[2] = (sm12 - sm21) / S;\n  } else if (sm11 > sm22 && sm11 > sm33) {\n    S = Math.sqrt(1.0 + sm11 - sm22 - sm33) * 2;\n    out[3] = (sm23 - sm32) / S;\n    out[0] = 0.25 * S;\n    out[1] = (sm12 + sm21) / S;\n    out[2] = (sm31 + sm13) / S;\n  } else if (sm22 > sm33) {\n    S = Math.sqrt(1.0 + sm22 - sm11 - sm33) * 2;\n    out[3] = (sm31 - sm13) / S;\n    out[0] = (sm12 + sm21) / S;\n    out[1] = 0.25 * S;\n    out[2] = (sm23 + sm32) / S;\n  } else {\n    S = Math.sqrt(1.0 + sm33 - sm11 - sm22) * 2;\n    out[3] = (sm12 - sm21) / S;\n    out[0] = (sm31 + sm13) / S;\n    out[1] = (sm23 + sm32) / S;\n    out[2] = 0.25 * S;\n  }\n\n  return out;\n}\n/**\n * Creates a matrix from a quaternion rotation, vector translation and vector scale\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.translate(dest, vec);\n *     let quatMat = mat4.create();\n *     quat4.toMat4(quat, quatMat);\n *     mat4.multiply(dest, quatMat);\n *     mat4.scale(dest, scale)\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {quat4} q Rotation quaternion\n * @param {ReadonlyVec3} v Translation vector\n * @param {ReadonlyVec3} s Scaling vector\n * @returns {mat4} out\n */\n\nexport function fromRotationTranslationScale(out, q, v, s) {\n  // Quaternion math\n  var x = q[0],\n      y = q[1],\n      z = q[2],\n      w = q[3];\n  var x2 = x + x;\n  var y2 = y + y;\n  var z2 = z + z;\n  var xx = x * x2;\n  var xy = x * y2;\n  var xz = x * z2;\n  var yy = y * y2;\n  var yz = y * z2;\n  var zz = z * z2;\n  var wx = w * x2;\n  var wy = w * y2;\n  var wz = w * z2;\n  var sx = s[0];\n  var sy = s[1];\n  var sz = s[2];\n  out[0] = (1 - (yy + zz)) * sx;\n  out[1] = (xy + wz) * sx;\n  out[2] = (xz - wy) * sx;\n  out[3] = 0;\n  out[4] = (xy - wz) * sy;\n  out[5] = (1 - (xx + zz)) * sy;\n  out[6] = (yz + wx) * sy;\n  out[7] = 0;\n  out[8] = (xz + wy) * sz;\n  out[9] = (yz - wx) * sz;\n  out[10] = (1 - (xx + yy)) * sz;\n  out[11] = 0;\n  out[12] = v[0];\n  out[13] = v[1];\n  out[14] = v[2];\n  out[15] = 1;\n  return out;\n}\n/**\n * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin\n * This is equivalent to (but much faster than):\n *\n *     mat4.identity(dest);\n *     mat4.translate(dest, vec);\n *     mat4.translate(dest, origin);\n *     let quatMat = mat4.create();\n *     quat4.toMat4(quat, quatMat);\n *     mat4.multiply(dest, quatMat);\n *     mat4.scale(dest, scale)\n *     mat4.translate(dest, negativeOrigin);\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {quat4} q Rotation quaternion\n * @param {ReadonlyVec3} v Translation vector\n * @param {ReadonlyVec3} s Scaling vector\n * @param {ReadonlyVec3} o The origin vector around which to scale and rotate\n * @returns {mat4} out\n */\n\nexport function fromRotationTranslationScaleOrigin(out, q, v, s, o) {\n  // Quaternion math\n  var x = q[0],\n      y = q[1],\n      z = q[2],\n      w = q[3];\n  var x2 = x + x;\n  var y2 = y + y;\n  var z2 = z + z;\n  var xx = x * x2;\n  var xy = x * y2;\n  var xz = x * z2;\n  var yy = y * y2;\n  var yz = y * z2;\n  var zz = z * z2;\n  var wx = w * x2;\n  var wy = w * y2;\n  var wz = w * z2;\n  var sx = s[0];\n  var sy = s[1];\n  var sz = s[2];\n  var ox = o[0];\n  var oy = o[1];\n  var oz = o[2];\n  var out0 = (1 - (yy + zz)) * sx;\n  var out1 = (xy + wz) * sx;\n  var out2 = (xz - wy) * sx;\n  var out4 = (xy - wz) * sy;\n  var out5 = (1 - (xx + zz)) * sy;\n  var out6 = (yz + wx) * sy;\n  var out8 = (xz + wy) * sz;\n  var out9 = (yz - wx) * sz;\n  var out10 = (1 - (xx + yy)) * sz;\n  out[0] = out0;\n  out[1] = out1;\n  out[2] = out2;\n  out[3] = 0;\n  out[4] = out4;\n  out[5] = out5;\n  out[6] = out6;\n  out[7] = 0;\n  out[8] = out8;\n  out[9] = out9;\n  out[10] = out10;\n  out[11] = 0;\n  out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);\n  out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);\n  out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);\n  out[15] = 1;\n  return out;\n}\n/**\n * Calculates a 4x4 matrix from the given quaternion\n *\n * @param {mat4} out mat4 receiving operation result\n * @param {ReadonlyQuat} q Quaternion to create matrix from\n *\n * @returns {mat4} out\n */\n\nexport function fromQuat(out, q) {\n  var x = q[0],\n      y = q[1],\n      z = q[2],\n      w = q[3];\n  var x2 = x + x;\n  var y2 = y + y;\n  var z2 = z + z;\n  var xx = x * x2;\n  var yx = y * x2;\n  var yy = y * y2;\n  var zx = z * x2;\n  var zy = z * y2;\n  var zz = z * z2;\n  var wx = w * x2;\n  var wy = w * y2;\n  var wz = w * z2;\n  out[0] = 1 - yy - zz;\n  out[1] = yx + wz;\n  out[2] = zx - wy;\n  out[3] = 0;\n  out[4] = yx - wz;\n  out[5] = 1 - xx - zz;\n  out[6] = zy + wx;\n  out[7] = 0;\n  out[8] = zx + wy;\n  out[9] = zy - wx;\n  out[10] = 1 - xx - yy;\n  out[11] = 0;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = 0;\n  out[15] = 1;\n  return out;\n}\n/**\n * Generates a frustum matrix with the given bounds\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {Number} left Left bound of the frustum\n * @param {Number} right Right bound of the frustum\n * @param {Number} bottom Bottom bound of the frustum\n * @param {Number} top Top bound of the frustum\n * @param {Number} near Near bound of the frustum\n * @param {Number} far Far bound of the frustum\n * @returns {mat4} out\n */\n\nexport function frustum(out, left, right, bottom, top, near, far) {\n  var rl = 1 / (right - left);\n  var tb = 1 / (top - bottom);\n  var nf = 1 / (near - far);\n  out[0] = near * 2 * rl;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = near * 2 * tb;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = (right + left) * rl;\n  out[9] = (top + bottom) * tb;\n  out[10] = (far + near) * nf;\n  out[11] = -1;\n  out[12] = 0;\n  out[13] = 0;\n  out[14] = far * near * 2 * nf;\n  out[15] = 0;\n  return out;\n}\n/**\n * Generates a perspective projection matrix with the given bounds.\n * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],\n * which matches WebGL/OpenGL's clip volume.\n * Passing null/undefined/no value for far will generate infinite projection matrix.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {number} fovy Vertical field of view in radians\n * @param {number} aspect Aspect ratio. typically viewport width/height\n * @param {number} near Near bound of the frustum\n * @param {number} far Far bound of the frustum, can be null or Infinity\n * @returns {mat4} out\n */\n\nexport function perspectiveNO(out, fovy, aspect, near, far) {\n  var f = 1.0 / Math.tan(fovy / 2),\n      nf;\n  out[0] = f / aspect;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = f;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[11] = -1;\n  out[12] = 0;\n  out[13] = 0;\n  out[15] = 0;\n\n  if (far != null && far !== Infinity) {\n    nf = 1 / (near - far);\n    out[10] = (far + near) * nf;\n    out[14] = 2 * far * near * nf;\n  } else {\n    out[10] = -1;\n    out[14] = -2 * near;\n  }\n\n  return out;\n}\n/**\n * Alias for {@link mat4.perspectiveNO}\n * @function\n */\n\nexport var perspective = perspectiveNO;\n/**\n * Generates a perspective projection matrix suitable for WebGPU with the given bounds.\n * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],\n * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.\n * Passing null/undefined/no value for far will generate infinite projection matrix.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {number} fovy Vertical field of view in radians\n * @param {number} aspect Aspect ratio. typically viewport width/height\n * @param {number} near Near bound of the frustum\n * @param {number} far Far bound of the frustum, can be null or Infinity\n * @returns {mat4} out\n */\n\nexport function perspectiveZO(out, fovy, aspect, near, far) {\n  var f = 1.0 / Math.tan(fovy / 2),\n      nf;\n  out[0] = f / aspect;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = f;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[11] = -1;\n  out[12] = 0;\n  out[13] = 0;\n  out[15] = 0;\n\n  if (far != null && far !== Infinity) {\n    nf = 1 / (near - far);\n    out[10] = far * nf;\n    out[14] = far * near * nf;\n  } else {\n    out[10] = -1;\n    out[14] = -near;\n  }\n\n  return out;\n}\n/**\n * Generates a perspective projection matrix with the given field of view.\n * This is primarily useful for generating projection matrices to be used\n * with the still experiemental WebVR API.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees\n * @param {number} near Near bound of the frustum\n * @param {number} far Far bound of the frustum\n * @returns {mat4} out\n */\n\nexport function perspectiveFromFieldOfView(out, fov, near, far) {\n  var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);\n  var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);\n  var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);\n  var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);\n  var xScale = 2.0 / (leftTan + rightTan);\n  var yScale = 2.0 / (upTan + downTan);\n  out[0] = xScale;\n  out[1] = 0.0;\n  out[2] = 0.0;\n  out[3] = 0.0;\n  out[4] = 0.0;\n  out[5] = yScale;\n  out[6] = 0.0;\n  out[7] = 0.0;\n  out[8] = -((leftTan - rightTan) * xScale * 0.5);\n  out[9] = (upTan - downTan) * yScale * 0.5;\n  out[10] = far / (near - far);\n  out[11] = -1.0;\n  out[12] = 0.0;\n  out[13] = 0.0;\n  out[14] = far * near / (near - far);\n  out[15] = 0.0;\n  return out;\n}\n/**\n * Generates a orthogonal projection matrix with the given bounds.\n * The near/far clip planes correspond to a normalized device coordinate Z range of [-1, 1],\n * which matches WebGL/OpenGL's clip volume.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {number} left Left bound of the frustum\n * @param {number} right Right bound of the frustum\n * @param {number} bottom Bottom bound of the frustum\n * @param {number} top Top bound of the frustum\n * @param {number} near Near bound of the frustum\n * @param {number} far Far bound of the frustum\n * @returns {mat4} out\n */\n\nexport function orthoNO(out, left, right, bottom, top, near, far) {\n  var lr = 1 / (left - right);\n  var bt = 1 / (bottom - top);\n  var nf = 1 / (near - far);\n  out[0] = -2 * lr;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = -2 * bt;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = 2 * nf;\n  out[11] = 0;\n  out[12] = (left + right) * lr;\n  out[13] = (top + bottom) * bt;\n  out[14] = (far + near) * nf;\n  out[15] = 1;\n  return out;\n}\n/**\n * Alias for {@link mat4.orthoNO}\n * @function\n */\n\nexport var ortho = orthoNO;\n/**\n * Generates a orthogonal projection matrix with the given bounds.\n * The near/far clip planes correspond to a normalized device coordinate Z range of [0, 1],\n * which matches WebGPU/Vulkan/DirectX/Metal's clip volume.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {number} left Left bound of the frustum\n * @param {number} right Right bound of the frustum\n * @param {number} bottom Bottom bound of the frustum\n * @param {number} top Top bound of the frustum\n * @param {number} near Near bound of the frustum\n * @param {number} far Far bound of the frustum\n * @returns {mat4} out\n */\n\nexport function orthoZO(out, left, right, bottom, top, near, far) {\n  var lr = 1 / (left - right);\n  var bt = 1 / (bottom - top);\n  var nf = 1 / (near - far);\n  out[0] = -2 * lr;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 0;\n  out[4] = 0;\n  out[5] = -2 * bt;\n  out[6] = 0;\n  out[7] = 0;\n  out[8] = 0;\n  out[9] = 0;\n  out[10] = nf;\n  out[11] = 0;\n  out[12] = (left + right) * lr;\n  out[13] = (top + bottom) * bt;\n  out[14] = near * nf;\n  out[15] = 1;\n  return out;\n}\n/**\n * Generates a look-at matrix with the given eye position, focal point, and up axis.\n * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {ReadonlyVec3} eye Position of the viewer\n * @param {ReadonlyVec3} center Point the viewer is looking at\n * @param {ReadonlyVec3} up vec3 pointing up\n * @returns {mat4} out\n */\n\nexport function lookAt(out, eye, center, up) {\n  var x0, x1, x2, y0, y1, y2, z0, z1, z2, len;\n  var eyex = eye[0];\n  var eyey = eye[1];\n  var eyez = eye[2];\n  var upx = up[0];\n  var upy = up[1];\n  var upz = up[2];\n  var centerx = center[0];\n  var centery = center[1];\n  var centerz = center[2];\n\n  if (Math.abs(eyex - centerx) < glMatrix.EPSILON && Math.abs(eyey - centery) < glMatrix.EPSILON && Math.abs(eyez - centerz) < glMatrix.EPSILON) {\n    return identity(out);\n  }\n\n  z0 = eyex - centerx;\n  z1 = eyey - centery;\n  z2 = eyez - centerz;\n  len = 1 / Math.hypot(z0, z1, z2);\n  z0 *= len;\n  z1 *= len;\n  z2 *= len;\n  x0 = upy * z2 - upz * z1;\n  x1 = upz * z0 - upx * z2;\n  x2 = upx * z1 - upy * z0;\n  len = Math.hypot(x0, x1, x2);\n\n  if (!len) {\n    x0 = 0;\n    x1 = 0;\n    x2 = 0;\n  } else {\n    len = 1 / len;\n    x0 *= len;\n    x1 *= len;\n    x2 *= len;\n  }\n\n  y0 = z1 * x2 - z2 * x1;\n  y1 = z2 * x0 - z0 * x2;\n  y2 = z0 * x1 - z1 * x0;\n  len = Math.hypot(y0, y1, y2);\n\n  if (!len) {\n    y0 = 0;\n    y1 = 0;\n    y2 = 0;\n  } else {\n    len = 1 / len;\n    y0 *= len;\n    y1 *= len;\n    y2 *= len;\n  }\n\n  out[0] = x0;\n  out[1] = y0;\n  out[2] = z0;\n  out[3] = 0;\n  out[4] = x1;\n  out[5] = y1;\n  out[6] = z1;\n  out[7] = 0;\n  out[8] = x2;\n  out[9] = y2;\n  out[10] = z2;\n  out[11] = 0;\n  out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);\n  out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);\n  out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);\n  out[15] = 1;\n  return out;\n}\n/**\n * Generates a matrix that makes something look at something else.\n *\n * @param {mat4} out mat4 frustum matrix will be written into\n * @param {ReadonlyVec3} eye Position of the viewer\n * @param {ReadonlyVec3} center Point the viewer is looking at\n * @param {ReadonlyVec3} up vec3 pointing up\n * @returns {mat4} out\n */\n\nexport function targetTo(out, eye, target, up) {\n  var eyex = eye[0],\n      eyey = eye[1],\n      eyez = eye[2],\n      upx = up[0],\n      upy = up[1],\n      upz = up[2];\n  var z0 = eyex - target[0],\n      z1 = eyey - target[1],\n      z2 = eyez - target[2];\n  var len = z0 * z0 + z1 * z1 + z2 * z2;\n\n  if (len > 0) {\n    len = 1 / Math.sqrt(len);\n    z0 *= len;\n    z1 *= len;\n    z2 *= len;\n  }\n\n  var x0 = upy * z2 - upz * z1,\n      x1 = upz * z0 - upx * z2,\n      x2 = upx * z1 - upy * z0;\n  len = x0 * x0 + x1 * x1 + x2 * x2;\n\n  if (len > 0) {\n    len = 1 / Math.sqrt(len);\n    x0 *= len;\n    x1 *= len;\n    x2 *= len;\n  }\n\n  out[0] = x0;\n  out[1] = x1;\n  out[2] = x2;\n  out[3] = 0;\n  out[4] = z1 * x2 - z2 * x1;\n  out[5] = z2 * x0 - z0 * x2;\n  out[6] = z0 * x1 - z1 * x0;\n  out[7] = 0;\n  out[8] = z0;\n  out[9] = z1;\n  out[10] = z2;\n  out[11] = 0;\n  out[12] = eyex;\n  out[13] = eyey;\n  out[14] = eyez;\n  out[15] = 1;\n  return out;\n}\n/**\n * Returns a string representation of a mat4\n *\n * @param {ReadonlyMat4} a matrix to represent as a string\n * @returns {String} string representation of the matrix\n */\n\nexport function str(a) {\n  return \"mat4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \", \" + a[4] + \", \" + a[5] + \", \" + a[6] + \", \" + a[7] + \", \" + a[8] + \", \" + a[9] + \", \" + a[10] + \", \" + a[11] + \", \" + a[12] + \", \" + a[13] + \", \" + a[14] + \", \" + a[15] + \")\";\n}\n/**\n * Returns Frobenius norm of a mat4\n *\n * @param {ReadonlyMat4} a the matrix to calculate Frobenius norm of\n * @returns {Number} Frobenius norm\n */\n\nexport function frob(a) {\n  return Math.hypot(a[0], a[1], a[2], a[3], a[4], a[5], a[6], a[7], a[8], a[9], a[10], a[11], a[12], a[13], a[14], a[15]);\n}\n/**\n * Adds two mat4's\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the first operand\n * @param {ReadonlyMat4} b the second operand\n * @returns {mat4} out\n */\n\nexport function add(out, a, b) {\n  out[0] = a[0] + b[0];\n  out[1] = a[1] + b[1];\n  out[2] = a[2] + b[2];\n  out[3] = a[3] + b[3];\n  out[4] = a[4] + b[4];\n  out[5] = a[5] + b[5];\n  out[6] = a[6] + b[6];\n  out[7] = a[7] + b[7];\n  out[8] = a[8] + b[8];\n  out[9] = a[9] + b[9];\n  out[10] = a[10] + b[10];\n  out[11] = a[11] + b[11];\n  out[12] = a[12] + b[12];\n  out[13] = a[13] + b[13];\n  out[14] = a[14] + b[14];\n  out[15] = a[15] + b[15];\n  return out;\n}\n/**\n * Subtracts matrix b from matrix a\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the first operand\n * @param {ReadonlyMat4} b the second operand\n * @returns {mat4} out\n */\n\nexport function subtract(out, a, b) {\n  out[0] = a[0] - b[0];\n  out[1] = a[1] - b[1];\n  out[2] = a[2] - b[2];\n  out[3] = a[3] - b[3];\n  out[4] = a[4] - b[4];\n  out[5] = a[5] - b[5];\n  out[6] = a[6] - b[6];\n  out[7] = a[7] - b[7];\n  out[8] = a[8] - b[8];\n  out[9] = a[9] - b[9];\n  out[10] = a[10] - b[10];\n  out[11] = a[11] - b[11];\n  out[12] = a[12] - b[12];\n  out[13] = a[13] - b[13];\n  out[14] = a[14] - b[14];\n  out[15] = a[15] - b[15];\n  return out;\n}\n/**\n * Multiply each element of the matrix by a scalar.\n *\n * @param {mat4} out the receiving matrix\n * @param {ReadonlyMat4} a the matrix to scale\n * @param {Number} b amount to scale the matrix's elements by\n * @returns {mat4} out\n */\n\nexport function multiplyScalar(out, a, b) {\n  out[0] = a[0] * b;\n  out[1] = a[1] * b;\n  out[2] = a[2] * b;\n  out[3] = a[3] * b;\n  out[4] = a[4] * b;\n  out[5] = a[5] * b;\n  out[6] = a[6] * b;\n  out[7] = a[7] * b;\n  out[8] = a[8] * b;\n  out[9] = a[9] * b;\n  out[10] = a[10] * b;\n  out[11] = a[11] * b;\n  out[12] = a[12] * b;\n  out[13] = a[13] * b;\n  out[14] = a[14] * b;\n  out[15] = a[15] * b;\n  return out;\n}\n/**\n * Adds two mat4's after multiplying each element of the second operand by a scalar value.\n *\n * @param {mat4} out the receiving vector\n * @param {ReadonlyMat4} a the first operand\n * @param {ReadonlyMat4} b the second operand\n * @param {Number} scale the amount to scale b's elements by before adding\n * @returns {mat4} out\n */\n\nexport function multiplyScalarAndAdd(out, a, b, scale) {\n  out[0] = a[0] + b[0] * scale;\n  out[1] = a[1] + b[1] * scale;\n  out[2] = a[2] + b[2] * scale;\n  out[3] = a[3] + b[3] * scale;\n  out[4] = a[4] + b[4] * scale;\n  out[5] = a[5] + b[5] * scale;\n  out[6] = a[6] + b[6] * scale;\n  out[7] = a[7] + b[7] * scale;\n  out[8] = a[8] + b[8] * scale;\n  out[9] = a[9] + b[9] * scale;\n  out[10] = a[10] + b[10] * scale;\n  out[11] = a[11] + b[11] * scale;\n  out[12] = a[12] + b[12] * scale;\n  out[13] = a[13] + b[13] * scale;\n  out[14] = a[14] + b[14] * scale;\n  out[15] = a[15] + b[15] * scale;\n  return out;\n}\n/**\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\n *\n * @param {ReadonlyMat4} a The first matrix.\n * @param {ReadonlyMat4} b The second matrix.\n * @returns {Boolean} True if the matrices are equal, false otherwise.\n */\n\nexport function exactEquals(a, b) {\n  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];\n}\n/**\n * Returns whether or not the matrices have approximately the same elements in the same position.\n *\n * @param {ReadonlyMat4} a The first matrix.\n * @param {ReadonlyMat4} b The second matrix.\n * @returns {Boolean} True if the matrices are equal, false otherwise.\n */\n\nexport function equals(a, b) {\n  var a0 = a[0],\n      a1 = a[1],\n      a2 = a[2],\n      a3 = a[3];\n  var a4 = a[4],\n      a5 = a[5],\n      a6 = a[6],\n      a7 = a[7];\n  var a8 = a[8],\n      a9 = a[9],\n      a10 = a[10],\n      a11 = a[11];\n  var a12 = a[12],\n      a13 = a[13],\n      a14 = a[14],\n      a15 = a[15];\n  var b0 = b[0],\n      b1 = b[1],\n      b2 = b[2],\n      b3 = b[3];\n  var b4 = b[4],\n      b5 = b[5],\n      b6 = b[6],\n      b7 = b[7];\n  var b8 = b[8],\n      b9 = b[9],\n      b10 = b[10],\n      b11 = b[11];\n  var b12 = b[12],\n      b13 = b[13],\n      b14 = b[14],\n      b15 = b[15];\n  return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));\n}\n/**\n * Alias for {@link mat4.multiply}\n * @function\n */\n\nexport var mul = multiply;\n/**\n * Alias for {@link mat4.subtract}\n * @function\n */\n\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\nimport * as mat3 from \"./mat3.js\";\nimport * as vec3 from \"./vec3.js\";\nimport * as vec4 from \"./vec4.js\";\n/**\n * Quaternion\n * @module quat\n */\n\n/**\n * Creates a new identity quat\n *\n * @returns {quat} a new quaternion\n */\n\nexport function create() {\n  var out = new glMatrix.ARRAY_TYPE(4);\n\n  if (glMatrix.ARRAY_TYPE != Float32Array) {\n    out[0] = 0;\n    out[1] = 0;\n    out[2] = 0;\n  }\n\n  out[3] = 1;\n  return out;\n}\n/**\n * Set a quat to the identity quaternion\n *\n * @param {quat} out the receiving quaternion\n * @returns {quat} out\n */\n\nexport function identity(out) {\n  out[0] = 0;\n  out[1] = 0;\n  out[2] = 0;\n  out[3] = 1;\n  return out;\n}\n/**\n * Sets a quat from the given angle and rotation axis,\n * then returns it.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyVec3} axis the axis around which to rotate\n * @param {Number} rad the angle in radians\n * @returns {quat} out\n **/\n\nexport function setAxisAngle(out, axis, rad) {\n  rad = rad * 0.5;\n  var s = Math.sin(rad);\n  out[0] = s * axis[0];\n  out[1] = s * axis[1];\n  out[2] = s * axis[2];\n  out[3] = Math.cos(rad);\n  return out;\n}\n/**\n * Gets the rotation axis and angle for a given\n *  quaternion. If a quaternion is created with\n *  setAxisAngle, this method will return the same\n *  values as providied in the original parameter list\n *  OR functionally equivalent values.\n * Example: The quaternion formed by axis [0, 0, 1] and\n *  angle -90 is the same as the quaternion formed by\n *  [0, 0, 1] and 270. This method favors the latter.\n * @param  {vec3} out_axis  Vector receiving the axis of rotation\n * @param  {ReadonlyQuat} q     Quaternion to be decomposed\n * @return {Number}     Angle, in radians, of the rotation\n */\n\nexport function getAxisAngle(out_axis, q) {\n  var rad = Math.acos(q[3]) * 2.0;\n  var s = Math.sin(rad / 2.0);\n\n  if (s > glMatrix.EPSILON) {\n    out_axis[0] = q[0] / s;\n    out_axis[1] = q[1] / s;\n    out_axis[2] = q[2] / s;\n  } else {\n    // If s is zero, return any axis (no rotation - axis does not matter)\n    out_axis[0] = 1;\n    out_axis[1] = 0;\n    out_axis[2] = 0;\n  }\n\n  return rad;\n}\n/**\n * Gets the angular distance between two unit quaternions\n *\n * @param  {ReadonlyQuat} a     Origin unit quaternion\n * @param  {ReadonlyQuat} b     Destination unit quaternion\n * @return {Number}     Angle, in radians, between the two quaternions\n */\n\nexport function getAngle(a, b) {\n  var dotproduct = dot(a, b);\n  return Math.acos(2 * dotproduct * dotproduct - 1);\n}\n/**\n * Multiplies two quat's\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @returns {quat} out\n */\n\nexport function multiply(out, a, b) {\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      aw = a[3];\n  var bx = b[0],\n      by = b[1],\n      bz = b[2],\n      bw = b[3];\n  out[0] = ax * bw + aw * bx + ay * bz - az * by;\n  out[1] = ay * bw + aw * by + az * bx - ax * bz;\n  out[2] = az * bw + aw * bz + ax * by - ay * bx;\n  out[3] = aw * bw - ax * bx - ay * by - az * bz;\n  return out;\n}\n/**\n * Rotates a quaternion by the given angle about the X axis\n *\n * @param {quat} out quat receiving operation result\n * @param {ReadonlyQuat} a quat to rotate\n * @param {number} rad angle (in radians) to rotate\n * @returns {quat} out\n */\n\nexport function rotateX(out, a, rad) {\n  rad *= 0.5;\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      aw = a[3];\n  var bx = Math.sin(rad),\n      bw = Math.cos(rad);\n  out[0] = ax * bw + aw * bx;\n  out[1] = ay * bw + az * bx;\n  out[2] = az * bw - ay * bx;\n  out[3] = aw * bw - ax * bx;\n  return out;\n}\n/**\n * Rotates a quaternion by the given angle about the Y axis\n *\n * @param {quat} out quat receiving operation result\n * @param {ReadonlyQuat} a quat to rotate\n * @param {number} rad angle (in radians) to rotate\n * @returns {quat} out\n */\n\nexport function rotateY(out, a, rad) {\n  rad *= 0.5;\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      aw = a[3];\n  var by = Math.sin(rad),\n      bw = Math.cos(rad);\n  out[0] = ax * bw - az * by;\n  out[1] = ay * bw + aw * by;\n  out[2] = az * bw + ax * by;\n  out[3] = aw * bw - ay * by;\n  return out;\n}\n/**\n * Rotates a quaternion by the given angle about the Z axis\n *\n * @param {quat} out quat receiving operation result\n * @param {ReadonlyQuat} a quat to rotate\n * @param {number} rad angle (in radians) to rotate\n * @returns {quat} out\n */\n\nexport function rotateZ(out, a, rad) {\n  rad *= 0.5;\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      aw = a[3];\n  var bz = Math.sin(rad),\n      bw = Math.cos(rad);\n  out[0] = ax * bw + ay * bz;\n  out[1] = ay * bw - ax * bz;\n  out[2] = az * bw + aw * bz;\n  out[3] = aw * bw - az * bz;\n  return out;\n}\n/**\n * Calculates the W component of a quat from the X, Y, and Z components.\n * Assumes that quaternion is 1 unit in length.\n * Any existing W component will be ignored.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate W component of\n * @returns {quat} out\n */\n\nexport function calculateW(out, a) {\n  var x = a[0],\n      y = a[1],\n      z = a[2];\n  out[0] = x;\n  out[1] = y;\n  out[2] = z;\n  out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));\n  return out;\n}\n/**\n * Calculate the exponential of a unit quaternion.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate the exponential of\n * @returns {quat} out\n */\n\nexport function exp(out, a) {\n  var x = a[0],\n      y = a[1],\n      z = a[2],\n      w = a[3];\n  var r = Math.sqrt(x * x + y * y + z * z);\n  var et = Math.exp(w);\n  var s = r > 0 ? et * Math.sin(r) / r : 0;\n  out[0] = x * s;\n  out[1] = y * s;\n  out[2] = z * s;\n  out[3] = et * Math.cos(r);\n  return out;\n}\n/**\n * Calculate the natural logarithm of a unit quaternion.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate the exponential of\n * @returns {quat} out\n */\n\nexport function ln(out, a) {\n  var x = a[0],\n      y = a[1],\n      z = a[2],\n      w = a[3];\n  var r = Math.sqrt(x * x + y * y + z * z);\n  var t = r > 0 ? Math.atan2(r, w) / r : 0;\n  out[0] = x * t;\n  out[1] = y * t;\n  out[2] = z * t;\n  out[3] = 0.5 * Math.log(x * x + y * y + z * z + w * w);\n  return out;\n}\n/**\n * Calculate the scalar power of a unit quaternion.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate the exponential of\n * @param {Number} b amount to scale the quaternion by\n * @returns {quat} out\n */\n\nexport function pow(out, a, b) {\n  ln(out, a);\n  scale(out, out, b);\n  exp(out, out);\n  return out;\n}\n/**\n * Performs a spherical linear interpolation between two quat\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {quat} out\n */\n\nexport function slerp(out, a, b, t) {\n  // benchmarks:\n  //    http://jsperf.com/quaternion-slerp-implementations\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      aw = a[3];\n  var bx = b[0],\n      by = b[1],\n      bz = b[2],\n      bw = b[3];\n  var omega, cosom, sinom, scale0, scale1; // calc cosine\n\n  cosom = ax * bx + ay * by + az * bz + aw * bw; // adjust signs (if necessary)\n\n  if (cosom < 0.0) {\n    cosom = -cosom;\n    bx = -bx;\n    by = -by;\n    bz = -bz;\n    bw = -bw;\n  } // calculate coefficients\n\n\n  if (1.0 - cosom > glMatrix.EPSILON) {\n    // standard case (slerp)\n    omega = Math.acos(cosom);\n    sinom = Math.sin(omega);\n    scale0 = Math.sin((1.0 - t) * omega) / sinom;\n    scale1 = Math.sin(t * omega) / sinom;\n  } else {\n    // \"from\" and \"to\" quaternions are very close\n    //  ... so we can do a linear interpolation\n    scale0 = 1.0 - t;\n    scale1 = t;\n  } // calculate final values\n\n\n  out[0] = scale0 * ax + scale1 * bx;\n  out[1] = scale0 * ay + scale1 * by;\n  out[2] = scale0 * az + scale1 * bz;\n  out[3] = scale0 * aw + scale1 * bw;\n  return out;\n}\n/**\n * Generates a random unit quaternion\n *\n * @param {quat} out the receiving quaternion\n * @returns {quat} out\n */\n\nexport function random(out) {\n  // Implementation of http://planning.cs.uiuc.edu/node198.html\n  // TODO: Calling random 3 times is probably not the fastest solution\n  var u1 = glMatrix.RANDOM();\n  var u2 = glMatrix.RANDOM();\n  var u3 = glMatrix.RANDOM();\n  var sqrt1MinusU1 = Math.sqrt(1 - u1);\n  var sqrtU1 = Math.sqrt(u1);\n  out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);\n  out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);\n  out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);\n  out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);\n  return out;\n}\n/**\n * Calculates the inverse of a quat\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate inverse of\n * @returns {quat} out\n */\n\nexport function invert(out, a) {\n  var a0 = a[0],\n      a1 = a[1],\n      a2 = a[2],\n      a3 = a[3];\n  var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;\n  var invDot = dot ? 1.0 / dot : 0; // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0\n\n  out[0] = -a0 * invDot;\n  out[1] = -a1 * invDot;\n  out[2] = -a2 * invDot;\n  out[3] = a3 * invDot;\n  return out;\n}\n/**\n * Calculates the conjugate of a quat\n * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quat to calculate conjugate of\n * @returns {quat} out\n */\n\nexport function conjugate(out, a) {\n  out[0] = -a[0];\n  out[1] = -a[1];\n  out[2] = -a[2];\n  out[3] = a[3];\n  return out;\n}\n/**\n * Creates a quaternion from the given 3x3 rotation matrix.\n *\n * NOTE: The resultant quaternion is not normalized, so you should be sure\n * to renormalize the quaternion yourself where necessary.\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyMat3} m rotation matrix\n * @returns {quat} out\n * @function\n */\n\nexport function fromMat3(out, m) {\n  // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes\n  // article \"Quaternion Calculus and Fast Animation\".\n  var fTrace = m[0] + m[4] + m[8];\n  var fRoot;\n\n  if (fTrace > 0.0) {\n    // |w| > 1/2, may as well choose w > 1/2\n    fRoot = Math.sqrt(fTrace + 1.0); // 2w\n\n    out[3] = 0.5 * fRoot;\n    fRoot = 0.5 / fRoot; // 1/(4w)\n\n    out[0] = (m[5] - m[7]) * fRoot;\n    out[1] = (m[6] - m[2]) * fRoot;\n    out[2] = (m[1] - m[3]) * fRoot;\n  } else {\n    // |w| <= 1/2\n    var i = 0;\n    if (m[4] > m[0]) i = 1;\n    if (m[8] > m[i * 3 + i]) i = 2;\n    var j = (i + 1) % 3;\n    var k = (i + 2) % 3;\n    fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);\n    out[i] = 0.5 * fRoot;\n    fRoot = 0.5 / fRoot;\n    out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;\n    out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;\n    out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;\n  }\n\n  return out;\n}\n/**\n * Creates a quaternion from the given euler angle x, y, z.\n *\n * @param {quat} out the receiving quaternion\n * @param {x} Angle to rotate around X axis in degrees.\n * @param {y} Angle to rotate around Y axis in degrees.\n * @param {z} Angle to rotate around Z axis in degrees.\n * @returns {quat} out\n * @function\n */\n\nexport function fromEuler(out, x, y, z) {\n  var halfToRad = 0.5 * Math.PI / 180.0;\n  x *= halfToRad;\n  y *= halfToRad;\n  z *= halfToRad;\n  var sx = Math.sin(x);\n  var cx = Math.cos(x);\n  var sy = Math.sin(y);\n  var cy = Math.cos(y);\n  var sz = Math.sin(z);\n  var cz = Math.cos(z);\n  out[0] = sx * cy * cz - cx * sy * sz;\n  out[1] = cx * sy * cz + sx * cy * sz;\n  out[2] = cx * cy * sz - sx * sy * cz;\n  out[3] = cx * cy * cz + sx * sy * sz;\n  return out;\n}\n/**\n * Returns a string representation of a quatenion\n *\n * @param {ReadonlyQuat} a vector to represent as a string\n * @returns {String} string representation of the vector\n */\n\nexport function str(a) {\n  return \"quat(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\n * Creates a new quat initialized with values from an existing quaternion\n *\n * @param {ReadonlyQuat} a quaternion to clone\n * @returns {quat} a new quaternion\n * @function\n */\n\nexport var clone = vec4.clone;\n/**\n * Creates a new quat initialized with the given values\n *\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @param {Number} w W component\n * @returns {quat} a new quaternion\n * @function\n */\n\nexport var fromValues = vec4.fromValues;\n/**\n * Copy the values from one quat to another\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the source quaternion\n * @returns {quat} out\n * @function\n */\n\nexport var copy = vec4.copy;\n/**\n * Set the components of a quat to the given values\n *\n * @param {quat} out the receiving quaternion\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @param {Number} w W component\n * @returns {quat} out\n * @function\n */\n\nexport var set = vec4.set;\n/**\n * Adds two quat's\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @returns {quat} out\n * @function\n */\n\nexport var add = vec4.add;\n/**\n * Alias for {@link quat.multiply}\n * @function\n */\n\nexport var mul = multiply;\n/**\n * Scales a quat by a scalar number\n *\n * @param {quat} out the receiving vector\n * @param {ReadonlyQuat} a the vector to scale\n * @param {Number} b amount to scale the vector by\n * @returns {quat} out\n * @function\n */\n\nexport var scale = vec4.scale;\n/**\n * Calculates the dot product of two quat's\n *\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @returns {Number} dot product of a and b\n * @function\n */\n\nexport var dot = vec4.dot;\n/**\n * Performs a linear interpolation between two quat's\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {quat} out\n * @function\n */\n\nexport var lerp = vec4.lerp;\n/**\n * Calculates the length of a quat\n *\n * @param {ReadonlyQuat} a vector to calculate length of\n * @returns {Number} length of a\n */\n\nexport var length = vec4.length;\n/**\n * Alias for {@link quat.length}\n * @function\n */\n\nexport var len = length;\n/**\n * Calculates the squared length of a quat\n *\n * @param {ReadonlyQuat} a vector to calculate squared length of\n * @returns {Number} squared length of a\n * @function\n */\n\nexport var squaredLength = vec4.squaredLength;\n/**\n * Alias for {@link quat.squaredLength}\n * @function\n */\n\nexport var sqrLen = squaredLength;\n/**\n * Normalize a quat\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a quaternion to normalize\n * @returns {quat} out\n * @function\n */\n\nexport var normalize = vec4.normalize;\n/**\n * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)\n *\n * @param {ReadonlyQuat} a The first quaternion.\n * @param {ReadonlyQuat} b The second quaternion.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport var exactEquals = vec4.exactEquals;\n/**\n * Returns whether or not the quaternions have approximately the same elements in the same position.\n *\n * @param {ReadonlyQuat} a The first vector.\n * @param {ReadonlyQuat} b The second vector.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport var equals = vec4.equals;\n/**\n * Sets a quaternion to represent the shortest rotation from one\n * vector to another.\n *\n * Both vectors are assumed to be unit length.\n *\n * @param {quat} out the receiving quaternion.\n * @param {ReadonlyVec3} a the initial vector\n * @param {ReadonlyVec3} b the destination vector\n * @returns {quat} out\n */\n\nexport var rotationTo = function () {\n  var tmpvec3 = vec3.create();\n  var xUnitVec3 = vec3.fromValues(1, 0, 0);\n  var yUnitVec3 = vec3.fromValues(0, 1, 0);\n  return function (out, a, b) {\n    var dot = vec3.dot(a, b);\n\n    if (dot < -0.999999) {\n      vec3.cross(tmpvec3, xUnitVec3, a);\n      if (vec3.len(tmpvec3) < 0.000001) vec3.cross(tmpvec3, yUnitVec3, a);\n      vec3.normalize(tmpvec3, tmpvec3);\n      setAxisAngle(out, tmpvec3, Math.PI);\n      return out;\n    } else if (dot > 0.999999) {\n      out[0] = 0;\n      out[1] = 0;\n      out[2] = 0;\n      out[3] = 1;\n      return out;\n    } else {\n      vec3.cross(tmpvec3, a, b);\n      out[0] = tmpvec3[0];\n      out[1] = tmpvec3[1];\n      out[2] = tmpvec3[2];\n      out[3] = 1 + dot;\n      return normalize(out, out);\n    }\n  };\n}();\n/**\n * Performs a spherical linear interpolation with two control points\n *\n * @param {quat} out the receiving quaternion\n * @param {ReadonlyQuat} a the first operand\n * @param {ReadonlyQuat} b the second operand\n * @param {ReadonlyQuat} c the third operand\n * @param {ReadonlyQuat} d the fourth operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {quat} out\n */\n\nexport var sqlerp = function () {\n  var temp1 = create();\n  var temp2 = create();\n  return function (out, a, b, c, d, t) {\n    slerp(temp1, a, d, t);\n    slerp(temp2, b, c, t);\n    slerp(out, temp1, temp2, 2 * t * (1 - t));\n    return out;\n  };\n}();\n/**\n * Sets the specified quaternion with values corresponding to the given\n * axes. Each axis is a vec3 and is expected to be unit length and\n * perpendicular to all other specified axes.\n *\n * @param {ReadonlyVec3} view  the vector representing the viewing direction\n * @param {ReadonlyVec3} right the vector representing the local \"right\" direction\n * @param {ReadonlyVec3} up    the vector representing the local \"up\" direction\n * @returns {quat} out\n */\n\nexport var setAxes = function () {\n  var matr = mat3.create();\n  return function (out, view, right, up) {\n    matr[0] = right[0];\n    matr[3] = right[1];\n    matr[6] = right[2];\n    matr[1] = up[0];\n    matr[4] = up[1];\n    matr[7] = up[2];\n    matr[2] = -view[0];\n    matr[5] = -view[1];\n    matr[8] = -view[2];\n    return normalize(out, fromMat3(out, matr));\n  };\n}();","import * as glMatrix from \"./common.js\";\n/**\n * 3 Dimensional Vector\n * @module vec3\n */\n\n/**\n * Creates a new, empty vec3\n *\n * @returns {vec3} a new 3D vector\n */\n\nexport function create() {\n  var out = new glMatrix.ARRAY_TYPE(3);\n\n  if (glMatrix.ARRAY_TYPE != Float32Array) {\n    out[0] = 0;\n    out[1] = 0;\n    out[2] = 0;\n  }\n\n  return out;\n}\n/**\n * Creates a new vec3 initialized with values from an existing vector\n *\n * @param {ReadonlyVec3} a vector to clone\n * @returns {vec3} a new 3D vector\n */\n\nexport function clone(a) {\n  var out = new glMatrix.ARRAY_TYPE(3);\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  return out;\n}\n/**\n * Calculates the length of a vec3\n *\n * @param {ReadonlyVec3} a vector to calculate length of\n * @returns {Number} length of a\n */\n\nexport function length(a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  return Math.hypot(x, y, z);\n}\n/**\n * Creates a new vec3 initialized with the given values\n *\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @returns {vec3} a new 3D vector\n */\n\nexport function fromValues(x, y, z) {\n  var out = new glMatrix.ARRAY_TYPE(3);\n  out[0] = x;\n  out[1] = y;\n  out[2] = z;\n  return out;\n}\n/**\n * Copy the values from one vec3 to another\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the source vector\n * @returns {vec3} out\n */\n\nexport function copy(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  return out;\n}\n/**\n * Set the components of a vec3 to the given values\n *\n * @param {vec3} out the receiving vector\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @returns {vec3} out\n */\n\nexport function set(out, x, y, z) {\n  out[0] = x;\n  out[1] = y;\n  out[2] = z;\n  return out;\n}\n/**\n * Adds two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function add(out, a, b) {\n  out[0] = a[0] + b[0];\n  out[1] = a[1] + b[1];\n  out[2] = a[2] + b[2];\n  return out;\n}\n/**\n * Subtracts vector b from vector a\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function subtract(out, a, b) {\n  out[0] = a[0] - b[0];\n  out[1] = a[1] - b[1];\n  out[2] = a[2] - b[2];\n  return out;\n}\n/**\n * Multiplies two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function multiply(out, a, b) {\n  out[0] = a[0] * b[0];\n  out[1] = a[1] * b[1];\n  out[2] = a[2] * b[2];\n  return out;\n}\n/**\n * Divides two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function divide(out, a, b) {\n  out[0] = a[0] / b[0];\n  out[1] = a[1] / b[1];\n  out[2] = a[2] / b[2];\n  return out;\n}\n/**\n * Math.ceil the components of a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to ceil\n * @returns {vec3} out\n */\n\nexport function ceil(out, a) {\n  out[0] = Math.ceil(a[0]);\n  out[1] = Math.ceil(a[1]);\n  out[2] = Math.ceil(a[2]);\n  return out;\n}\n/**\n * Math.floor the components of a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to floor\n * @returns {vec3} out\n */\n\nexport function floor(out, a) {\n  out[0] = Math.floor(a[0]);\n  out[1] = Math.floor(a[1]);\n  out[2] = Math.floor(a[2]);\n  return out;\n}\n/**\n * Returns the minimum of two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function min(out, a, b) {\n  out[0] = Math.min(a[0], b[0]);\n  out[1] = Math.min(a[1], b[1]);\n  out[2] = Math.min(a[2], b[2]);\n  return out;\n}\n/**\n * Returns the maximum of two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function max(out, a, b) {\n  out[0] = Math.max(a[0], b[0]);\n  out[1] = Math.max(a[1], b[1]);\n  out[2] = Math.max(a[2], b[2]);\n  return out;\n}\n/**\n * Math.round the components of a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to round\n * @returns {vec3} out\n */\n\nexport function round(out, a) {\n  out[0] = Math.round(a[0]);\n  out[1] = Math.round(a[1]);\n  out[2] = Math.round(a[2]);\n  return out;\n}\n/**\n * Scales a vec3 by a scalar number\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the vector to scale\n * @param {Number} b amount to scale the vector by\n * @returns {vec3} out\n */\n\nexport function scale(out, a, b) {\n  out[0] = a[0] * b;\n  out[1] = a[1] * b;\n  out[2] = a[2] * b;\n  return out;\n}\n/**\n * Adds two vec3's after scaling the second operand by a scalar value\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @param {Number} scale the amount to scale b by before adding\n * @returns {vec3} out\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n  out[0] = a[0] + b[0] * scale;\n  out[1] = a[1] + b[1] * scale;\n  out[2] = a[2] + b[2] * scale;\n  return out;\n}\n/**\n * Calculates the euclidian distance between two vec3's\n *\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {Number} distance between a and b\n */\n\nexport function distance(a, b) {\n  var x = b[0] - a[0];\n  var y = b[1] - a[1];\n  var z = b[2] - a[2];\n  return Math.hypot(x, y, z);\n}\n/**\n * Calculates the squared euclidian distance between two vec3's\n *\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {Number} squared distance between a and b\n */\n\nexport function squaredDistance(a, b) {\n  var x = b[0] - a[0];\n  var y = b[1] - a[1];\n  var z = b[2] - a[2];\n  return x * x + y * y + z * z;\n}\n/**\n * Calculates the squared length of a vec3\n *\n * @param {ReadonlyVec3} a vector to calculate squared length of\n * @returns {Number} squared length of a\n */\n\nexport function squaredLength(a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  return x * x + y * y + z * z;\n}\n/**\n * Negates the components of a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to negate\n * @returns {vec3} out\n */\n\nexport function negate(out, a) {\n  out[0] = -a[0];\n  out[1] = -a[1];\n  out[2] = -a[2];\n  return out;\n}\n/**\n * Returns the inverse of the components of a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to invert\n * @returns {vec3} out\n */\n\nexport function inverse(out, a) {\n  out[0] = 1.0 / a[0];\n  out[1] = 1.0 / a[1];\n  out[2] = 1.0 / a[2];\n  return out;\n}\n/**\n * Normalize a vec3\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a vector to normalize\n * @returns {vec3} out\n */\n\nexport function normalize(out, a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  var len = x * x + y * y + z * z;\n\n  if (len > 0) {\n    //TODO: evaluate use of glm_invsqrt here?\n    len = 1 / Math.sqrt(len);\n  }\n\n  out[0] = a[0] * len;\n  out[1] = a[1] * len;\n  out[2] = a[2] * len;\n  return out;\n}\n/**\n * Calculates the dot product of two vec3's\n *\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {Number} dot product of a and b\n */\n\nexport function dot(a, b) {\n  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\n}\n/**\n * Computes the cross product of two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @returns {vec3} out\n */\n\nexport function cross(out, a, b) {\n  var ax = a[0],\n      ay = a[1],\n      az = a[2];\n  var bx = b[0],\n      by = b[1],\n      bz = b[2];\n  out[0] = ay * bz - az * by;\n  out[1] = az * bx - ax * bz;\n  out[2] = ax * by - ay * bx;\n  return out;\n}\n/**\n * Performs a linear interpolation between two vec3's\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {vec3} out\n */\n\nexport function lerp(out, a, b, t) {\n  var ax = a[0];\n  var ay = a[1];\n  var az = a[2];\n  out[0] = ax + t * (b[0] - ax);\n  out[1] = ay + t * (b[1] - ay);\n  out[2] = az + t * (b[2] - az);\n  return out;\n}\n/**\n * Performs a hermite interpolation with two control points\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @param {ReadonlyVec3} c the third operand\n * @param {ReadonlyVec3} d the fourth operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {vec3} out\n */\n\nexport function hermite(out, a, b, c, d, t) {\n  var factorTimes2 = t * t;\n  var factor1 = factorTimes2 * (2 * t - 3) + 1;\n  var factor2 = factorTimes2 * (t - 2) + t;\n  var factor3 = factorTimes2 * (t - 1);\n  var factor4 = factorTimes2 * (3 - 2 * t);\n  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n  return out;\n}\n/**\n * Performs a bezier interpolation with two control points\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the first operand\n * @param {ReadonlyVec3} b the second operand\n * @param {ReadonlyVec3} c the third operand\n * @param {ReadonlyVec3} d the fourth operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {vec3} out\n */\n\nexport function bezier(out, a, b, c, d, t) {\n  var inverseFactor = 1 - t;\n  var inverseFactorTimesTwo = inverseFactor * inverseFactor;\n  var factorTimes2 = t * t;\n  var factor1 = inverseFactorTimesTwo * inverseFactor;\n  var factor2 = 3 * t * inverseFactorTimesTwo;\n  var factor3 = 3 * factorTimes2 * inverseFactor;\n  var factor4 = factorTimes2 * t;\n  out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\n  out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\n  out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\n  return out;\n}\n/**\n * Generates a random vector with the given scale\n *\n * @param {vec3} out the receiving vector\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\n * @returns {vec3} out\n */\n\nexport function random(out, scale) {\n  scale = scale || 1.0;\n  var r = glMatrix.RANDOM() * 2.0 * Math.PI;\n  var z = glMatrix.RANDOM() * 2.0 - 1.0;\n  var zScale = Math.sqrt(1.0 - z * z) * scale;\n  out[0] = Math.cos(r) * zScale;\n  out[1] = Math.sin(r) * zScale;\n  out[2] = z * scale;\n  return out;\n}\n/**\n * Transforms the vec3 with a mat4.\n * 4th vector component is implicitly '1'\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the vector to transform\n * @param {ReadonlyMat4} m matrix to transform with\n * @returns {vec3} out\n */\n\nexport function transformMat4(out, a, m) {\n  var x = a[0],\n      y = a[1],\n      z = a[2];\n  var w = m[3] * x + m[7] * y + m[11] * z + m[15];\n  w = w || 1.0;\n  out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;\n  out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;\n  out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;\n  return out;\n}\n/**\n * Transforms the vec3 with a mat3.\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the vector to transform\n * @param {ReadonlyMat3} m the 3x3 matrix to transform with\n * @returns {vec3} out\n */\n\nexport function transformMat3(out, a, m) {\n  var x = a[0],\n      y = a[1],\n      z = a[2];\n  out[0] = x * m[0] + y * m[3] + z * m[6];\n  out[1] = x * m[1] + y * m[4] + z * m[7];\n  out[2] = x * m[2] + y * m[5] + z * m[8];\n  return out;\n}\n/**\n * Transforms the vec3 with a quat\n * Can also be used for dual quaternions. (Multiply it with the real part)\n *\n * @param {vec3} out the receiving vector\n * @param {ReadonlyVec3} a the vector to transform\n * @param {ReadonlyQuat} q quaternion to transform with\n * @returns {vec3} out\n */\n\nexport function transformQuat(out, a, q) {\n  // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed\n  var qx = q[0],\n      qy = q[1],\n      qz = q[2],\n      qw = q[3];\n  var x = a[0],\n      y = a[1],\n      z = a[2]; // var qvec = [qx, qy, qz];\n  // var uv = vec3.cross([], qvec, a);\n\n  var uvx = qy * z - qz * y,\n      uvy = qz * x - qx * z,\n      uvz = qx * y - qy * x; // var uuv = vec3.cross([], qvec, uv);\n\n  var uuvx = qy * uvz - qz * uvy,\n      uuvy = qz * uvx - qx * uvz,\n      uuvz = qx * uvy - qy * uvx; // vec3.scale(uv, uv, 2 * w);\n\n  var w2 = qw * 2;\n  uvx *= w2;\n  uvy *= w2;\n  uvz *= w2; // vec3.scale(uuv, uuv, 2);\n\n  uuvx *= 2;\n  uuvy *= 2;\n  uuvz *= 2; // return vec3.add(out, a, vec3.add(out, uv, uuv));\n\n  out[0] = x + uvx + uuvx;\n  out[1] = y + uvy + uuvy;\n  out[2] = z + uvz + uuvz;\n  return out;\n}\n/**\n * Rotate a 3D vector around the x-axis\n * @param {vec3} out The receiving vec3\n * @param {ReadonlyVec3} a The vec3 point to rotate\n * @param {ReadonlyVec3} b The origin of the rotation\n * @param {Number} rad The angle of rotation in radians\n * @returns {vec3} out\n */\n\nexport function rotateX(out, a, b, rad) {\n  var p = [],\n      r = []; //Translate point to the origin\n\n  p[0] = a[0] - b[0];\n  p[1] = a[1] - b[1];\n  p[2] = a[2] - b[2]; //perform rotation\n\n  r[0] = p[0];\n  r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);\n  r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad); //translate to correct position\n\n  out[0] = r[0] + b[0];\n  out[1] = r[1] + b[1];\n  out[2] = r[2] + b[2];\n  return out;\n}\n/**\n * Rotate a 3D vector around the y-axis\n * @param {vec3} out The receiving vec3\n * @param {ReadonlyVec3} a The vec3 point to rotate\n * @param {ReadonlyVec3} b The origin of the rotation\n * @param {Number} rad The angle of rotation in radians\n * @returns {vec3} out\n */\n\nexport function rotateY(out, a, b, rad) {\n  var p = [],\n      r = []; //Translate point to the origin\n\n  p[0] = a[0] - b[0];\n  p[1] = a[1] - b[1];\n  p[2] = a[2] - b[2]; //perform rotation\n\n  r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);\n  r[1] = p[1];\n  r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad); //translate to correct position\n\n  out[0] = r[0] + b[0];\n  out[1] = r[1] + b[1];\n  out[2] = r[2] + b[2];\n  return out;\n}\n/**\n * Rotate a 3D vector around the z-axis\n * @param {vec3} out The receiving vec3\n * @param {ReadonlyVec3} a The vec3 point to rotate\n * @param {ReadonlyVec3} b The origin of the rotation\n * @param {Number} rad The angle of rotation in radians\n * @returns {vec3} out\n */\n\nexport function rotateZ(out, a, b, rad) {\n  var p = [],\n      r = []; //Translate point to the origin\n\n  p[0] = a[0] - b[0];\n  p[1] = a[1] - b[1];\n  p[2] = a[2] - b[2]; //perform rotation\n\n  r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);\n  r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);\n  r[2] = p[2]; //translate to correct position\n\n  out[0] = r[0] + b[0];\n  out[1] = r[1] + b[1];\n  out[2] = r[2] + b[2];\n  return out;\n}\n/**\n * Get the angle between two 3D vectors\n * @param {ReadonlyVec3} a The first operand\n * @param {ReadonlyVec3} b The second operand\n * @returns {Number} The angle in radians\n */\n\nexport function angle(a, b) {\n  var ax = a[0],\n      ay = a[1],\n      az = a[2],\n      bx = b[0],\n      by = b[1],\n      bz = b[2],\n      mag1 = Math.sqrt(ax * ax + ay * ay + az * az),\n      mag2 = Math.sqrt(bx * bx + by * by + bz * bz),\n      mag = mag1 * mag2,\n      cosine = mag && dot(a, b) / mag;\n  return Math.acos(Math.min(Math.max(cosine, -1), 1));\n}\n/**\n * Set the components of a vec3 to zero\n *\n * @param {vec3} out the receiving vector\n * @returns {vec3} out\n */\n\nexport function zero(out) {\n  out[0] = 0.0;\n  out[1] = 0.0;\n  out[2] = 0.0;\n  return out;\n}\n/**\n * Returns a string representation of a vector\n *\n * @param {ReadonlyVec3} a vector to represent as a string\n * @returns {String} string representation of the vector\n */\n\nexport function str(a) {\n  return \"vec3(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \")\";\n}\n/**\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\n *\n * @param {ReadonlyVec3} a The first vector.\n * @param {ReadonlyVec3} b The second vector.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport function exactEquals(a, b) {\n  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];\n}\n/**\n * Returns whether or not the vectors have approximately the same elements in the same position.\n *\n * @param {ReadonlyVec3} a The first vector.\n * @param {ReadonlyVec3} b The second vector.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport function equals(a, b) {\n  var a0 = a[0],\n      a1 = a[1],\n      a2 = a[2];\n  var b0 = b[0],\n      b1 = b[1],\n      b2 = b[2];\n  return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));\n}\n/**\n * Alias for {@link vec3.subtract}\n * @function\n */\n\nexport var sub = subtract;\n/**\n * Alias for {@link vec3.multiply}\n * @function\n */\n\nexport var mul = multiply;\n/**\n * Alias for {@link vec3.divide}\n * @function\n */\n\nexport var div = divide;\n/**\n * Alias for {@link vec3.distance}\n * @function\n */\n\nexport var dist = distance;\n/**\n * Alias for {@link vec3.squaredDistance}\n * @function\n */\n\nexport var sqrDist = squaredDistance;\n/**\n * Alias for {@link vec3.length}\n * @function\n */\n\nexport var len = length;\n/**\n * Alias for {@link vec3.squaredLength}\n * @function\n */\n\nexport var sqrLen = squaredLength;\n/**\n * Perform some operation over an array of vec3s.\n *\n * @param {Array} a the array of vectors to iterate over\n * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed\n * @param {Number} offset Number of elements to skip at the beginning of the array\n * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array\n * @param {Function} fn Function to call for each vector in the array\n * @param {Object} [arg] additional argument to pass to fn\n * @returns {Array} a\n * @function\n */\n\nexport var forEach = function () {\n  var vec = create();\n  return function (a, stride, offset, count, fn, arg) {\n    var i, l;\n\n    if (!stride) {\n      stride = 3;\n    }\n\n    if (!offset) {\n      offset = 0;\n    }\n\n    if (count) {\n      l = Math.min(count * stride + offset, a.length);\n    } else {\n      l = a.length;\n    }\n\n    for (i = offset; i < l; i += stride) {\n      vec[0] = a[i];\n      vec[1] = a[i + 1];\n      vec[2] = a[i + 2];\n      fn(vec, vec, arg);\n      a[i] = vec[0];\n      a[i + 1] = vec[1];\n      a[i + 2] = vec[2];\n    }\n\n    return a;\n  };\n}();","import * as glMatrix from \"./common.js\";\n/**\n * 4 Dimensional Vector\n * @module vec4\n */\n\n/**\n * Creates a new, empty vec4\n *\n * @returns {vec4} a new 4D vector\n */\n\nexport function create() {\n  var out = new glMatrix.ARRAY_TYPE(4);\n\n  if (glMatrix.ARRAY_TYPE != Float32Array) {\n    out[0] = 0;\n    out[1] = 0;\n    out[2] = 0;\n    out[3] = 0;\n  }\n\n  return out;\n}\n/**\n * Creates a new vec4 initialized with values from an existing vector\n *\n * @param {ReadonlyVec4} a vector to clone\n * @returns {vec4} a new 4D vector\n */\n\nexport function clone(a) {\n  var out = new glMatrix.ARRAY_TYPE(4);\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  return out;\n}\n/**\n * Creates a new vec4 initialized with the given values\n *\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @param {Number} w W component\n * @returns {vec4} a new 4D vector\n */\n\nexport function fromValues(x, y, z, w) {\n  var out = new glMatrix.ARRAY_TYPE(4);\n  out[0] = x;\n  out[1] = y;\n  out[2] = z;\n  out[3] = w;\n  return out;\n}\n/**\n * Copy the values from one vec4 to another\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the source vector\n * @returns {vec4} out\n */\n\nexport function copy(out, a) {\n  out[0] = a[0];\n  out[1] = a[1];\n  out[2] = a[2];\n  out[3] = a[3];\n  return out;\n}\n/**\n * Set the components of a vec4 to the given values\n *\n * @param {vec4} out the receiving vector\n * @param {Number} x X component\n * @param {Number} y Y component\n * @param {Number} z Z component\n * @param {Number} w W component\n * @returns {vec4} out\n */\n\nexport function set(out, x, y, z, w) {\n  out[0] = x;\n  out[1] = y;\n  out[2] = z;\n  out[3] = w;\n  return out;\n}\n/**\n * Adds two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function add(out, a, b) {\n  out[0] = a[0] + b[0];\n  out[1] = a[1] + b[1];\n  out[2] = a[2] + b[2];\n  out[3] = a[3] + b[3];\n  return out;\n}\n/**\n * Subtracts vector b from vector a\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function subtract(out, a, b) {\n  out[0] = a[0] - b[0];\n  out[1] = a[1] - b[1];\n  out[2] = a[2] - b[2];\n  out[3] = a[3] - b[3];\n  return out;\n}\n/**\n * Multiplies two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function multiply(out, a, b) {\n  out[0] = a[0] * b[0];\n  out[1] = a[1] * b[1];\n  out[2] = a[2] * b[2];\n  out[3] = a[3] * b[3];\n  return out;\n}\n/**\n * Divides two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function divide(out, a, b) {\n  out[0] = a[0] / b[0];\n  out[1] = a[1] / b[1];\n  out[2] = a[2] / b[2];\n  out[3] = a[3] / b[3];\n  return out;\n}\n/**\n * Math.ceil the components of a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to ceil\n * @returns {vec4} out\n */\n\nexport function ceil(out, a) {\n  out[0] = Math.ceil(a[0]);\n  out[1] = Math.ceil(a[1]);\n  out[2] = Math.ceil(a[2]);\n  out[3] = Math.ceil(a[3]);\n  return out;\n}\n/**\n * Math.floor the components of a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to floor\n * @returns {vec4} out\n */\n\nexport function floor(out, a) {\n  out[0] = Math.floor(a[0]);\n  out[1] = Math.floor(a[1]);\n  out[2] = Math.floor(a[2]);\n  out[3] = Math.floor(a[3]);\n  return out;\n}\n/**\n * Returns the minimum of two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function min(out, a, b) {\n  out[0] = Math.min(a[0], b[0]);\n  out[1] = Math.min(a[1], b[1]);\n  out[2] = Math.min(a[2], b[2]);\n  out[3] = Math.min(a[3], b[3]);\n  return out;\n}\n/**\n * Returns the maximum of two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {vec4} out\n */\n\nexport function max(out, a, b) {\n  out[0] = Math.max(a[0], b[0]);\n  out[1] = Math.max(a[1], b[1]);\n  out[2] = Math.max(a[2], b[2]);\n  out[3] = Math.max(a[3], b[3]);\n  return out;\n}\n/**\n * Math.round the components of a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to round\n * @returns {vec4} out\n */\n\nexport function round(out, a) {\n  out[0] = Math.round(a[0]);\n  out[1] = Math.round(a[1]);\n  out[2] = Math.round(a[2]);\n  out[3] = Math.round(a[3]);\n  return out;\n}\n/**\n * Scales a vec4 by a scalar number\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the vector to scale\n * @param {Number} b amount to scale the vector by\n * @returns {vec4} out\n */\n\nexport function scale(out, a, b) {\n  out[0] = a[0] * b;\n  out[1] = a[1] * b;\n  out[2] = a[2] * b;\n  out[3] = a[3] * b;\n  return out;\n}\n/**\n * Adds two vec4's after scaling the second operand by a scalar value\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @param {Number} scale the amount to scale b by before adding\n * @returns {vec4} out\n */\n\nexport function scaleAndAdd(out, a, b, scale) {\n  out[0] = a[0] + b[0] * scale;\n  out[1] = a[1] + b[1] * scale;\n  out[2] = a[2] + b[2] * scale;\n  out[3] = a[3] + b[3] * scale;\n  return out;\n}\n/**\n * Calculates the euclidian distance between two vec4's\n *\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {Number} distance between a and b\n */\n\nexport function distance(a, b) {\n  var x = b[0] - a[0];\n  var y = b[1] - a[1];\n  var z = b[2] - a[2];\n  var w = b[3] - a[3];\n  return Math.hypot(x, y, z, w);\n}\n/**\n * Calculates the squared euclidian distance between two vec4's\n *\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {Number} squared distance between a and b\n */\n\nexport function squaredDistance(a, b) {\n  var x = b[0] - a[0];\n  var y = b[1] - a[1];\n  var z = b[2] - a[2];\n  var w = b[3] - a[3];\n  return x * x + y * y + z * z + w * w;\n}\n/**\n * Calculates the length of a vec4\n *\n * @param {ReadonlyVec4} a vector to calculate length of\n * @returns {Number} length of a\n */\n\nexport function length(a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  var w = a[3];\n  return Math.hypot(x, y, z, w);\n}\n/**\n * Calculates the squared length of a vec4\n *\n * @param {ReadonlyVec4} a vector to calculate squared length of\n * @returns {Number} squared length of a\n */\n\nexport function squaredLength(a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  var w = a[3];\n  return x * x + y * y + z * z + w * w;\n}\n/**\n * Negates the components of a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to negate\n * @returns {vec4} out\n */\n\nexport function negate(out, a) {\n  out[0] = -a[0];\n  out[1] = -a[1];\n  out[2] = -a[2];\n  out[3] = -a[3];\n  return out;\n}\n/**\n * Returns the inverse of the components of a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to invert\n * @returns {vec4} out\n */\n\nexport function inverse(out, a) {\n  out[0] = 1.0 / a[0];\n  out[1] = 1.0 / a[1];\n  out[2] = 1.0 / a[2];\n  out[3] = 1.0 / a[3];\n  return out;\n}\n/**\n * Normalize a vec4\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a vector to normalize\n * @returns {vec4} out\n */\n\nexport function normalize(out, a) {\n  var x = a[0];\n  var y = a[1];\n  var z = a[2];\n  var w = a[3];\n  var len = x * x + y * y + z * z + w * w;\n\n  if (len > 0) {\n    len = 1 / Math.sqrt(len);\n  }\n\n  out[0] = x * len;\n  out[1] = y * len;\n  out[2] = z * len;\n  out[3] = w * len;\n  return out;\n}\n/**\n * Calculates the dot product of two vec4's\n *\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @returns {Number} dot product of a and b\n */\n\nexport function dot(a, b) {\n  return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\n}\n/**\n * Returns the cross-product of three vectors in a 4-dimensional space\n *\n * @param {ReadonlyVec4} result the receiving vector\n * @param {ReadonlyVec4} U the first vector\n * @param {ReadonlyVec4} V the second vector\n * @param {ReadonlyVec4} W the third vector\n * @returns {vec4} result\n */\n\nexport function cross(out, u, v, w) {\n  var A = v[0] * w[1] - v[1] * w[0],\n      B = v[0] * w[2] - v[2] * w[0],\n      C = v[0] * w[3] - v[3] * w[0],\n      D = v[1] * w[2] - v[2] * w[1],\n      E = v[1] * w[3] - v[3] * w[1],\n      F = v[2] * w[3] - v[3] * w[2];\n  var G = u[0];\n  var H = u[1];\n  var I = u[2];\n  var J = u[3];\n  out[0] = H * F - I * E + J * D;\n  out[1] = -(G * F) + I * C - J * B;\n  out[2] = G * E - H * C + J * A;\n  out[3] = -(G * D) + H * B - I * A;\n  return out;\n}\n/**\n * Performs a linear interpolation between two vec4's\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the first operand\n * @param {ReadonlyVec4} b the second operand\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\n * @returns {vec4} out\n */\n\nexport function lerp(out, a, b, t) {\n  var ax = a[0];\n  var ay = a[1];\n  var az = a[2];\n  var aw = a[3];\n  out[0] = ax + t * (b[0] - ax);\n  out[1] = ay + t * (b[1] - ay);\n  out[2] = az + t * (b[2] - az);\n  out[3] = aw + t * (b[3] - aw);\n  return out;\n}\n/**\n * Generates a random vector with the given scale\n *\n * @param {vec4} out the receiving vector\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\n * @returns {vec4} out\n */\n\nexport function random(out, scale) {\n  scale = scale || 1.0; // Marsaglia, George. Choosing a Point from the Surface of a\n  // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.\n  // http://projecteuclid.org/euclid.aoms/1177692644;\n\n  var v1, v2, v3, v4;\n  var s1, s2;\n\n  do {\n    v1 = glMatrix.RANDOM() * 2 - 1;\n    v2 = glMatrix.RANDOM() * 2 - 1;\n    s1 = v1 * v1 + v2 * v2;\n  } while (s1 >= 1);\n\n  do {\n    v3 = glMatrix.RANDOM() * 2 - 1;\n    v4 = glMatrix.RANDOM() * 2 - 1;\n    s2 = v3 * v3 + v4 * v4;\n  } while (s2 >= 1);\n\n  var d = Math.sqrt((1 - s1) / s2);\n  out[0] = scale * v1;\n  out[1] = scale * v2;\n  out[2] = scale * v3 * d;\n  out[3] = scale * v4 * d;\n  return out;\n}\n/**\n * Transforms the vec4 with a mat4.\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the vector to transform\n * @param {ReadonlyMat4} m matrix to transform with\n * @returns {vec4} out\n */\n\nexport function transformMat4(out, a, m) {\n  var x = a[0],\n      y = a[1],\n      z = a[2],\n      w = a[3];\n  out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;\n  out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;\n  out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;\n  out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;\n  return out;\n}\n/**\n * Transforms the vec4 with a quat\n *\n * @param {vec4} out the receiving vector\n * @param {ReadonlyVec4} a the vector to transform\n * @param {ReadonlyQuat} q quaternion to transform with\n * @returns {vec4} out\n */\n\nexport function transformQuat(out, a, q) {\n  var x = a[0],\n      y = a[1],\n      z = a[2];\n  var qx = q[0],\n      qy = q[1],\n      qz = q[2],\n      qw = q[3]; // calculate quat * vec\n\n  var ix = qw * x + qy * z - qz * y;\n  var iy = qw * y + qz * x - qx * z;\n  var iz = qw * z + qx * y - qy * x;\n  var iw = -qx * x - qy * y - qz * z; // calculate result * inverse quat\n\n  out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;\n  out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;\n  out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;\n  out[3] = a[3];\n  return out;\n}\n/**\n * Set the components of a vec4 to zero\n *\n * @param {vec4} out the receiving vector\n * @returns {vec4} out\n */\n\nexport function zero(out) {\n  out[0] = 0.0;\n  out[1] = 0.0;\n  out[2] = 0.0;\n  out[3] = 0.0;\n  return out;\n}\n/**\n * Returns a string representation of a vector\n *\n * @param {ReadonlyVec4} a vector to represent as a string\n * @returns {String} string representation of the vector\n */\n\nexport function str(a) {\n  return \"vec4(\" + a[0] + \", \" + a[1] + \", \" + a[2] + \", \" + a[3] + \")\";\n}\n/**\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\n *\n * @param {ReadonlyVec4} a The first vector.\n * @param {ReadonlyVec4} b The second vector.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport function exactEquals(a, b) {\n  return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];\n}\n/**\n * Returns whether or not the vectors have approximately the same elements in the same position.\n *\n * @param {ReadonlyVec4} a The first vector.\n * @param {ReadonlyVec4} b The second vector.\n * @returns {Boolean} True if the vectors are equal, false otherwise.\n */\n\nexport function equals(a, b) {\n  var a0 = a[0],\n      a1 = a[1],\n      a2 = a[2],\n      a3 = a[3];\n  var b0 = b[0],\n      b1 = b[1],\n      b2 = b[2],\n      b3 = b[3];\n  return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));\n}\n/**\n * Alias for {@link vec4.subtract}\n * @function\n */\n\nexport var sub = subtract;\n/**\n * Alias for {@link vec4.multiply}\n * @function\n */\n\nexport var mul = multiply;\n/**\n * Alias for {@link vec4.divide}\n * @function\n */\n\nexport var div = divide;\n/**\n * Alias for {@link vec4.distance}\n * @function\n */\n\nexport var dist = distance;\n/**\n * Alias for {@link vec4.squaredDistance}\n * @function\n */\n\nexport var sqrDist = squaredDistance;\n/**\n * Alias for {@link vec4.length}\n * @function\n */\n\nexport var len = length;\n/**\n * Alias for {@link vec4.squaredLength}\n * @function\n */\n\nexport var sqrLen = squaredLength;\n/**\n * Perform some operation over an array of vec4s.\n *\n * @param {Array} a the array of vectors to iterate over\n * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed\n * @param {Number} offset Number of elements to skip at the beginning of the array\n * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array\n * @param {Function} fn Function to call for each vector in the array\n * @param {Object} [arg] additional argument to pass to fn\n * @returns {Array} a\n * @function\n */\n\nexport var forEach = function () {\n  var vec = create();\n  return function (a, stride, offset, count, fn, arg) {\n    var i, l;\n\n    if (!stride) {\n      stride = 4;\n    }\n\n    if (!offset) {\n      offset = 0;\n    }\n\n    if (count) {\n      l = Math.min(count * stride + offset, a.length);\n    } else {\n      l = a.length;\n    }\n\n    for (i = offset; i < l; i += stride) {\n      vec[0] = a[i];\n      vec[1] = a[i + 1];\n      vec[2] = a[i + 2];\n      vec[3] = a[i + 3];\n      fn(vec, vec, arg);\n      a[i] = vec[0];\n      a[i + 1] = vec[1];\n      a[i + 2] = vec[2];\n      a[i + 3] = vec[3];\n    }\n\n    return a;\n  };\n}();","import getPrototypeOf from \"./getPrototypeOf.js\";\nexport default function _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n\n  return object;\n}","import superPropBase from \"./superPropBase.js\";\nexport default function _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    _get = Reflect.get;\n  } else {\n    _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n\n      return desc.value;\n    };\n  }\n\n  return _get.apply(this, arguments);\n}","import { clamp01, clamp11 } from \"./interval.js\";\n/**\n * Returns normalized value of `x` WRT to interval `a .. b`. If `a`\n * equals `b`, returns 0.\n *\n * @param x -\n * @param a -\n * @param b -\n */\nexport const norm = (x, a, b) => (b !== a ? (x - a) / (b - a) : 0);\n/**\n * Returns a number in the `[c,d]` interval which is relative to `x` in the\n * `[a,b]` interval. **No** clamping will be performed if `x` lies outside the\n * original range (for that use {@link fitClamped} instead).\n *\n * @param x\n * @param a\n * @param b\n * @param c\n * @param d\n */\nexport const fit = (x, a, b, c, d) => c + (d - c) * norm(x, a, b);\n/**\n * Clamped version of {@link fit}, i.e. before mapping `x` into the target\n * interval `[c,d]`, it will be clamped to the source interval `[a,b]`.\n *\n * @param x\n * @param a\n * @param b\n * @param c\n * @param d\n */\nexport const fitClamped = (x, a, b, c, d) => c + (d - c) * clamp01(norm(x, a, b));\n/**\n * Similar to {@link fitClamped}, assuming [0,1] as source interval.\n *\n * @param x\n * @param a\n * @param b\n */\nexport const fit01 = (x, a, b) => a + (b - a) * clamp01(x);\n/**\n * Similar to {@link fitClamped}, assuming the reverse ordered [1,0] as source\n * interval.\n *\n * @param x\n * @param a\n * @param b\n */\nexport const fit10 = (x, a, b) => b + (a - b) * clamp01(x);\n/**\n * Similar to {@link fitClamped}, assuming [-1,1] as source interval.\n *\n * @param x\n * @param a\n * @param b\n */\nexport const fit11 = (x, a, b) => a + (b - a) * (0.5 + 0.5 * clamp11(x));\n","export const compare = (a, b) => {\n    if (a === b) {\n        return 0;\n    }\n    if (a == null) {\n        return b == null ? 0 : -1;\n    }\n    if (b == null) {\n        return a == null ? 0 : 1;\n    }\n    if (typeof a.compare === \"function\") {\n        return a.compare(b);\n    }\n    if (typeof b.compare === \"function\") {\n        return -b.compare(a);\n    }\n    return a < b ? -1 : a > b ? 1 : 0;\n};\n","/**\n * Numeric comparator (ascending order)\n *\n * @param a -\n * @param b -\n */\nexport const compareNumAsc = (a, b) => a - b;\n/**\n * Numeric comparator (descending order)\n *\n * @param a -\n * @param b -\n */\nexport const compareNumDesc = (a, b) => b - a;\n","import { EPS } from \"./api.js\";\nexport const absDiff = (x, y) => Math.abs(x - y);\nexport const sign = (x, eps = EPS) => (x > eps ? 1 : x < -eps ? -1 : 0);\n","/**\n * Clamps value `x` to given closed interval.\n *\n * @param x - value to clamp\n * @param min - lower bound\n * @param max - upper bound\n */\nexport const clamp = (x, min, max) => (x < min ? min : x > max ? max : x);\n/**\n * Clamps value `x` to closed [0 .. ∞] interval.\n *\n * @param x -\n */\nexport const clamp0 = (x) => (x > 0 ? x : 0);\n/**\n * Clamps value `x` to closed [0 .. 1] interval.\n *\n * @param x -\n */\nexport const clamp01 = (x) => (x < 0 ? 0 : x > 1 ? 1 : x);\n/**\n * Clamps value `x` to closed [-1 .. 1] interval.\n *\n * @param x -\n */\nexport const clamp11 = (x) => (x < -1 ? -1 : x > 1 ? 1 : x);\n/**\n * Clamps value `x` to closed [0 .. 0.5] interval.\n *\n * @param x -\n */\nexport const clamp05 = (x) => (x < 0 ? 0 : x > 0.5 ? 0.5 : x);\n/**\n * Returns 2-tuple of [min(x,y), max(x,y)].\n *\n * @param x\n * @param y\n */\nexport const minMax = (x, y) => x < y ? [x, y] : [y, x];\n/**\n * Folds `x` back inside closed [min..max] interval. Also see\n * {@link wrapOnce}.\n *\n * @param x -\n * @param min -\n * @param max -\n */\nexport const wrap = (x, min, max) => {\n    if (min === max)\n        return min;\n    if (x > max) {\n        const d = max - min;\n        x -= d;\n        if (x > max)\n            x -= d * (((x - min) / d) | 0);\n    }\n    else if (x < min) {\n        const d = max - min;\n        x += d;\n        if (x < min)\n            x += d * (((min - x) / d + 1) | 0);\n    }\n    return x;\n};\n/**\n * Like {@link wrap}, but optimized for cases where `x` is guaranteed to\n * be in `[min - d, max + d]` interval, where `d = max - min`. Result\n * will be in closed `[min..max]` interval.\n *\n * @param x -\n * @param min -\n * @param max -\n */\nexport const wrapOnce = (x, min, max) => x < min ? x - min + max : x > max ? x - max + min : x;\n/**\n * Similar to {@link wrapOnce} for [0..1] interval.\n *\n * @param x -\n */\nexport const wrap01 = (x) => (x < 0 ? x + 1 : x > 1 ? x - 1 : x);\n/**\n * Similar to {@link wrapOnce} for [-1..1] interval.\n *\n * @param x -\n */\nexport const wrap11 = (x) => (x < -1 ? x + 2 : x > 1 ? x - 2 : x);\nexport const min2id = (a, b) => (a <= b ? 0 : 1);\nexport const min3id = (a, b, c) => a <= b ? (a <= c ? 0 : 2) : b <= c ? 1 : 2;\nexport const min4id = (a, b, c, d) => a <= b\n    ? a <= c\n        ? a <= d\n            ? 0\n            : 3\n        : c <= d\n            ? 2\n            : 3\n    : b <= c\n        ? b <= d\n            ? 1\n            : 3\n        : c <= d\n            ? 2\n            : 3;\nexport const max2id = (a, b) => (a >= b ? 0 : 1);\nexport const max3id = (a, b, c) => a >= b ? (a >= c ? 0 : 2) : b >= c ? 1 : 2;\nexport const max4id = (a, b, c, d) => a >= b\n    ? a >= c\n        ? a >= d\n            ? 0\n            : 3\n        : c >= d\n            ? 2\n            : 3\n    : b >= c\n        ? b >= d\n            ? 1\n            : 3\n        : c >= d\n            ? 2\n            : 3;\n/**\n * Returns the non-zero minimum value of the given `a`, `b` args.\n *\n * @param a -\n * @param b -\n */\nexport const minNonZero2 = (a, b) => a !== 0 ? (b !== 0 ? Math.min(a, b) : a) : b;\n/**\n * Returns the non-zero minimum value of the given `a`, `b`, `c` args.\n *\n * @param a -\n * @param b -\n * @param c -\n */\nexport const minNonZero3 = (a, b, c) => minNonZero2(minNonZero2(a, b), c);\n/**\n * See `smax()`.\n *\n * @param a -\n * @param b -\n * @param k - smooth exponent (MUST be > 0)\n */\nexport const smin = (a, b, k) => smax(a, b, -k);\n/**\n * Smooth maximum. Note: Result values will be slightly larger than max value\n * near max(a,b) + eps due to exponential decay. Higher `k` values reduce the\n * error, but also reduce the smoothing. Recommended k=16.\n *\n * https://en.wikipedia.org/wiki/Smooth_maximum\n *\n * @param a -\n * @param b -\n * @param k - smooth exponent (MUST be > 0)\n */\nexport const smax = (a, b, k) => {\n    const ea = Math.exp(a * k);\n    const eb = Math.exp(b * k);\n    return (a * ea + b * eb) / (ea + eb);\n};\n/**\n * Same as `smin(smax(x, min, k), max, k)`.\n *\n * @param x -\n * @param min -\n * @param max -\n * @param k -\n */\nexport const sclamp = (x, min, max, k) => smin(smax(x, min, k), max, k);\nexport const absMin = (a, b) => (Math.abs(a) < Math.abs(b) ? a : b);\nexport const absMax = (a, b) => (Math.abs(a) > Math.abs(b) ? a : b);\n/**\n * If `abs(x) > abs(e)`, recursively mirrors `x` back into `[-e .. +e]`\n * interval at respective positive/negative boundary.\n *\n * @remarks\n * References:\n * - https://www.desmos.com/calculator/lkyf2ag3ta\n * - https://www.musicdsp.org/en/latest/Effects/203-fold-back-distortion.html\n *\n * @param e - threshold (> 0)\n * @param x - input value\n */\nexport const foldback = (e, x) => x < -e || x > e ? Math.abs(Math.abs((x - e) % (4 * e)) - 2 * e) - e : x;\n/**\n * Similar to {@link foldback}, but with fixed target range: Folds `x` into the\n * closed [0..1] interval, using infinite internal reflection on either side of\n * the interval.\n *\n * @param x\n */\nexport const foldback01 = (x) => ((x = Math.abs(x) % 2) > 1 ? 2 - x : x);\n/**\n * Returns true iff `x` is in closed interval `[min .. max]`\n *\n * @param x -\n * @param min -\n * @param max -\n */\nexport const inRange = (x, min, max) => x >= min && x <= max;\n/**\n * Returns true iff `x` is in open interval `(min .. max)`\n *\n * @param x -\n * @param min -\n * @param max -\n */\nexport const inOpenRange = (x, min, max) => x > min && x < max;\n","import { binarySearch } from \"@thi.ng/arrays/binary-search\";\nimport { compareNumAsc } from \"@thi.ng/compare/numeric\";\nimport { absDiff } from \"@thi.ng/math/abs\";\nimport { clamp } from \"@thi.ng/math/interval\";\nexport class ARamp {\n    constructor(stops = [\n        [0, 0],\n        [1, 1],\n    ]) {\n        this.stops = stops;\n    }\n    bounds() {\n        const stops = this.stops;\n        const n = stops.length;\n        if (!n)\n            return { min: 0, max: 0, minT: 0, maxT: 0 };\n        let min = Infinity;\n        let max = -Infinity;\n        for (let i = n; i-- > 0;) {\n            const y = stops[i][1];\n            min = Math.min(min, y);\n            max = Math.max(max, y);\n        }\n        return { min, max, minT: stops[0][0], maxT: stops[n - 1][0] };\n    }\n    addStopAt(t, y, eps = 0.01) {\n        if (this.closestIndex(t, eps) !== -1) {\n            this.stops.push([t, y]);\n            this.sort();\n            return true;\n        }\n        return false;\n    }\n    removeStopAt(t, eps = 0.01) {\n        if (this.stops.length > 2) {\n            const i = this.closestIndex(t, eps);\n            if (i !== -1) {\n                this.stops.splice(i, 1);\n                return true;\n            }\n        }\n        return false;\n    }\n    closestIndex(t, eps = 0.01) {\n        const stops = this.stops;\n        for (let i = stops.length; i-- > 0;) {\n            if (absDiff(t, stops[i][0]) < eps)\n                return i;\n        }\n        return -1;\n    }\n    clampedIndexTime(i, t, eps = 0.01) {\n        const stops = this.stops;\n        const n = stops.length - 1;\n        return i == 0\n            ? Math.min(t, stops[1][0] - eps)\n            : i === n\n                ? Math.max(t, stops[n - 1][0] + eps)\n                : clamp(t, stops[i - 1][0] + eps, stops[i + 1][0] - eps);\n    }\n    sort() {\n        this.stops.sort((a, b) => a[0] - b[0]);\n    }\n    uniform() {\n        const n = this.stops.length - 1;\n        this.stops.forEach((p, i) => (p[0] = i / n));\n    }\n    timeIndex(t) {\n        const stops = this.stops;\n        const n = stops.length;\n        if (n < 256) {\n            for (let i = n; i-- > 0;) {\n                if (t >= stops[i][0])\n                    return i;\n            }\n            return -1;\n        }\n        return binarySearch(stops, [t], (x) => x[0], compareNumAsc);\n    }\n}\n","import { compare } from \"@thi.ng/compare/compare\";\nimport { compareNumAsc } from \"@thi.ng/compare/numeric\";\n/**\n * Returns the supposed index of `x` in pre-sorted array-like collection `buf`.\n *\n * @remarks\n * If `x` can't be found, returns `-index-1`, representing the negative of the\n * index, were `x` to be inserted into `buf`. E.g if the return value is -3, `x`\n * would appear/insert at index 2.\n *\n * The optional `key` function is used to obtain the actual sort value of `x`\n * and each array item (default: identity).\n *\n * The optional `cmp` comparator (default:\n * [`compare()`](https://docs.thi.ng/umbrella/compare/functions/compare.html))\n * is then used to identify the index of `x`. The sort order of `buf` MUST be\n * compatible with that of `cmp`.\n *\n * @example\n * ```ts\n * binarySearch([2, 4, 6], 5);\n * // -3\n * ```\n *\n * @param buf - array\n * @param x - search value\n * @param key - key function\n * @param cmp - comparator\n * @param low - min index\n * @param high - max index\n */\nexport const binarySearch = (buf, x, key = (x) => x, cmp = compare, low = 0, high = buf.length - 1) => {\n    const kx = key(x);\n    while (low <= high) {\n        const mid = (low + high) >>> 1;\n        const c = cmp(key(buf[mid]), kx);\n        if (c < 0) {\n            low = mid + 1;\n        }\n        else if (c > 0) {\n            high = mid - 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return -low - 1;\n};\n/**\n * Similar to {@link binarySearch}, but optimized for numeric arrays and\n * supporting custom comparators (default:\n * [`compareNumAsc()`](https://docs.thi.ng/umbrella/compare/functions/compareNumAsc.html)).\n *\n * @param buf - array\n * @param x - search value\n * @param cmp - comparator\n * @param low - min index\n * @param high - max index\n */\nexport const binarySearchNumeric = (buf, x, cmp = compareNumAsc, low = 0, high = buf.length - 1) => {\n    while (low <= high) {\n        const mid = (low + high) >>> 1;\n        const c = cmp(buf[mid], x);\n        if (c < 0) {\n            low = mid + 1;\n        }\n        else if (c > 0) {\n            high = mid - 1;\n        }\n        else {\n            return mid;\n        }\n    }\n    return -low - 1;\n};\nexport const binarySearch2 = (buf, x) => {\n    let idx = buf[1] <= x ? 1 : 0;\n    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;\n};\n/**\n * Non-recursive, optimized binary search for fixed size numeric arrays of 4\n * values. Returns index of `x` or `-index-1` if not found.\n *\n * @param buf -\n * @param x -\n */\nexport const binarySearch4 = (buf, x) => {\n    let idx = buf[2] <= x ? 2 : 0;\n    idx |= buf[idx + 1] <= x ? 1 : 0;\n    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;\n};\n/**\n * Non-recursive, optimized binary search for fixed size numeric arrays of 8\n * values. Returns index of `x` or `-index-1` if not found.\n *\n * @param buf -\n * @param x -\n */\nexport const binarySearch8 = (buf, x) => {\n    let idx = buf[4] <= x ? 4 : 0;\n    idx |= buf[idx + 2] <= x ? 2 : 0;\n    idx |= buf[idx + 1] <= x ? 1 : 0;\n    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;\n};\n/**\n * Non-recursive, optimized binary search for fixed size numeric arrays of 16\n * values. Returns index of `x` or `-index-1` if not found.\n *\n * @param buf -\n * @param x -\n */\nexport const binarySearch16 = (buf, x) => {\n    let idx = buf[8] <= x ? 8 : 0;\n    idx |= buf[idx + 4] <= x ? 4 : 0;\n    idx |= buf[idx + 2] <= x ? 2 : 0;\n    idx |= buf[idx + 1] <= x ? 1 : 0;\n    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;\n};\n/**\n * Non-recursive, optimized binary search for fixed size numeric arrays of 32\n * values. Returns index of `x` or `-index-1` if not found.\n *\n * @param buf -\n * @param x -\n */\nexport const binarySearch32 = (buf, x) => {\n    let idx = buf[16] <= x ? 16 : 0;\n    idx |= buf[idx + 4] <= x ? 8 : 0;\n    idx |= buf[idx + 4] <= x ? 4 : 0;\n    idx |= buf[idx + 2] <= x ? 2 : 0;\n    idx |= buf[idx + 1] <= x ? 1 : 0;\n    return buf[idx] === x ? idx : buf[0] < x ? -idx - 2 : -1;\n};\n/**\n * {@link binarySearch} result index classifier for predecessor queries.\n * Returns index of last item less than search value or -1 if no such\n * values exist.\n *\n * @example\n * ```ts\n * bsLT(binarySearch([10, 20, 30, 40], 25))\n * // 1\n * ```\n *\n * @param i - binarySearch result index\n */\nexport const bsLT = (i) => (i < 0 ? -i - 2 : i - 1);\n/**\n * Similar to {@link bsLT}, but for less-than-equals queries.\n *\n * @param i - binarySearch result index\n */\nexport const bsLE = (i) => (i < 0 ? -i - 2 : i);\n/**\n * {@link binarySearch} result index classifier for successor queries.\n * Returns index of first item greater than search value or -1 if no\n * such values exist.\n *\n * @example\n * ```ts\n * src = [10, 20, 30, 40];\n *\n * bsGT(binarySearch(src, 25), src.length)\n * // 2\n *\n * bsGT(binarySearch(src, 40), src.length)\n * // -1\n * ```\n *\n * @param i - binarySearch result index\n * @param n - array length\n */\nexport const bsGT = (i, n) => ((i = i < 0 ? -i - 1 : i + 1), i < n ? i : -1);\n/**\n * Similar to {@link bsGT}, but for greater-than-equals queries.\n *\n * @param i - binarySearch result index\n * @param n - array length\n */\nexport const bsGE = (i, n) => ((i = i < 0 ? -i - 1 : i), i < n ? i : -1);\n/**\n * {@link binarySearch} result index classifier for equals queries.\n * Merely syntax sugar, casting any non-found result indices to -1.\n *\n * @param i - binarySearch result index\n */\nexport const bsEQ = (i) => (i < 0 ? -1 : i);\n","import { fit } from \"@thi.ng/math/fit\";\nimport { ARamp } from \"./aramp.js\";\nexport const linear = (stops) => new LinearRamp(stops);\nexport class LinearRamp extends ARamp {\n    at(t) {\n        const stops = this.stops;\n        const n = stops.length - 1;\n        const i = this.timeIndex(t);\n        if (i < 0) {\n            return stops[0][1];\n        }\n        else if (i >= n) {\n            return stops[n][1];\n        }\n        else {\n            const a = stops[i];\n            const b = stops[i + 1];\n            return fit(t, a[0], b[0], a[1], b[1]);\n        }\n    }\n    interpolatedPoints() {\n        return this.stops;\n    }\n}\n"],"names":["faceCropCanvas","faceCropContext","glassesRemovalCanvas","glassesRemovalContext","previewCanvasCrop","previewContextCrop","previewCanvasOutput","previewContextOutput","currentModelSize","glassesDetectionCanvas","glassesDetectionContext","previewCanvasDetectionGlass","previewContextDetectionGlass","isDetectedGlasses","previousPose","stopDetectionCounter","actionCallback","CallbackHelper","onGlassesPresenceStart","onGlassesPresenceEnd","onDetectInitStart","onDetectInitEnd","onLoadSMModelStart","onLoadSMModelEnd","onLoadLGModelStart","onLoadLGModelEnd","pointsInUse","scaledPointList","pts","width","height","list","forEach","p","x","y","getEyeAreaPath","pose","min","value","max","pitch","yaw","roll","widthScalar","Math","abs","widthPadding","heightPadding","top","bottom","leftEye","rightEye","cropWidth","sqrt","pow","cropHeight","cropCenterX","cropCenterY","paddingX","cos","sin","paddingY","pitchRange","PI","yawRange","rollRange","velocityAngleThreshold","shouldDetect","screenSize","faceCoords","currentPose","undefined","pitchDiff","yawDiff","rollDiff","xDiff","yDiff","console","debug","toFixed","shouldRender","scrSize","smallModel","smallLoadingStatus","smallModelUrl","smallModelName","largeModel","largeLoadingStatus","largeModelUrl","largeModelName","modelUpdated","initialized","getCurrentModel","getCurrentResolution","GlassesRemovalRendererTFData","input","expanded","img","prediction","reduction","squeeze","GlassesRemovalRenderer","shouldLoad","initialize","currentFps","document","createElement","getContext","willReadFrequently","window","concat","setSmallModel","setLargeModel","setModelsUrl","modelsUrl","updateDebug","debugCanvasContainer","id","style","display","position","zIndex","transform","body","appendChild","removeChild","ready","_setSmallModel","Promise","resolve","reject","tf","then","model","e","_callee","_setLargeModel","log","_callee2","render","parameters","faceMeshResults","_parameters$faceMeshR","multiFaceLandmarks","_parameters$faceMeshR2","_context3","context","canvas","facePoints","vtoPoseArray","translate","rotate","drawImage","image","resetTransform","cropImageData","getImageData","toFloat","expandDims","predict","training","dispose","_callee3","getCurrentModelSize","disposeCanvases","clearRect","detectModel","loadingStatus","detectModelUrl","detectModelName","GlassesDetectorTFData","sumT","sum","GlassesDetector","graphModel","borderColor","finalize","detectGlasses","_context","data","glassesDetectionInterval","glassesRenderingDetectionInterval","glassesDetected","previousDetectionTimestamp","stopDetection","stopGlassesDetectionAfterMs","glassesRemovalState","callbackAction","message","details","state","modelSize","pluginId","forceGlassesRendererEnabled","GlassesRemovalPlugin","callbacks","version","glassesDevModelsUrl","hasFace","setTimeout","clearTimeout","Date","now","shouldDetectGlasses","detectionResult","fps","enabled","GlassesRemovalEffect","constructor","orderOfExecution","this","payload","applyFilter","options","result","module","exports","fn","ctx","params","Array","arguments","length","offset","index","pending","err","apply","base64","string","n","charAt","ceil","b64","s64","i","encode","buffer","start","end","t","parts","chunk","j","b","push","String","fromCharCode","slice","join","invalidEncoding","decode","c","charCodeAt","Error","test","EventEmitter","_listeners","prototype","on","evt","off","listeners","splice","emit","args","factory","Float32Array","f32","f8b","Uint8Array","le","writeFloat_f32_cpy","val","buf","pos","writeFloat_f32_rev","readFloat_f32_cpy","readFloat_f32_rev","writeFloatLE","writeFloatBE","readFloatLE","readFloatBE","writeFloat_ieee754","writeUint","sign","isNaN","round","exponent","floor","LN2","readFloat_ieee754","readUint","uint","mantissa","NaN","Infinity","bind","writeUintLE","writeUintBE","readUintLE","readUintBE","Float64Array","f64","writeDouble_f64_cpy","writeDouble_f64_rev","readDouble_f64_cpy","readDouble_f64_rev","writeDoubleLE","writeDoubleBE","readDoubleLE","readDoubleBE","writeDouble_ieee754","off0","off1","readDouble_ieee754","lo","hi","inquire","moduleName","mod","eval","replace","Object","keys","alloc","size","SIZE","MAX","slab","call","utf8","len","read","write","c1","c2","EPSILON","ARRAY_TYPE","random","hypot","create","out","glMatrix","fromMat4","a","transpose","a01","a02","a12","invert","a00","a03","a10","a11","a13","a20","a21","a22","a23","a30","a31","a32","a33","b00","b01","b02","b03","b04","b05","b06","b07","b08","b09","b10","b11","det","multiply","b0","b1","b2","b3","scale","v","z","rad","axis","s","b12","b20","b21","b22","rotateX","fromTranslation","fromScaling","fromRotation","getRotation","mat","scaling","m11","m12","m13","m21","m22","m23","m31","m32","m33","getScaling","is1","is2","is3","sm11","sm12","sm13","sm21","sm22","sm23","sm31","sm32","sm33","trace","S","perspective","fovy","aspect","near","far","nf","f","tan","perspectiveFromFieldOfView","fov","upTan","upDegrees","downTan","downDegrees","leftTan","leftDegrees","rightTan","rightDegrees","xScale","yScale","mul","getAxisAngle","out_axis","q","acos","slerp","omega","cosom","sinom","scale0","scale1","ax","ay","az","aw","bx","by","bz","bw","vec4","normalize","tmpvec3","vec3","xUnitVec3","yUnitVec3","temp1","temp2","matr","mat3","fromValues","set","add","distance","dot","cross","lerp","transformMat4","m","w","transformMat3","div","dist","vec","clone","copy","squaredLength","exactEquals","equals","a0","a1","a2","a3","_superPropBase","object","property","hasOwnProperty","getPrototypeOf","_get","Reflect","get","target","receiver","base","desc","getOwnPropertyDescriptor","norm","compare","compareNumAsc","absDiff","clamp","ARamp","stops","minT","maxT","eps","closestIndex","sort","key","cmp","low","high","kx","mid","binarySearch","linear","LinearRamp","timeIndex","d","fit"],"sourceRoot":""}