volview 4.0.0 → 4.0.1

package/dist/js/385.51ca48a2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"js/385.51ca48a2.js","mappings":"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","sources":["webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/DataArray/Constants.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/Math/index.js","webpack://VolView/./node_modules/gl-matrix/esm/common.js","webpack://VolView/./node_modules/gl-matrix/esm/mat4.js","webpack://VolView/./node_modules/gl-matrix/esm/vec3.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/Core/BinaryHelper.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/Core/DataAccessHelper.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/MatrixBuilder.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/CellArray.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/Points.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/Cell.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/CellLinks.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/CellTypes/Constants.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/CellTypes.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/Line/Constants.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/Line.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/PointSet.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/Triangle.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/PolyData.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/DataModel/PolyData/Constants.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/Endian.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/Core/DataAccessHelper/LiteHttpDataAccessHelper.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/Geometry/STLReader.js","webpack://VolView/./node_modules/fflate/esm/browser.js","webpack://VolView/./node_modules/@kitware/vtk.js/Common/Core/Base64.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/XML/XMLReader.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/XML/XMLImageDataReader.js","webpack://VolView/./node_modules/@kitware/vtk.js/IO/XML/XMLPolyDataReader.js","webpack://VolView/./src/io/io.ts","webpack://VolView/./src/io/index.ts","webpack://VolView/./src/io/vtk/common.ts","webpack://VolView/./src/io/vtk/async.reader.worker.ts","webpack://VolView/webpack/bootstrap","webpack://VolView/webpack/runtime/amd define","webpack://VolView/webpack/runtime/amd options","webpack://VolView/webpack/runtime/chunk loaded","webpack://VolView/webpack/runtime/compat get default export","webpack://VolView/webpack/runtime/define property getters","webpack://VolView/webpack/runtime/ensure chunk","webpack://VolView/webpack/runtime/get javascript chunk filename","webpack://VolView/webpack/runtime/get mini-css chunk filename","webpack://VolView/webpack/runtime/global","webpack://VolView/webpack/runtime/hasOwnProperty shorthand","webpack://VolView/webpack/runtime/make namespace object","webpack://VolView/webpack/runtime/node module decorator","webpack://VolView/webpack/runtime/publicPath","webpack://VolView/webpack/runtime/importScripts chunk loading","webpack://VolView/webpack/runtime/startup chunk dependencies","webpack://VolView/webpack/startup"],"sourcesContent":["var DataTypeByteSize = {\n  Int8Array: 1,\n  Uint8Array: 1,\n  Uint8ClampedArray: 1,\n  Int16Array: 2,\n  Uint16Array: 2,\n  Int32Array: 4,\n  Uint32Array: 4,\n  Float32Array: 4,\n  Float64Array: 8\n};\nvar VtkDataTypes = {\n  VOID: '',\n  // not sure to know what that should be\n  CHAR: 'Int8Array',\n  SIGNED_CHAR: 'Int8Array',\n  UNSIGNED_CHAR: 'Uint8Array',\n  SHORT: 'Int16Array',\n  UNSIGNED_SHORT: 'Uint16Array',\n  INT: 'Int32Array',\n  UNSIGNED_INT: 'Uint32Array',\n  FLOAT: 'Float32Array',\n  DOUBLE: 'Float64Array'\n};\nvar DefaultDataType = VtkDataTypes.FLOAT;\nvar Constants = {\n  DefaultDataType: DefaultDataType,\n  DataTypeByteSize: DataTypeByteSize,\n  VtkDataTypes: VtkDataTypes\n};\n\nexport { DataTypeByteSize, DefaultDataType, VtkDataTypes, Constants as default };\n","import _slicedToArray from '@babel/runtime/helpers/slicedToArray';\nimport _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';\nimport seedrandom from 'seedrandom';\nimport macro from '../../../macros.js';\nimport { IDENTITY, IDENTITY_3X3, VTK_SMALL_NUMBER, EPSILON } from './Constants.js';\n\nvar vtkErrorMacro = macro.vtkErrorMacro,\n    vtkWarningMacro = macro.vtkWarningMacro; // ----------------------------------------------------------------------------\n\n/* eslint-disable camelcase                                                  */\n\n/* eslint-disable no-cond-assign                                             */\n\n/* eslint-disable no-bitwise                                                 */\n\n/* eslint-disable no-multi-assign                                            */\n// ----------------------------------------------------------------------------\n\nvar randomSeedValue = 0;\nvar VTK_MAX_ROTATIONS = 20;\n\nfunction notImplemented(method) {\n  return function () {\n    return vtkErrorMacro(\"vtkMath::\".concat(method, \" - NOT IMPLEMENTED\"));\n  };\n} // Swap rows for n by n matrix\n\n\nfunction swapRowsMatrix_nxn(matrix, n, row1, row2) {\n  var tmp;\n\n  for (var i = 0; i < n; i++) {\n    tmp = matrix[row1 * n + i];\n    matrix[row1 * n + i] = matrix[row2 * n + i];\n    matrix[row2 * n + i] = tmp;\n  }\n} // Swap columns for n by n matrix\n\n\nfunction swapColumnsMatrix_nxn(matrix, n, column1, column2) {\n  var tmp;\n\n  for (var i = 0; i < n; i++) {\n    tmp = matrix[i * n + column1];\n    matrix[i * n + column1] = matrix[i * n + column2];\n    matrix[i * n + column2] = tmp;\n  }\n} // ----------------------------------------------------------------------------\n// Global methods\n// ----------------------------------------------------------------------------\n\n\nfunction createArray() {\n  var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 3;\n  // faster than Array.from and/or while loop\n  var res = Array(size);\n\n  for (var i = 0; i < size; ++i) {\n    res[i] = 0;\n  }\n\n  return res;\n}\nvar Pi = function Pi() {\n  return Math.PI;\n};\nfunction radiansFromDegrees(deg) {\n  return deg / 180 * Math.PI;\n}\nfunction degreesFromRadians(rad) {\n  return rad * 180 / Math.PI;\n}\nvar round = Math.round,\n    floor = Math.floor,\n    ceil = Math.ceil,\n    min = Math.min,\n    max = Math.max;\nfunction arrayMin(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  var minValue = Infinity;\n\n  for (var i = offset, len = arr.length; i < len; i += stride) {\n    if (arr[i] < minValue) {\n      minValue = arr[i];\n    }\n  }\n\n  return minValue;\n}\nfunction arrayMax(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  var maxValue = -Infinity;\n\n  for (var i = offset, len = arr.length; i < len; i += stride) {\n    if (maxValue < arr[i]) {\n      maxValue = arr[i];\n    }\n  }\n\n  return maxValue;\n}\nfunction arrayRange(arr) {\n  var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n  var stride = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n  var minValue = Infinity;\n  var maxValue = -Infinity;\n\n  for (var i = offset, len = arr.length; i < len; i += stride) {\n    if (arr[i] < minValue) {\n      minValue = arr[i];\n    }\n\n    if (maxValue < arr[i]) {\n      maxValue = arr[i];\n    }\n  }\n\n  return [minValue, maxValue];\n}\nvar ceilLog2 = notImplemented('ceilLog2');\nvar factorial = notImplemented('factorial');\nfunction nearestPowerOfTwo(xi) {\n  var v = 1;\n\n  while (v < xi) {\n    v *= 2;\n  }\n\n  return v;\n}\nfunction isPowerOfTwo(x) {\n  return x === nearestPowerOfTwo(x);\n}\nfunction binomial(m, n) {\n  var r = 1;\n\n  for (var i = 1; i <= n; ++i) {\n    r *= (m - i + 1) / i;\n  }\n\n  return Math.floor(r);\n}\nfunction beginCombination(m, n) {\n  if (m < n) {\n    return 0;\n  }\n\n  var r = createArray(n);\n\n  for (var i = 0; i < n; ++i) {\n    r[i] = i;\n  }\n\n  return r;\n}\nfunction nextCombination(m, n, r) {\n  var status = 0;\n\n  for (var i = n - 1; i >= 0; --i) {\n    if (r[i] < m - n + i) {\n      var j = r[i] + 1;\n\n      while (i < n) {\n        r[i++] = j++;\n      }\n\n      status = 1;\n      break;\n    }\n  }\n\n  return status;\n}\nfunction randomSeed(seed) {\n  seedrandom(\"\".concat(seed), {\n    global: true\n  });\n  randomSeedValue = seed;\n}\nfunction getSeed() {\n  return randomSeedValue;\n}\nfunction random() {\n  var minValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n  var maxValue = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;\n  var delta = maxValue - minValue;\n  return minValue + delta * Math.random();\n}\nvar gaussian = notImplemented('gaussian'); // Vect3 operations\n\nfunction add(a, b, out) {\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}\nfunction subtract(a, b, out) {\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}\nfunction multiplyScalar(vec, scalar) {\n  vec[0] *= scalar;\n  vec[1] *= scalar;\n  vec[2] *= scalar;\n  return vec;\n}\nfunction multiplyScalar2D(vec, scalar) {\n  vec[0] *= scalar;\n  vec[1] *= scalar;\n  return vec;\n}\nfunction multiplyAccumulate(a, b, scalar, out) {\n  out[0] = a[0] + b[0] * scalar;\n  out[1] = a[1] + b[1] * scalar;\n  out[2] = a[2] + b[2] * scalar;\n  return out;\n}\nfunction multiplyAccumulate2D(a, b, scalar, out) {\n  out[0] = a[0] + b[0] * scalar;\n  out[1] = a[1] + b[1] * scalar;\n  return out;\n}\nfunction dot(x, y) {\n  return x[0] * y[0] + x[1] * y[1] + x[2] * y[2];\n}\nfunction outer(x, y, out_3x3) {\n  out_3x3[0] = x[0] * y[0];\n  out_3x3[1] = x[0] * y[1];\n  out_3x3[2] = x[0] * y[2];\n  out_3x3[3] = x[1] * y[0];\n  out_3x3[4] = x[1] * y[1];\n  out_3x3[5] = x[1] * y[2];\n  out_3x3[6] = x[2] * y[0];\n  out_3x3[7] = x[2] * y[1];\n  out_3x3[8] = x[2] * y[2];\n}\nfunction cross(x, y, out) {\n  var Zx = x[1] * y[2] - x[2] * y[1];\n  var Zy = x[2] * y[0] - x[0] * y[2];\n  var Zz = x[0] * y[1] - x[1] * y[0];\n  out[0] = Zx;\n  out[1] = Zy;\n  out[2] = Zz;\n  return out;\n}\nfunction norm(x) {\n  var n = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;\n\n  switch (n) {\n    case 1:\n      return Math.abs(x);\n\n    case 2:\n      return Math.sqrt(x[0] * x[0] + x[1] * x[1]);\n\n    case 3:\n      return Math.sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]);\n\n    default:\n      {\n        var sum = 0;\n\n        for (var i = 0; i < n; i++) {\n          sum += x[i] * x[i];\n        }\n\n        return Math.sqrt(sum);\n      }\n  }\n}\nfunction normalize(x) {\n  var den = norm(x);\n\n  if (den !== 0.0) {\n    x[0] /= den;\n    x[1] /= den;\n    x[2] /= den;\n  }\n\n  return den;\n}\nfunction perpendiculars(x, y, z, theta) {\n  var x2 = x[0] * x[0];\n  var y2 = x[1] * x[1];\n  var z2 = x[2] * x[2];\n  var r = Math.sqrt(x2 + y2 + z2);\n  var dx;\n  var dy;\n  var dz; // transpose the vector to avoid divide-by-zero error\n\n  if (x2 > y2 && x2 > z2) {\n    dx = 0;\n    dy = 1;\n    dz = 2;\n  } else if (y2 > z2) {\n    dx = 1;\n    dy = 2;\n    dz = 0;\n  } else {\n    dx = 2;\n    dy = 0;\n    dz = 1;\n  }\n\n  var a = x[dx] / r;\n  var b = x[dy] / r;\n  var c = x[dz] / r;\n  var tmp = Math.sqrt(a * a + c * c);\n\n  if (theta !== 0) {\n    var sintheta = Math.sin(theta);\n    var costheta = Math.cos(theta);\n\n    if (y) {\n      y[dx] = (c * costheta - a * b * sintheta) / tmp;\n      y[dy] = sintheta * tmp;\n      y[dz] = (-(a * costheta) - b * c * sintheta) / tmp;\n    }\n\n    if (z) {\n      z[dx] = (-(c * sintheta) - a * b * costheta) / tmp;\n      z[dy] = costheta * tmp;\n      z[dz] = (a * sintheta - b * c * costheta) / tmp;\n    }\n  } else {\n    if (y) {\n      y[dx] = c / tmp;\n      y[dy] = 0;\n      y[dz] = -a / tmp;\n    }\n\n    if (z) {\n      z[dx] = -a * b / tmp;\n      z[dy] = tmp;\n      z[dz] = -b * c / tmp;\n    }\n  }\n}\nfunction projectVector(a, b, projection) {\n  var bSquared = dot(b, b);\n\n  if (bSquared === 0) {\n    projection[0] = 0;\n    projection[1] = 0;\n    projection[2] = 0;\n    return false;\n  }\n\n  var scale = dot(a, b) / bSquared;\n\n  for (var i = 0; i < 3; i++) {\n    projection[i] = b[i];\n  }\n\n  multiplyScalar(projection, scale);\n  return true;\n}\nfunction dot2D(x, y) {\n  return x[0] * y[0] + x[1] * y[1];\n}\nfunction projectVector2D(a, b, projection) {\n  var bSquared = dot2D(b, b);\n\n  if (bSquared === 0) {\n    projection[0] = 0;\n    projection[1] = 0;\n    return false;\n  }\n\n  var scale = dot2D(a, b) / bSquared;\n\n  for (var i = 0; i < 2; i++) {\n    projection[i] = b[i];\n  }\n\n  multiplyScalar2D(projection, scale);\n  return true;\n}\nfunction distance2BetweenPoints(x, y) {\n  return (x[0] - y[0]) * (x[0] - y[0]) + (x[1] - y[1]) * (x[1] - y[1]) + (x[2] - y[2]) * (x[2] - y[2]);\n}\nfunction angleBetweenVectors(v1, v2) {\n  var crossVect = [0, 0, 0];\n  cross(v1, v2, crossVect);\n  return Math.atan2(norm(crossVect), dot(v1, v2));\n}\nfunction signedAngleBetweenVectors(v1, v2, vN) {\n  var crossVect = [0, 0, 0];\n  cross(v1, v2, crossVect);\n  var angle = Math.atan2(norm(crossVect), dot(v1, v2));\n  return dot(crossVect, vN) >= 0 ? angle : -angle;\n}\nfunction gaussianAmplitude(mean, variance, position) {\n  var distanceFromMean = Math.abs(mean - position);\n  return 1 / Math.sqrt(2 * Math.PI * variance) * Math.exp(-Math.pow(distanceFromMean, 2) / (2 * variance));\n}\nfunction gaussianWeight(mean, variance, position) {\n  var distanceFromMean = Math.abs(mean - position);\n  return Math.exp(-Math.pow(distanceFromMean, 2) / (2 * variance));\n}\nfunction outer2D(x, y, out_2x2) {\n  out_2x2[0] = x[0] * y[0];\n  out_2x2[1] = x[0] * y[1];\n  out_2x2[2] = x[1] * y[0];\n  out_2x2[3] = x[1] * y[1];\n}\nfunction norm2D(x2D) {\n  return Math.sqrt(x2D[0] * x2D[0] + x2D[1] * x2D[1]);\n}\nfunction normalize2D(x) {\n  var den = norm2D(x);\n\n  if (den !== 0.0) {\n    x[0] /= den;\n    x[1] /= den;\n  }\n\n  return den;\n}\nfunction rowsToMat4(row0, row1, row2, row3, mat) {\n  for (var i = 0; i < 4; i++) {\n    mat[i] = row0[i];\n    mat[4 + i] = row1[i];\n    mat[8 + i] = row2[i];\n    mat[12 + i] = row3[i];\n  }\n\n  return mat;\n}\nfunction columnsToMat4(column0, column1, column2, column3, mat) {\n  for (var i = 0; i < 4; i++) {\n    mat[4 * i] = column0[i];\n    mat[4 * i + 1] = column1[i];\n    mat[4 * i + 2] = column2[i];\n    mat[4 * i + 3] = column3[i];\n  }\n\n  return mat;\n}\nfunction rowsToMat3(row0, row1, row2, mat) {\n  for (var i = 0; i < 3; i++) {\n    mat[i] = row0[i];\n    mat[3 + i] = row1[i];\n    mat[6 + i] = row2[i];\n  }\n\n  return mat;\n}\nfunction columnsToMat3(column0, column1, column2, mat) {\n  for (var i = 0; i < 3; i++) {\n    mat[3 * i] = column0[i];\n    mat[3 * i + 1] = column1[i];\n    mat[3 * i + 2] = column2[i];\n  }\n\n  return mat;\n}\nfunction determinant2x2() {\n  for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {\n    args[_key] = arguments[_key];\n  }\n\n  if (args.length === 2) {\n    return args[0][0] * args[1][1] - args[1][0] * args[0][1];\n  }\n\n  if (args.length === 4) {\n    return args[0] * args[3] - args[1] * args[2];\n  }\n\n  return Number.NaN;\n}\nfunction LUFactor3x3(mat_3x3, index_3) {\n  var maxI;\n  var tmp;\n  var largest;\n  var scale = [0, 0, 0]; // Loop over rows to get implicit scaling information\n\n  for (var i = 0; i < 3; i++) {\n    largest = Math.abs(mat_3x3[i * 3]);\n\n    if ((tmp = Math.abs(mat_3x3[i * 3 + 1])) > largest) {\n      largest = tmp;\n    }\n\n    if ((tmp = Math.abs(mat_3x3[i * 3 + 2])) > largest) {\n      largest = tmp;\n    }\n\n    scale[i] = 1 / largest;\n  } // Loop over all columns using Crout's method\n  // first column\n\n\n  largest = scale[0] * Math.abs(mat_3x3[0]);\n  maxI = 0;\n\n  if ((tmp = scale[1] * Math.abs(mat_3x3[3])) >= largest) {\n    largest = tmp;\n    maxI = 1;\n  }\n\n  if ((tmp = scale[2] * Math.abs(mat_3x3[6])) >= largest) {\n    maxI = 2;\n  }\n\n  if (maxI !== 0) {\n    swapRowsMatrix_nxn(mat_3x3, 3, maxI, 0);\n    scale[maxI] = scale[0];\n  }\n\n  index_3[0] = maxI;\n  mat_3x3[3] /= mat_3x3[0];\n  mat_3x3[6] /= mat_3x3[0]; // second column\n\n  mat_3x3[4] -= mat_3x3[3] * mat_3x3[1];\n  mat_3x3[7] -= mat_3x3[6] * mat_3x3[1];\n  largest = scale[1] * Math.abs(mat_3x3[4]);\n  maxI = 1;\n\n  if ((tmp = scale[2] * Math.abs(mat_3x3[7])) >= largest) {\n    maxI = 2;\n    swapRowsMatrix_nxn(mat_3x3, 3, 1, 2);\n    scale[2] = scale[1];\n  }\n\n  index_3[1] = maxI;\n  mat_3x3[7] /= mat_3x3[4]; // third column\n\n  mat_3x3[5] -= mat_3x3[3] * mat_3x3[2];\n  mat_3x3[8] -= mat_3x3[6] * mat_3x3[2] + mat_3x3[7] * mat_3x3[5];\n  index_3[2] = 2;\n}\nfunction LUSolve3x3(mat_3x3, index_3, x_3) {\n  // forward substitution\n  var sum = x_3[index_3[0]];\n  x_3[index_3[0]] = x_3[0];\n  x_3[0] = sum;\n  sum = x_3[index_3[1]];\n  x_3[index_3[1]] = x_3[1];\n  x_3[1] = sum - mat_3x3[3] * x_3[0];\n  sum = x_3[index_3[2]];\n  x_3[index_3[2]] = x_3[2];\n  x_3[2] = sum - mat_3x3[6] * x_3[0] - mat_3x3[7] * x_3[1]; // back substitution\n\n  x_3[2] /= mat_3x3[8];\n  x_3[1] = (x_3[1] - mat_3x3[5] * x_3[2]) / mat_3x3[4];\n  x_3[0] = (x_3[0] - mat_3x3[1] * x_3[1] - mat_3x3[2] * x_3[2]) / mat_3x3[0];\n}\nfunction linearSolve3x3(mat_3x3, x_3, y_3) {\n  var a1 = mat_3x3[0];\n  var b1 = mat_3x3[1];\n  var c1 = mat_3x3[2];\n  var a2 = mat_3x3[3];\n  var b2 = mat_3x3[4];\n  var c2 = mat_3x3[5];\n  var a3 = mat_3x3[6];\n  var b3 = mat_3x3[7];\n  var c3 = mat_3x3[8]; // Compute the adjoint\n\n  var d1 = +determinant2x2(b2, b3, c2, c3);\n  var d2 = -determinant2x2(a2, a3, c2, c3);\n  var d3 = +determinant2x2(a2, a3, b2, b3);\n  var e1 = -determinant2x2(b1, b3, c1, c3);\n  var e2 = +determinant2x2(a1, a3, c1, c3);\n  var e3 = -determinant2x2(a1, a3, b1, b3);\n  var f1 = +determinant2x2(b1, b2, c1, c2);\n  var f2 = -determinant2x2(a1, a2, c1, c2);\n  var f3 = +determinant2x2(a1, a2, b1, b2); // Compute the determinant\n\n  var det = a1 * d1 + b1 * d2 + c1 * d3; // Multiply by the adjoint\n\n  var v1 = d1 * x_3[0] + e1 * x_3[1] + f1 * x_3[2];\n  var v2 = d2 * x_3[0] + e2 * x_3[1] + f2 * x_3[2];\n  var v3 = d3 * x_3[0] + e3 * x_3[1] + f3 * x_3[2]; // Divide by the determinant\n\n  y_3[0] = v1 / det;\n  y_3[1] = v2 / det;\n  y_3[2] = v3 / det;\n}\nfunction multiply3x3_vect3(mat_3x3, in_3, out_3) {\n  var x = mat_3x3[0] * in_3[0] + mat_3x3[1] * in_3[1] + mat_3x3[2] * in_3[2];\n  var y = mat_3x3[3] * in_3[0] + mat_3x3[4] * in_3[1] + mat_3x3[5] * in_3[2];\n  var z = mat_3x3[6] * in_3[0] + mat_3x3[7] * in_3[1] + mat_3x3[8] * in_3[2];\n  out_3[0] = x;\n  out_3[1] = y;\n  out_3[2] = z;\n}\nfunction multiply3x3_mat3(a_3x3, b_3x3, out_3x3) {\n  var copyA = _toConsumableArray(a_3x3);\n\n  var copyB = _toConsumableArray(b_3x3);\n\n  for (var i = 0; i < 3; i++) {\n    out_3x3[i] = copyA[0] * copyB[i] + copyA[1] * copyB[i + 3] + copyA[2] * copyB[i + 6];\n    out_3x3[i + 3] = copyA[3] * copyB[i] + copyA[4] * copyB[i + 3] + copyA[5] * copyB[i + 6];\n    out_3x3[i + 6] = copyA[6] * copyB[i] + copyA[7] * copyB[i + 3] + copyA[8] * copyB[i + 6];\n  }\n}\nfunction multiplyMatrix(a, b, rowA, colA, rowB, colB, out_rowXcol) {\n  // we need colA == rowB\n  if (colA !== rowB) {\n    vtkErrorMacro('Number of columns of A must match number of rows of B.');\n  } // If a or b is used to store the result, copying them is required\n\n\n  var copyA = _toConsumableArray(a);\n\n  var copyB = _toConsumableArray(b); // output matrix is rowA*colB\n  // output row\n\n\n  for (var i = 0; i < rowA; i++) {\n    // output col\n    for (var j = 0; j < colB; j++) {\n      out_rowXcol[i * colB + j] = 0; // sum for this point\n\n      for (var k = 0; k < colA; k++) {\n        out_rowXcol[i * colB + j] += copyA[i * colA + k] * copyB[j + colB * k];\n      }\n    }\n  }\n}\nfunction transpose3x3(in_3x3, outT_3x3) {\n  var tmp; // off-diagonal elements\n\n  tmp = in_3x3[3];\n  outT_3x3[3] = in_3x3[1];\n  outT_3x3[1] = tmp;\n  tmp = in_3x3[6];\n  outT_3x3[6] = in_3x3[2];\n  outT_3x3[2] = tmp;\n  tmp = in_3x3[7];\n  outT_3x3[7] = in_3x3[5];\n  outT_3x3[5] = tmp; // on-diagonal elements\n\n  outT_3x3[0] = in_3x3[0];\n  outT_3x3[4] = in_3x3[4];\n  outT_3x3[8] = in_3x3[8];\n}\nfunction invert3x3(in_3x3, outI_3x3) {\n  var a1 = in_3x3[0];\n  var b1 = in_3x3[1];\n  var c1 = in_3x3[2];\n  var a2 = in_3x3[3];\n  var b2 = in_3x3[4];\n  var c2 = in_3x3[5];\n  var a3 = in_3x3[6];\n  var b3 = in_3x3[7];\n  var c3 = in_3x3[8]; // Compute the adjoint\n\n  var d1 = +determinant2x2(b2, b3, c2, c3);\n  var d2 = -determinant2x2(a2, a3, c2, c3);\n  var d3 = +determinant2x2(a2, a3, b2, b3);\n  var e1 = -determinant2x2(b1, b3, c1, c3);\n  var e2 = +determinant2x2(a1, a3, c1, c3);\n  var e3 = -determinant2x2(a1, a3, b1, b3);\n  var f1 = +determinant2x2(b1, b2, c1, c2);\n  var f2 = -determinant2x2(a1, a2, c1, c2);\n  var f3 = +determinant2x2(a1, a2, b1, b2); // Divide by the determinant\n\n  var det = a1 * d1 + b1 * d2 + c1 * d3;\n\n  if (det === 0) {\n    vtkWarningMacro('Matrix has 0 determinant');\n  }\n\n  outI_3x3[0] = d1 / det;\n  outI_3x3[3] = d2 / det;\n  outI_3x3[6] = d3 / det;\n  outI_3x3[1] = e1 / det;\n  outI_3x3[4] = e2 / det;\n  outI_3x3[7] = e3 / det;\n  outI_3x3[2] = f1 / det;\n  outI_3x3[5] = f2 / det;\n  outI_3x3[8] = f3 / det;\n}\nfunction determinant3x3(mat_3x3) {\n  return mat_3x3[0] * mat_3x3[4] * mat_3x3[8] + mat_3x3[3] * mat_3x3[7] * mat_3x3[2] + mat_3x3[6] * mat_3x3[1] * mat_3x3[5] - mat_3x3[0] * mat_3x3[7] * mat_3x3[5] - mat_3x3[3] * mat_3x3[1] * mat_3x3[8] - mat_3x3[6] * mat_3x3[4] * mat_3x3[2];\n}\n/**\n * Returns true if elements of both arrays are equals.\n * @param {Array} a an array of numbers (vector, point, matrix...)\n * @param {Array} b an array of numbers (vector, point, matrix...)\n * @param {Number} eps tolerance\n */\n\nfunction areEquals(a, b) {\n  var eps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EPSILON;\n\n  if (a.length !== b.length) {\n    return false;\n  }\n\n  function isEqual(element, index) {\n    return Math.abs(element - b[index]) <= eps;\n  }\n\n  return a.every(isEqual);\n}\nvar areMatricesEqual = areEquals;\nfunction identity3x3(mat_3x3) {\n  for (var i = 0; i < 3; i++) {\n    /* eslint-disable-next-line no-multi-assign */\n    mat_3x3[i * 3] = mat_3x3[i * 3 + 1] = mat_3x3[i * 3 + 2] = 0;\n    mat_3x3[i * 3 + i] = 1;\n  }\n}\nfunction identity(n, mat) {\n  for (var i = 0; i < n; i++) {\n    for (var j = 0; j < n; j++) {\n      mat[i * n + j] = 0;\n    }\n\n    mat[i * n + i] = 1;\n  }\n\n  return mat;\n}\nfunction isIdentity(mat) {\n  var eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;\n  return areMatricesEqual(mat, IDENTITY, eps);\n}\nfunction isIdentity3x3(mat) {\n  var eps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : EPSILON;\n  return areMatricesEqual(mat, IDENTITY_3X3, eps);\n}\nfunction quaternionToMatrix3x3(quat_4, mat_3x3) {\n  var ww = quat_4[0] * quat_4[0];\n  var wx = quat_4[0] * quat_4[1];\n  var wy = quat_4[0] * quat_4[2];\n  var wz = quat_4[0] * quat_4[3];\n  var xx = quat_4[1] * quat_4[1];\n  var yy = quat_4[2] * quat_4[2];\n  var zz = quat_4[3] * quat_4[3];\n  var xy = quat_4[1] * quat_4[2];\n  var xz = quat_4[1] * quat_4[3];\n  var yz = quat_4[2] * quat_4[3];\n  var rr = xx + yy + zz; // normalization factor, just in case quaternion was not normalized\n\n  var f = 1 / (ww + rr);\n  var s = (ww - rr) * f;\n  f *= 2;\n  mat_3x3[0] = xx * f + s;\n  mat_3x3[3] = (xy + wz) * f;\n  mat_3x3[6] = (xz - wy) * f;\n  mat_3x3[1] = (xy - wz) * f;\n  mat_3x3[4] = yy * f + s;\n  mat_3x3[7] = (yz + wx) * f;\n  mat_3x3[2] = (xz + wy) * f;\n  mat_3x3[5] = (yz - wx) * f;\n  mat_3x3[8] = zz * f + s;\n}\nfunction roundNumber(num) {\n  var digits = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n  if (!\"\".concat(num).includes('e')) {\n    return +\"\".concat(Math.round(\"\".concat(num, \"e+\").concat(digits)), \"e-\").concat(digits);\n  }\n\n  var arr = \"\".concat(num).split('e');\n  var sig = '';\n\n  if (+arr[1] + digits > 0) {\n    sig = '+';\n  }\n\n  return +\"\".concat(Math.round(\"\".concat(+arr[0], \"e\").concat(sig).concat(+arr[1] + digits)), \"e-\").concat(digits);\n}\nfunction roundVector(vector) {\n  var out = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0, 0];\n  var digits = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;\n  out[0] = roundNumber(vector[0], digits);\n  out[1] = roundNumber(vector[1], digits);\n  out[2] = roundNumber(vector[2], digits);\n  return out;\n}\nfunction jacobiN(a, n, w, v) {\n  var i;\n  var j;\n  var k;\n  var iq;\n  var ip;\n  var numPos;\n  var tresh;\n  var theta;\n  var t;\n  var tau;\n  var sm;\n  var s;\n  var h;\n  var g;\n  var c;\n  var tmp;\n  var b = createArray(n);\n  var z = createArray(n);\n\n  var vtkROTATE = function vtkROTATE(aa, ii, jj) {\n    g = aa[ii];\n    h = aa[jj];\n    aa[ii] = g - s * (h + g * tau);\n    aa[jj] = h + s * (g - h * tau);\n  }; // initialize\n\n\n  identity(n, v);\n\n  for (ip = 0; ip < n; ip++) {\n    b[ip] = w[ip] = a[ip + ip * n];\n    z[ip] = 0.0;\n  } // begin rotation sequence\n\n\n  for (i = 0; i < VTK_MAX_ROTATIONS; i++) {\n    sm = 0.0;\n\n    for (ip = 0; ip < n - 1; ip++) {\n      for (iq = ip + 1; iq < n; iq++) {\n        sm += Math.abs(a[ip * n + iq]);\n      }\n    }\n\n    if (sm === 0.0) {\n      break;\n    } // first 3 sweeps\n\n\n    if (i < 3) {\n      tresh = 0.2 * sm / (n * n);\n    } else {\n      tresh = 0.0;\n    }\n\n    for (ip = 0; ip < n - 1; ip++) {\n      for (iq = ip + 1; iq < n; iq++) {\n        g = 100.0 * Math.abs(a[ip * n + iq]); // after 4 sweeps\n\n        if (i > 3 && Math.abs(w[ip]) + g === Math.abs(w[ip]) && Math.abs(w[iq]) + g === Math.abs(w[iq])) {\n          a[ip * n + iq] = 0.0;\n        } else if (Math.abs(a[ip * n + iq]) > tresh) {\n          h = w[iq] - w[ip];\n\n          if (Math.abs(h) + g === Math.abs(h)) {\n            t = a[ip * n + iq] / h;\n          } else {\n            theta = 0.5 * h / a[ip * n + iq];\n            t = 1.0 / (Math.abs(theta) + Math.sqrt(1.0 + theta * theta));\n\n            if (theta < 0.0) {\n              t = -t;\n            }\n          }\n\n          c = 1.0 / Math.sqrt(1 + t * t);\n          s = t * c;\n          tau = s / (1.0 + c);\n          h = t * a[ip * n + iq];\n          z[ip] -= h;\n          z[iq] += h;\n          w[ip] -= h;\n          w[iq] += h;\n          a[ip * n + iq] = 0.0; // ip already shifted left by 1 unit\n\n          for (j = 0; j <= ip - 1; j++) {\n            vtkROTATE(a, j * n + ip, j * n + iq);\n          } // ip and iq already shifted left by 1 unit\n\n\n          for (j = ip + 1; j <= iq - 1; j++) {\n            vtkROTATE(a, ip * n + j, j * n + iq);\n          } // iq already shifted left by 1 unit\n\n\n          for (j = iq + 1; j < n; j++) {\n            vtkROTATE(a, ip * n + j, iq * n + j);\n          }\n\n          for (j = 0; j < n; j++) {\n            vtkROTATE(v, j * n + ip, j * n + iq);\n          }\n        }\n      }\n    }\n\n    for (ip = 0; ip < n; ip++) {\n      b[ip] += z[ip];\n      w[ip] = b[ip];\n      z[ip] = 0.0;\n    }\n  } // this is NEVER called\n\n\n  if (i >= VTK_MAX_ROTATIONS) {\n    vtkWarningMacro('vtkMath::Jacobi: Error extracting eigenfunctions');\n    return 0;\n  } // sort eigenfunctions: these changes do not affect accuracy\n\n\n  for (j = 0; j < n - 1; j++) {\n    // boundary incorrect\n    k = j;\n    tmp = w[k];\n\n    for (i = j + 1; i < n; i++) {\n      // boundary incorrect, shifted already\n      if (w[i] >= tmp || Math.abs(w[i] - tmp) < VTK_SMALL_NUMBER) {\n        // why exchange if same?\n        k = i;\n        tmp = w[k];\n      }\n    }\n\n    if (k !== j) {\n      w[k] = w[j];\n      w[j] = tmp;\n      swapColumnsMatrix_nxn(v, n, j, k);\n    }\n  } // ensure eigenvector consistency (i.e., Jacobi can compute vectors that\n  // are negative of one another (.707,.707,0) and (-.707,-.707,0). This can\n  // reek havoc in hyperstreamline/other stuff. We will select the most\n  // positive eigenvector.\n\n\n  var ceil_half_n = (n >> 1) + (n & 1);\n\n  for (numPos = 0, i = 0; i < n * n; i++) {\n    if (v[i] >= 0.0) {\n      numPos++;\n    }\n  } //    if ( numPos < ceil(double(n)/double(2.0)) )\n\n\n  if (numPos < ceil_half_n) {\n    for (i = 0; i < n; i++) {\n      v[i * n + j] *= -1.0;\n    }\n  }\n\n  return 1;\n}\nfunction matrix3x3ToQuaternion(mat_3x3, quat_4) {\n  var tmp = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; // on-diagonal elements\n\n  tmp[0] = mat_3x3[0] + mat_3x3[4] + mat_3x3[8];\n  tmp[5] = mat_3x3[0] - mat_3x3[4] - mat_3x3[8];\n  tmp[10] = -mat_3x3[0] + mat_3x3[4] - mat_3x3[8];\n  tmp[15] = -mat_3x3[0] - mat_3x3[4] + mat_3x3[8]; // off-diagonal elements\n\n  tmp[1] = tmp[4] = mat_3x3[7] - mat_3x3[5];\n  tmp[2] = tmp[8] = mat_3x3[2] - mat_3x3[6];\n  tmp[3] = tmp[12] = mat_3x3[3] - mat_3x3[1];\n  tmp[6] = tmp[9] = mat_3x3[3] + mat_3x3[1];\n  tmp[7] = tmp[13] = mat_3x3[2] + mat_3x3[6];\n  tmp[11] = tmp[14] = mat_3x3[7] + mat_3x3[5];\n  var eigenvectors = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];\n  var eigenvalues = [0, 0, 0, 0]; // convert into format that JacobiN can use,\n  // then use Jacobi to find eigenvalues and eigenvectors\n  // tmp is copied because jacobiN may modify it\n\n  var NTemp = [].concat(tmp);\n  jacobiN(NTemp, 4, eigenvalues, eigenvectors); // the first eigenvector is the one we want\n\n  quat_4[0] = eigenvectors[0];\n  quat_4[1] = eigenvectors[4];\n  quat_4[2] = eigenvectors[8];\n  quat_4[3] = eigenvectors[12];\n}\nfunction multiplyQuaternion(quat_1, quat_2, quat_out) {\n  var ww = quat_1[0] * quat_2[0];\n  var wx = quat_1[0] * quat_2[1];\n  var wy = quat_1[0] * quat_2[2];\n  var wz = quat_1[0] * quat_2[3];\n  var xw = quat_1[1] * quat_2[0];\n  var xx = quat_1[1] * quat_2[1];\n  var xy = quat_1[1] * quat_2[2];\n  var xz = quat_1[1] * quat_2[3];\n  var yw = quat_1[2] * quat_2[0];\n  var yx = quat_1[2] * quat_2[1];\n  var yy = quat_1[2] * quat_2[2];\n  var yz = quat_1[2] * quat_2[3];\n  var zw = quat_1[3] * quat_2[0];\n  var zx = quat_1[3] * quat_2[1];\n  var zy = quat_1[3] * quat_2[2];\n  var zz = quat_1[3] * quat_2[3];\n  quat_out[0] = ww - xx - yy - zz;\n  quat_out[1] = wx + xw + yz - zy;\n  quat_out[2] = wy - xz + yw + zx;\n  quat_out[3] = wz + xy - yx + zw;\n}\nfunction orthogonalize3x3(a_3x3, out_3x3) {\n  // copy the matrix\n  for (var i = 0; i < 9; i++) {\n    out_3x3[i] = a_3x3[i];\n  } // Pivot the matrix to improve accuracy\n\n\n  var scale = createArray(3);\n  var index = createArray(3);\n  var largest; // Loop over rows to get implicit scaling information\n\n  for (var _i = 0; _i < 3; _i++) {\n    var _x = Math.abs(out_3x3[_i * 3]);\n\n    var _x2 = Math.abs(out_3x3[_i * 3 + 1]);\n\n    var _x3 = Math.abs(out_3x3[_i * 3 + 2]);\n\n    largest = _x2 > _x ? _x2 : _x;\n    largest = _x3 > largest ? _x3 : largest;\n    scale[_i] = 1;\n\n    if (largest !== 0) {\n      scale[_i] /= largest;\n    }\n  } // first column\n\n\n  var x1 = Math.abs(out_3x3[0]) * scale[0];\n  var x2 = Math.abs(out_3x3[3]) * scale[1];\n  var x3 = Math.abs(out_3x3[6]) * scale[2];\n  index[0] = 0;\n  largest = x1;\n\n  if (x2 >= largest) {\n    largest = x2;\n    index[0] = 1;\n  }\n\n  if (x3 >= largest) {\n    index[0] = 2;\n  }\n\n  if (index[0] !== 0) {\n    // swap vectors\n    swapColumnsMatrix_nxn(out_3x3, 3, index[0], 0);\n    scale[index[0]] = scale[0];\n  } // second column\n\n\n  var y2 = Math.abs(out_3x3[4]) * scale[1];\n  var y3 = Math.abs(out_3x3[7]) * scale[2];\n  index[1] = 1;\n  largest = y2;\n\n  if (y3 >= largest) {\n    index[1] = 2; // swap vectors\n\n    swapColumnsMatrix_nxn(out_3x3, 3, 1, 2);\n  } // third column\n\n\n  index[2] = 2; // A quaternion can only describe a pure rotation, not\n  // a rotation with a flip, therefore the flip must be\n  // removed before the matrix is converted to a quaternion.\n\n  var flip = 0;\n\n  if (determinant3x3(out_3x3) < 0) {\n    flip = 1;\n\n    for (var _i2 = 0; _i2 < 9; _i2++) {\n      out_3x3[_i2] = -out_3x3[_i2];\n    }\n  } // Do orthogonalization using a quaternion intermediate\n  // (this, essentially, does the orthogonalization via\n  // diagonalization of an appropriately constructed symmetric\n  // 4x4 matrix rather than by doing SVD of the 3x3 matrix)\n\n\n  var quat = createArray(4);\n  matrix3x3ToQuaternion(out_3x3, quat);\n  quaternionToMatrix3x3(quat, out_3x3); // Put the flip back into the orthogonalized matrix.\n\n  if (flip) {\n    for (var _i3 = 0; _i3 < 9; _i3++) {\n      out_3x3[_i3] = -out_3x3[_i3];\n    }\n  } // Undo the pivoting\n\n\n  if (index[1] !== 1) {\n    swapColumnsMatrix_nxn(out_3x3, 3, index[1], 1);\n  }\n\n  if (index[0] !== 0) {\n    swapColumnsMatrix_nxn(out_3x3, 3, index[0], 0);\n  }\n}\nfunction diagonalize3x3(a_3x3, w_3, v_3x3) {\n  var i;\n  var j;\n  var k;\n  var maxI;\n  var tmp;\n  var maxVal; // a is copied because jacobiN may modify it\n\n  var copyA = _toConsumableArray(a_3x3); // diagonalize using Jacobi\n\n\n  jacobiN(copyA, 3, w_3, v_3x3); // if all the eigenvalues are the same, return identity matrix\n\n  if (w_3[0] === w_3[1] && w_3[0] === w_3[2]) {\n    identity3x3(v_3x3);\n    return;\n  } // transpose temporarily, it makes it easier to sort the eigenvectors\n\n\n  transpose3x3(v_3x3, v_3x3); // if two eigenvalues are the same, re-orthogonalize to optimally line\n  // up the eigenvectors with the x, y, and z axes\n\n  for (i = 0; i < 3; i++) {\n    // two eigenvalues are the same\n    if (w_3[(i + 1) % 3] === w_3[(i + 2) % 3]) {\n      // find maximum element of the independent eigenvector\n      maxVal = Math.abs(v_3x3[i * 3]);\n      maxI = 0;\n\n      for (j = 1; j < 3; j++) {\n        if (maxVal < (tmp = Math.abs(v_3x3[i * 3 + j]))) {\n          maxVal = tmp;\n          maxI = j;\n        }\n      } // swap the eigenvector into its proper position\n\n\n      if (maxI !== i) {\n        tmp = w_3[maxI];\n        w_3[maxI] = w_3[i];\n        w_3[i] = tmp;\n        swapRowsMatrix_nxn(v_3x3, 3, i, maxI);\n      } // maximum element of eigenvector should be positive\n\n\n      if (v_3x3[maxI * 3 + maxI] < 0) {\n        v_3x3[maxI * 3] = -v_3x3[maxI * 3];\n        v_3x3[maxI * 3 + 1] = -v_3x3[maxI * 3 + 1];\n        v_3x3[maxI * 3 + 2] = -v_3x3[maxI * 3 + 2];\n      } // re-orthogonalize the other two eigenvectors\n\n\n      j = (maxI + 1) % 3;\n      k = (maxI + 2) % 3;\n      v_3x3[j * 3] = 0.0;\n      v_3x3[j * 3 + 1] = 0.0;\n      v_3x3[j * 3 + 2] = 0.0;\n      v_3x3[j * 3 + j] = 1.0;\n      var vectTmp1 = cross([v_3x3[maxI * 3], v_3x3[maxI * 3 + 1], v_3x3[maxI * 3 + 2]], [v_3x3[j * 3], v_3x3[j * 3 + 1], v_3x3[j * 3 + 2]], []);\n      normalize(vectTmp1);\n      var vectTmp2 = cross(vectTmp1, [v_3x3[maxI * 3], v_3x3[maxI * 3 + 1], v_3x3[maxI * 3 + 2]], []);\n\n      for (var t = 0; t < 3; t++) {\n        v_3x3[k * 3 + t] = vectTmp1[t];\n        v_3x3[j * 3 + t] = vectTmp2[t];\n      } // transpose vectors back to columns\n\n\n      transpose3x3(v_3x3, v_3x3);\n      return;\n    }\n  } // the three eigenvalues are different, just sort the eigenvectors\n  // to align them with the x, y, and z axes\n  // find the vector with the largest x element, make that vector\n  // the first vector\n\n\n  maxVal = Math.abs(v_3x3[0]);\n  maxI = 0;\n\n  for (i = 1; i < 3; i++) {\n    if (maxVal < (tmp = Math.abs(v_3x3[i * 3]))) {\n      maxVal = tmp;\n      maxI = i;\n    }\n  } // swap eigenvalue and eigenvector\n\n\n  if (maxI !== 0) {\n    var eigenValTmp = w_3[maxI];\n    w_3[maxI] = w_3[0];\n    w_3[0] = eigenValTmp;\n    swapRowsMatrix_nxn(v_3x3, 3, maxI, 0);\n  } // do the same for the y element\n\n\n  if (Math.abs(v_3x3[4]) < Math.abs(v_3x3[7])) {\n    var _eigenValTmp = w_3[2];\n    w_3[2] = w_3[1];\n    w_3[1] = _eigenValTmp;\n    swapRowsMatrix_nxn(v_3x3, 3, 1, 2);\n  } // ensure that the sign of the eigenvectors is correct\n\n\n  for (i = 0; i < 2; i++) {\n    if (v_3x3[i * 3 + i] < 0) {\n      v_3x3[i * 3] = -v_3x3[i * 3];\n      v_3x3[i * 3 + 1] = -v_3x3[i * 3 + 1];\n      v_3x3[i * 3 + 2] = -v_3x3[i * 3 + 2];\n    }\n  } // set sign of final eigenvector to ensure that determinant is positive\n\n\n  if (determinant3x3(v_3x3) < 0) {\n    v_3x3[6] = -v_3x3[6];\n    v_3x3[7] = -v_3x3[7];\n    v_3x3[8] = -v_3x3[8];\n  } // transpose the eigenvectors back again\n\n\n  transpose3x3(v_3x3, v_3x3);\n}\nfunction singularValueDecomposition3x3(a_3x3, u_3x3, w_3, vT_3x3) {\n  var i; // copy so that A can be used for U or VT without risk\n\n  var B = _toConsumableArray(a_3x3); // temporarily flip if determinant is negative\n\n\n  var d = determinant3x3(B);\n\n  if (d < 0) {\n    for (i = 0; i < 9; i++) {\n      B[i] = -B[i];\n    }\n  } // orthogonalize, diagonalize, etc.\n\n\n  orthogonalize3x3(B, u_3x3);\n  transpose3x3(B, B);\n  multiply3x3_mat3(B, u_3x3, vT_3x3);\n  diagonalize3x3(vT_3x3, w_3, vT_3x3);\n  multiply3x3_mat3(u_3x3, vT_3x3, u_3x3);\n  transpose3x3(vT_3x3, vT_3x3); // re-create the flip\n\n  if (d < 0) {\n    w_3[0] = -w_3[0];\n    w_3[1] = -w_3[1];\n    w_3[2] = -w_3[2];\n  }\n}\n/**\n * Factor linear equations Ax = b using LU decomposition A = LU. Output factorization LU is in matrix A.\n * @param {Matrix} A square matrix\n * @param {Number} index integer array of pivot indices index[0->n-1]\n * @param {Number} size matrix size\n */\n\nfunction luFactorLinearSystem(A, index, size) {\n  var i;\n  var j;\n  var k;\n  var largest;\n  var maxI = 0;\n  var sum;\n  var temp1;\n  var temp2;\n  var scale = createArray(size); //\n  // Loop over rows to get implicit scaling information\n  //\n\n  for (i = 0; i < size; i++) {\n    for (largest = 0.0, j = 0; j < size; j++) {\n      if ((temp2 = Math.abs(A[i * size + j])) > largest) {\n        largest = temp2;\n      }\n    }\n\n    if (largest === 0.0) {\n      vtkWarningMacro('Unable to factor linear system');\n      return 0;\n    }\n\n    scale[i] = 1.0 / largest;\n  } //\n  // Loop over all columns using Crout's method\n  //\n\n\n  for (j = 0; j < size; j++) {\n    for (i = 0; i < j; i++) {\n      sum = A[i * size + j];\n\n      for (k = 0; k < i; k++) {\n        sum -= A[i * size + k] * A[k * size + j];\n      }\n\n      A[i * size + j] = sum;\n    } //\n    // Begin search for largest pivot element\n    //\n\n\n    for (largest = 0.0, i = j; i < size; i++) {\n      sum = A[i * size + j];\n\n      for (k = 0; k < j; k++) {\n        sum -= A[i * size + k] * A[k * size + j];\n      }\n\n      A[i * size + j] = sum;\n\n      if ((temp1 = scale[i] * Math.abs(sum)) >= largest) {\n        largest = temp1;\n        maxI = i;\n      }\n    } //\n    // Check for row interchange\n    //\n\n\n    if (j !== maxI) {\n      for (k = 0; k < size; k++) {\n        temp1 = A[maxI * size + k];\n        A[maxI * size + k] = A[j * size + k];\n        A[j * size + k] = temp1;\n      }\n\n      scale[maxI] = scale[j];\n    } //\n    // Divide by pivot element and perform elimination\n    //\n\n\n    index[j] = maxI;\n\n    if (Math.abs(A[j * size + j]) <= VTK_SMALL_NUMBER) {\n      vtkWarningMacro('Unable to factor linear system');\n      return 0;\n    }\n\n    if (j !== size - 1) {\n      temp1 = 1.0 / A[j * size + j];\n\n      for (i = j + 1; i < size; i++) {\n        A[i * size + j] *= temp1;\n      }\n    }\n  }\n\n  return 1;\n}\nfunction luSolveLinearSystem(A, index, x, size) {\n  var i;\n  var j;\n  var ii;\n  var idx;\n  var sum; //\n  // Proceed with forward and backsubstitution for L and U\n  // matrices.  First, forward substitution.\n  //\n\n  for (ii = -1, i = 0; i < size; i++) {\n    idx = index[i];\n    sum = x[idx];\n    x[idx] = x[i];\n\n    if (ii >= 0) {\n      for (j = ii; j <= i - 1; j++) {\n        sum -= A[i * size + j] * x[j];\n      }\n    } else if (sum !== 0.0) {\n      ii = i;\n    }\n\n    x[i] = sum;\n  } //\n  // Now, back substitution\n  //\n\n\n  for (i = size - 1; i >= 0; i--) {\n    sum = x[i];\n\n    for (j = i + 1; j < size; j++) {\n      sum -= A[i * size + j] * x[j];\n    }\n\n    x[i] = sum / A[i * size + i];\n  }\n}\nfunction solveLinearSystem(A, x, size) {\n  // if we solving something simple, just solve it\n  if (size === 2) {\n    var y = createArray(2);\n    var det = determinant2x2(A[0], A[1], A[2], A[3]);\n\n    if (det === 0.0) {\n      // Unable to solve linear system\n      return 0;\n    }\n\n    y[0] = (A[3] * x[0] - A[1] * x[1]) / det;\n    y[1] = (-(A[2] * x[0]) + A[0] * x[1]) / det;\n    x[0] = y[0];\n    x[1] = y[1];\n    return 1;\n  }\n\n  if (size === 1) {\n    if (A[0] === 0.0) {\n      // Unable to solve linear system\n      return 0;\n    }\n\n    x[0] /= A[0];\n    return 1;\n  } //\n  // System of equations is not trivial, use Crout's method\n  //\n  // Check on allocation of working vectors\n\n\n  var index = createArray(size); // Factor and solve matrix\n\n  if (luFactorLinearSystem(A, index, size) === 0) {\n    return 0;\n  }\n\n  luSolveLinearSystem(A, index, x, size);\n  return 1;\n} // Note that A is modified during the inversion !\n\nfunction invertMatrix(A, AI, size) {\n  var index = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n  var column = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : null;\n  var tmp1Size = index || createArray(size);\n  var tmp2Size = column || createArray(size); // Factor matrix; then begin solving for inverse one column at a time.\n  // Note: tmp1Size returned value is used later, tmp2Size is just working\n  // memory whose values are not used in LUSolveLinearSystem\n\n  if (luFactorLinearSystem(A, tmp1Size, size) === 0) {\n    return null;\n  }\n\n  for (var j = 0; j < size; j++) {\n    for (var i = 0; i < size; i++) {\n      tmp2Size[i] = 0.0;\n    }\n\n    tmp2Size[j] = 1.0;\n    luSolveLinearSystem(A, tmp1Size, tmp2Size, size);\n\n    for (var _i4 = 0; _i4 < size; _i4++) {\n      AI[_i4 * size + j] = tmp2Size[_i4];\n    }\n  }\n\n  return AI;\n}\nfunction estimateMatrixCondition(A, size) {\n  var minValue = +Number.MAX_VALUE;\n  var maxValue = -Number.MAX_VALUE; // find the maximum value\n\n  for (var i = 0; i < size; i++) {\n    for (var j = i; j < size; j++) {\n      if (Math.abs(A[i * size + j]) > maxValue) {\n        maxValue = Math.abs(A[i * size + j]);\n      }\n    }\n  } // find the minimum diagonal value\n\n\n  for (var _i5 = 0; _i5 < size; _i5++) {\n    if (Math.abs(A[_i5 * size + _i5]) < minValue) {\n      minValue = Math.abs(A[_i5 * size + _i5]);\n    }\n  }\n\n  if (minValue === 0.0) {\n    return Number.MAX_VALUE;\n  }\n\n  return maxValue / minValue;\n}\nfunction jacobi(a_3x3, w, v) {\n  return jacobiN(a_3x3, 3, w, v);\n}\nfunction solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt) {\n  // check dimensional consistency\n  if (numberOfSamples < xOrder) {\n    vtkWarningMacro('Insufficient number of samples. Underdetermined.');\n    return 0;\n  }\n\n  var i;\n  var j;\n  var k; // set up intermediate variables\n  // Allocate matrix to hold X times transpose of X\n\n  var XXt = createArray(xOrder * xOrder); // size x by x\n  // Allocate the array of eigenvalues and eigenvectors\n\n  var eigenvals = createArray(xOrder);\n  var eigenvecs = createArray(xOrder * xOrder); // Calculate XXt upper half only, due to symmetry\n\n  for (k = 0; k < numberOfSamples; k++) {\n    for (i = 0; i < xOrder; i++) {\n      for (j = i; j < xOrder; j++) {\n        XXt[i * xOrder + j] += xt[k * xOrder + i] * xt[k * xOrder + j];\n      }\n    }\n  } // now fill in the lower half of the XXt matrix\n\n\n  for (i = 0; i < xOrder; i++) {\n    for (j = 0; j < i; j++) {\n      XXt[i * xOrder + j] = XXt[j * xOrder + i];\n    }\n  } // Compute the eigenvectors and eigenvalues\n\n\n  jacobiN(XXt, xOrder, eigenvals, eigenvecs); // Smallest eigenval is at the end of the list (xOrder-1), and solution is\n  // corresponding eigenvec.\n\n  for (i = 0; i < xOrder; i++) {\n    mt[i] = eigenvecs[i * xOrder + xOrder - 1];\n  }\n\n  return 1;\n}\nfunction solveLeastSquares(numberOfSamples, xt, xOrder, yt, yOrder, mt) {\n  var checkHomogeneous = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : true;\n\n  // check dimensional consistency\n  if (numberOfSamples < xOrder || numberOfSamples < yOrder) {\n    vtkWarningMacro('Insufficient number of samples. Underdetermined.');\n    return 0;\n  }\n\n  var homogenFlags = createArray(yOrder);\n  var allHomogeneous = 1;\n  var hmt;\n  var homogRC = 0;\n  var i;\n  var j;\n  var k;\n  var someHomogeneous = 0; // Ok, first init some flags check and see if all the systems are homogeneous\n\n  if (checkHomogeneous) {\n    // If Y' is zero, it's a homogeneous system and can't be solved via\n    // the pseudoinverse method. Detect this case, warn the user, and\n    // invoke SolveHomogeneousLeastSquares instead. Note that it doesn't\n    // really make much sense for yOrder to be greater than one in this case,\n    // since that's just yOrder occurrences of a 0 vector on the RHS, but\n    // we allow it anyway. N\n    // Initialize homogeneous flags on a per-right-hand-side basis\n    for (j = 0; j < yOrder; j++) {\n      homogenFlags[j] = 1;\n    }\n\n    for (i = 0; i < numberOfSamples; i++) {\n      for (j = 0; j < yOrder; j++) {\n        if (Math.abs(yt[i * yOrder + j]) > VTK_SMALL_NUMBER) {\n          allHomogeneous = 0;\n          homogenFlags[j] = 0;\n        }\n      }\n    } // If we've got one system, and it's homogeneous, do it and bail out quickly.\n\n\n    if (allHomogeneous && yOrder === 1) {\n      vtkWarningMacro('Detected homogeneous system (Y=0), calling SolveHomogeneousLeastSquares()');\n      return solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, mt);\n    } // Ok, we've got more than one system of equations.\n    // Figure out if we need to calculate the homogeneous equation solution for\n    // any of them.\n\n\n    if (allHomogeneous) {\n      someHomogeneous = 1;\n    } else {\n      for (j = 0; j < yOrder; j++) {\n        if (homogenFlags[j]) {\n          someHomogeneous = 1;\n        }\n      }\n    }\n  } // If necessary, solve the homogeneous problem\n\n\n  if (someHomogeneous) {\n    // hmt is the homogeneous equation version of mt, the general solution.\n    // hmt should be xOrder x yOrder, but since we are solving only the homogeneous part, here it is xOrder x 1\n    hmt = createArray(xOrder); // Ok, solve the homogeneous problem\n\n    homogRC = solveHomogeneousLeastSquares(numberOfSamples, xt, xOrder, hmt);\n  } // set up intermediate variables\n\n\n  var XXt = createArray(xOrder * xOrder); // size x by x\n\n  var XXtI = createArray(xOrder * xOrder); // size x by x\n\n  var XYt = createArray(xOrder * yOrder); // size x by y\n  // first find the pseudoinverse matrix\n\n  for (k = 0; k < numberOfSamples; k++) {\n    for (i = 0; i < xOrder; i++) {\n      // first calculate the XXt matrix, only do the upper half (symmetrical)\n      for (j = i; j < xOrder; j++) {\n        XXt[i * xOrder + j] += xt[k * xOrder + i] * xt[k * xOrder + j];\n      } // now calculate the XYt matrix\n\n\n      for (j = 0; j < yOrder; j++) {\n        XYt[i * yOrder + j] += xt[k * xOrder + i] * yt[k * yOrder + j];\n      }\n    }\n  } // now fill in the lower half of the XXt matrix\n\n\n  for (i = 0; i < xOrder; i++) {\n    for (j = 0; j < i; j++) {\n      XXt[i * xOrder + j] = XXt[j * xOrder + i];\n    }\n  }\n\n  var successFlag = invertMatrix(XXt, XXtI, xOrder); // next get the inverse of XXt\n\n  if (successFlag) {\n    for (i = 0; i < xOrder; i++) {\n      for (j = 0; j < yOrder; j++) {\n        mt[i * yOrder + j] = 0.0;\n\n        for (k = 0; k < xOrder; k++) {\n          mt[i * yOrder + j] += XXtI[i * xOrder + k] * XYt[k * yOrder + j];\n        }\n      }\n    }\n  } // Fix up any of the solutions that correspond to the homogeneous equation\n  // problem.\n\n\n  if (someHomogeneous) {\n    for (j = 0; j < yOrder; j++) {\n      if (homogenFlags[j]) {\n        // Fix this one\n        for (i = 0; i < xOrder; i++) {\n          mt[i * yOrder + j] = hmt[i * yOrder];\n        }\n      }\n    }\n  }\n\n  if (someHomogeneous) {\n    return homogRC && successFlag;\n  }\n\n  return successFlag;\n}\nfunction hex2float(hexStr) {\n  var outFloatArray = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [0, 0.5, 1];\n\n  switch (hexStr.length) {\n    case 3:\n      // abc => #aabbcc\n      outFloatArray[0] = parseInt(hexStr[0], 16) * 17 / 255;\n      outFloatArray[1] = parseInt(hexStr[1], 16) * 17 / 255;\n      outFloatArray[2] = parseInt(hexStr[2], 16) * 17 / 255;\n      return outFloatArray;\n\n    case 4:\n      // #abc => #aabbcc\n      outFloatArray[0] = parseInt(hexStr[1], 16) * 17 / 255;\n      outFloatArray[1] = parseInt(hexStr[2], 16) * 17 / 255;\n      outFloatArray[2] = parseInt(hexStr[3], 16) * 17 / 255;\n      return outFloatArray;\n\n    case 6:\n      // ab01df => #ab01df\n      outFloatArray[0] = parseInt(hexStr.substr(0, 2), 16) / 255;\n      outFloatArray[1] = parseInt(hexStr.substr(2, 2), 16) / 255;\n      outFloatArray[2] = parseInt(hexStr.substr(4, 2), 16) / 255;\n      return outFloatArray;\n\n    case 7:\n      // #ab01df\n      outFloatArray[0] = parseInt(hexStr.substr(1, 2), 16) / 255;\n      outFloatArray[1] = parseInt(hexStr.substr(3, 2), 16) / 255;\n      outFloatArray[2] = parseInt(hexStr.substr(5, 2), 16) / 255;\n      return outFloatArray;\n\n    case 9:\n      // #ab01df00\n      outFloatArray[0] = parseInt(hexStr.substr(1, 2), 16) / 255;\n      outFloatArray[1] = parseInt(hexStr.substr(3, 2), 16) / 255;\n      outFloatArray[2] = parseInt(hexStr.substr(5, 2), 16) / 255;\n      outFloatArray[3] = parseInt(hexStr.substr(7, 2), 16) / 255;\n      return outFloatArray;\n\n    default:\n      return outFloatArray;\n  }\n}\nfunction rgb2hsv(rgb, hsv) {\n  var h;\n  var s;\n\n  var _rgb = _slicedToArray(rgb, 3),\n      r = _rgb[0],\n      g = _rgb[1],\n      b = _rgb[2];\n\n  var onethird = 1.0 / 3.0;\n  var onesixth = 1.0 / 6.0;\n  var twothird = 2.0 / 3.0;\n  var cmax = r;\n  var cmin = r;\n\n  if (g > cmax) {\n    cmax = g;\n  } else if (g < cmin) {\n    cmin = g;\n  }\n\n  if (b > cmax) {\n    cmax = b;\n  } else if (b < cmin) {\n    cmin = b;\n  }\n\n  var v = cmax;\n\n  if (v > 0.0) {\n    s = (cmax - cmin) / cmax;\n  } else {\n    s = 0.0;\n  }\n\n  if (s > 0) {\n    if (r === cmax) {\n      h = onesixth * (g - b) / (cmax - cmin);\n    } else if (g === cmax) {\n      h = onethird + onesixth * (b - r) / (cmax - cmin);\n    } else {\n      h = twothird + onesixth * (r - g) / (cmax - cmin);\n    }\n\n    if (h < 0.0) {\n      h += 1.0;\n    }\n  } else {\n    h = 0.0;\n  } // Set the values back to the array\n\n\n  hsv[0] = h;\n  hsv[1] = s;\n  hsv[2] = v;\n}\nfunction hsv2rgb(hsv, rgb) {\n  var _hsv = _slicedToArray(hsv, 3),\n      h = _hsv[0],\n      s = _hsv[1],\n      v = _hsv[2];\n\n  var onethird = 1.0 / 3.0;\n  var onesixth = 1.0 / 6.0;\n  var twothird = 2.0 / 3.0;\n  var fivesixth = 5.0 / 6.0;\n  var r;\n  var g;\n  var b; // compute RGB from HSV\n\n  if (h > onesixth && h <= onethird) {\n    // green/red\n    g = 1.0;\n    r = (onethird - h) / onesixth;\n    b = 0.0;\n  } else if (h > onethird && h <= 0.5) {\n    // green/blue\n    g = 1.0;\n    b = (h - onethird) / onesixth;\n    r = 0.0;\n  } else if (h > 0.5 && h <= twothird) {\n    // blue/green\n    b = 1.0;\n    g = (twothird - h) / onesixth;\n    r = 0.0;\n  } else if (h > twothird && h <= fivesixth) {\n    // blue/red\n    b = 1.0;\n    r = (h - twothird) / onesixth;\n    g = 0.0;\n  } else if (h > fivesixth && h <= 1.0) {\n    // red/blue\n    r = 1.0;\n    b = (1.0 - h) / onesixth;\n    g = 0.0;\n  } else {\n    // red/green\n    r = 1.0;\n    g = h / onesixth;\n    b = 0.0;\n  } // add Saturation to the equation.\n\n\n  r = s * r + (1.0 - s);\n  g = s * g + (1.0 - s);\n  b = s * b + (1.0 - s);\n  r *= v;\n  g *= v;\n  b *= v; // Assign back to the array\n\n  rgb[0] = r;\n  rgb[1] = g;\n  rgb[2] = b;\n}\nfunction lab2xyz(lab, xyz) {\n  // LAB to XYZ\n  var _lab = _slicedToArray(lab, 3),\n      L = _lab[0],\n      a = _lab[1],\n      b = _lab[2];\n\n  var var_Y = (L + 16) / 116;\n  var var_X = a / 500 + var_Y;\n  var var_Z = var_Y - b / 200;\n\n  if (Math.pow(var_Y, 3) > 0.008856) {\n    var_Y = Math.pow(var_Y, 3);\n  } else {\n    var_Y = (var_Y - 16.0 / 116.0) / 7.787;\n  }\n\n  if (Math.pow(var_X, 3) > 0.008856) {\n    var_X = Math.pow(var_X, 3);\n  } else {\n    var_X = (var_X - 16.0 / 116.0) / 7.787;\n  }\n\n  if (Math.pow(var_Z, 3) > 0.008856) {\n    var_Z = Math.pow(var_Z, 3);\n  } else {\n    var_Z = (var_Z - 16.0 / 116.0) / 7.787;\n  }\n\n  var ref_X = 0.9505;\n  var ref_Y = 1.0;\n  var ref_Z = 1.089;\n  xyz[0] = ref_X * var_X; // ref_X = 0.9505  Observer= 2 deg Illuminant= D65\n\n  xyz[1] = ref_Y * var_Y; // ref_Y = 1.000\n\n  xyz[2] = ref_Z * var_Z; // ref_Z = 1.089\n}\nfunction xyz2lab(xyz, lab) {\n  var _xyz = _slicedToArray(xyz, 3),\n      x = _xyz[0],\n      y = _xyz[1],\n      z = _xyz[2];\n\n  var ref_X = 0.9505;\n  var ref_Y = 1.0;\n  var ref_Z = 1.089;\n  var var_X = x / ref_X; // ref_X = 0.9505  Observer= 2 deg, Illuminant= D65\n\n  var var_Y = y / ref_Y; // ref_Y = 1.000\n\n  var var_Z = z / ref_Z; // ref_Z = 1.089\n\n  if (var_X > 0.008856) var_X = Math.pow(var_X, 1.0 / 3.0);else var_X = 7.787 * var_X + 16.0 / 116.0;\n  if (var_Y > 0.008856) var_Y = Math.pow(var_Y, 1.0 / 3.0);else var_Y = 7.787 * var_Y + 16.0 / 116.0;\n  if (var_Z > 0.008856) var_Z = Math.pow(var_Z, 1.0 / 3.0);else var_Z = 7.787 * var_Z + 16.0 / 116.0;\n  lab[0] = 116 * var_Y - 16;\n  lab[1] = 500 * (var_X - var_Y);\n  lab[2] = 200 * (var_Y - var_Z);\n}\nfunction xyz2rgb(xyz, rgb) {\n  var _xyz2 = _slicedToArray(xyz, 3),\n      x = _xyz2[0],\n      y = _xyz2[1],\n      z = _xyz2[2];\n\n  var r = x * 3.2406 + y * -1.5372 + z * -0.4986;\n  var g = x * -0.9689 + y * 1.8758 + z * 0.0415;\n  var b = x * 0.0557 + y * -0.204 + z * 1.057; // The following performs a \"gamma correction\" specified by the sRGB color\n  // space.  sRGB is defined by a canonical definition of a display monitor and\n  // has been standardized by the International Electrotechnical Commission (IEC\n  // 61966-2-1).  The nonlinearity of the correction is designed to make the\n  // colors more perceptually uniform.  This color space has been adopted by\n  // several applications including Adobe Photoshop and Microsoft Windows color\n  // management.  OpenGL is agnostic on its RGB color space, but it is reasonable\n  // to assume it is close to this one.\n\n  if (r > 0.0031308) r = 1.055 * Math.pow(r, 1 / 2.4) - 0.055;else r *= 12.92;\n  if (g > 0.0031308) g = 1.055 * Math.pow(g, 1 / 2.4) - 0.055;else g *= 12.92;\n  if (b > 0.0031308) b = 1.055 * Math.pow(b, 1 / 2.4) - 0.055;else b *= 12.92; // Clip colors. ideally we would do something that is perceptually closest\n  // (since we can see colors outside of the display gamut), but this seems to\n  // work well enough.\n\n  var maxVal = r;\n  if (maxVal < g) maxVal = g;\n  if (maxVal < b) maxVal = b;\n\n  if (maxVal > 1.0) {\n    r /= maxVal;\n    g /= maxVal;\n    b /= maxVal;\n  }\n\n  if (r < 0) r = 0;\n  if (g < 0) g = 0;\n  if (b < 0) b = 0; // Push values back to array\n\n  rgb[0] = r;\n  rgb[1] = g;\n  rgb[2] = b;\n}\nfunction rgb2xyz(rgb, xyz) {\n  var _rgb2 = _slicedToArray(rgb, 3),\n      r = _rgb2[0],\n      g = _rgb2[1],\n      b = _rgb2[2]; // The following performs a \"gamma correction\" specified by the sRGB color\n  // space.  sRGB is defined by a canonical definition of a display monitor and\n  // has been standardized by the International Electrotechnical Commission (IEC\n  // 61966-2-1).  The nonlinearity of the correction is designed to make the\n  // colors more perceptually uniform.  This color space has been adopted by\n  // several applications including Adobe Photoshop and Microsoft Windows color\n  // management.  OpenGL is agnostic on its RGB color space, but it is reasonable\n  // to assume it is close to this one.\n\n\n  if (r > 0.04045) r = Math.pow((r + 0.055) / 1.055, 2.4);else r /= 12.92;\n  if (g > 0.04045) g = Math.pow((g + 0.055) / 1.055, 2.4);else g /= 12.92;\n  if (b > 0.04045) b = Math.pow((b + 0.055) / 1.055, 2.4);else b /= 12.92; // Observer. = 2 deg, Illuminant = D65\n\n  xyz[0] = r * 0.4124 + g * 0.3576 + b * 0.1805;\n  xyz[1] = r * 0.2126 + g * 0.7152 + b * 0.0722;\n  xyz[2] = r * 0.0193 + g * 0.1192 + b * 0.9505;\n}\nfunction rgb2lab(rgb, lab) {\n  var xyz = [0, 0, 0];\n  rgb2xyz(rgb, xyz);\n  xyz2lab(xyz, lab);\n}\nfunction lab2rgb(lab, rgb) {\n  var xyz = [0, 0, 0];\n  lab2xyz(lab, xyz);\n  xyz2rgb(xyz, rgb);\n}\nfunction uninitializeBounds(bounds) {\n  bounds[0] = 1.0;\n  bounds[1] = -1.0;\n  bounds[2] = 1.0;\n  bounds[3] = -1.0;\n  bounds[4] = 1.0;\n  bounds[5] = -1.0;\n  return bounds;\n}\nfunction areBoundsInitialized(bounds) {\n  return !(bounds[1] - bounds[0] < 0.0);\n}\nfunction computeBoundsFromPoints(point1, point2, bounds) {\n  bounds[0] = Math.min(point1[0], point2[0]);\n  bounds[1] = Math.max(point1[0], point2[0]);\n  bounds[2] = Math.min(point1[1], point2[1]);\n  bounds[3] = Math.max(point1[1], point2[1]);\n  bounds[4] = Math.min(point1[2], point2[2]);\n  bounds[5] = Math.max(point1[2], point2[2]);\n  return bounds;\n}\nfunction clampValue(value, minValue, maxValue) {\n  if (value < minValue) {\n    return minValue;\n  }\n\n  if (value > maxValue) {\n    return maxValue;\n  }\n\n  return value;\n}\nfunction clampVector(vector, minVector, maxVector) {\n  var out = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [0, 0, 0];\n  out[0] = clampValue(vector[0], minVector[0], maxVector[0]);\n  out[1] = clampValue(vector[1], minVector[1], maxVector[1]);\n  out[2] = clampValue(vector[2], minVector[2], maxVector[2]);\n  return out;\n}\nfunction clampAndNormalizeValue(value, range) {\n  var result = 0;\n\n  if (range[0] !== range[1]) {\n    // clamp\n    if (value < range[0]) {\n      result = range[0];\n    } else if (value > range[1]) {\n      result = range[1];\n    } else {\n      result = value;\n    } // normalize\n\n\n    result = (result - range[0]) / (range[1] - range[0]);\n  }\n\n  return result;\n}\nvar getScalarTypeFittingRange = notImplemented('GetScalarTypeFittingRange');\nvar getAdjustedScalarRange = notImplemented('GetAdjustedScalarRange');\nfunction extentIsWithinOtherExtent(extent1, extent2) {\n  if (!extent1 || !extent2) {\n    return 0;\n  }\n\n  for (var i = 0; i < 6; i += 2) {\n    if (extent1[i] < extent2[i] || extent1[i] > extent2[i + 1] || extent1[i + 1] < extent2[i] || extent1[i + 1] > extent2[i + 1]) {\n      return 0;\n    }\n  }\n\n  return 1;\n}\nfunction boundsIsWithinOtherBounds(bounds1_6, bounds2_6, delta_3) {\n  if (!bounds1_6 || !bounds2_6) {\n    return 0;\n  }\n\n  for (var i = 0; i < 6; i += 2) {\n    if (bounds1_6[i] + delta_3[i / 2] < bounds2_6[i] || bounds1_6[i] - delta_3[i / 2] > bounds2_6[i + 1] || bounds1_6[i + 1] + delta_3[i / 2] < bounds2_6[i] || bounds1_6[i + 1] - delta_3[i / 2] > bounds2_6[i + 1]) {\n      return 0;\n    }\n  }\n\n  return 1;\n}\nfunction pointIsWithinBounds(point_3, bounds_6, delta_3) {\n  if (!point_3 || !bounds_6 || !delta_3) {\n    return 0;\n  }\n\n  for (var i = 0; i < 3; i++) {\n    if (point_3[i] + delta_3[i] < bounds_6[2 * i] || point_3[i] - delta_3[i] > bounds_6[2 * i + 1]) {\n      return 0;\n    }\n  }\n\n  return 1;\n}\nfunction solve3PointCircle(p1, p2, p3, center) {\n  var v21 = createArray(3);\n  var v32 = createArray(3);\n  var v13 = createArray(3);\n  var v12 = createArray(3);\n  var v23 = createArray(3);\n  var v31 = createArray(3);\n\n  for (var i = 0; i < 3; ++i) {\n    v21[i] = p1[i] - p2[i];\n    v32[i] = p2[i] - p3[i];\n    v13[i] = p3[i] - p1[i];\n    v12[i] = -v21[i];\n    v23[i] = -v32[i];\n    v31[i] = -v13[i];\n  }\n\n  var norm12 = norm(v12);\n  var norm23 = norm(v23);\n  var norm13 = norm(v13);\n  var crossv21v32 = createArray(3);\n  cross(v21, v32, crossv21v32);\n  var normCross = norm(crossv21v32);\n  var radius = norm12 * norm23 * norm13 / (2 * normCross);\n  var normCross22 = 2 * normCross * normCross;\n  var alpha = norm23 * norm23 * dot(v21, v31) / normCross22;\n  var beta = norm13 * norm13 * dot(v12, v32) / normCross22;\n  var gamma = norm12 * norm12 * dot(v13, v23) / normCross22;\n\n  for (var _i6 = 0; _i6 < 3; ++_i6) {\n    center[_i6] = alpha * p1[_i6] + beta * p2[_i6] + gamma * p3[_i6];\n  }\n\n  return radius;\n}\nvar inf = Infinity;\nvar negInf = -Infinity;\nvar isInf = function isInf(value) {\n  return !Number.isFinite(value);\n};\nvar isFinite = Number.isFinite,\n    isNaN = Number.isNaN;\nvar isNan = isNaN; // JavaScript - add-on ----------------------\n\nfunction createUninitializedBounds() {\n  return [].concat([Number.MAX_VALUE, -Number.MAX_VALUE, // X\n  Number.MAX_VALUE, -Number.MAX_VALUE, // Y\n  Number.MAX_VALUE, -Number.MAX_VALUE // Z\n  ]);\n}\nfunction getMajorAxisIndex(vector) {\n  var maxValue = -1;\n  var axisIndex = -1;\n\n  for (var i = 0; i < vector.length; i++) {\n    var value = Math.abs(vector[i]);\n\n    if (value > maxValue) {\n      axisIndex = i;\n      maxValue = value;\n    }\n  }\n\n  return axisIndex;\n}\nfunction floatToHex2(value) {\n  var integer = Math.floor(value * 255);\n\n  if (integer > 15) {\n    return integer.toString(16);\n  }\n\n  return \"0\".concat(integer.toString(16));\n}\nfunction floatRGB2HexCode(rgbArray) {\n  var prefix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '#';\n  return \"\".concat(prefix).concat(rgbArray.map(floatToHex2).join(''));\n}\n\nfunction floatToChar(f) {\n  return Math.round(f * 255);\n}\n\nfunction float2CssRGBA(rgbArray) {\n  if (rgbArray.length === 3) {\n    return \"rgb(\".concat(rgbArray.map(floatToChar).join(', '), \")\");\n  }\n\n  return \"rgba(\".concat(floatToChar(rgbArray[0] || 0), \", \").concat(floatToChar(rgbArray[1] || 0), \", \").concat(floatToChar(rgbArray[2] || 0), \", \").concat(rgbArray[3] || 0, \")\");\n} // ----------------------------------------------------------------------------\n// Only Static API\n// ----------------------------------------------------------------------------\n\nvar vtkMath = {\n  Pi: Pi,\n  radiansFromDegrees: radiansFromDegrees,\n  degreesFromRadians: degreesFromRadians,\n  round: round,\n  floor: floor,\n  ceil: ceil,\n  ceilLog2: ceilLog2,\n  min: min,\n  max: max,\n  arrayMin: arrayMin,\n  arrayMax: arrayMax,\n  arrayRange: arrayRange,\n  isPowerOfTwo: isPowerOfTwo,\n  nearestPowerOfTwo: nearestPowerOfTwo,\n  factorial: factorial,\n  binomial: binomial,\n  beginCombination: beginCombination,\n  nextCombination: nextCombination,\n  randomSeed: randomSeed,\n  getSeed: getSeed,\n  random: random,\n  gaussian: gaussian,\n  add: add,\n  subtract: subtract,\n  multiplyScalar: multiplyScalar,\n  multiplyScalar2D: multiplyScalar2D,\n  multiplyAccumulate: multiplyAccumulate,\n  multiplyAccumulate2D: multiplyAccumulate2D,\n  dot: dot,\n  outer: outer,\n  cross: cross,\n  norm: norm,\n  normalize: normalize,\n  perpendiculars: perpendiculars,\n  projectVector: projectVector,\n  projectVector2D: projectVector2D,\n  distance2BetweenPoints: distance2BetweenPoints,\n  angleBetweenVectors: angleBetweenVectors,\n  gaussianAmplitude: gaussianAmplitude,\n  gaussianWeight: gaussianWeight,\n  dot2D: dot2D,\n  outer2D: outer2D,\n  norm2D: norm2D,\n  normalize2D: normalize2D,\n  determinant2x2: determinant2x2,\n  LUFactor3x3: LUFactor3x3,\n  LUSolve3x3: LUSolve3x3,\n  linearSolve3x3: linearSolve3x3,\n  multiply3x3_vect3: multiply3x3_vect3,\n  multiply3x3_mat3: multiply3x3_mat3,\n  multiplyMatrix: multiplyMatrix,\n  transpose3x3: transpose3x3,\n  invert3x3: invert3x3,\n  identity3x3: identity3x3,\n  identity: identity,\n  isIdentity: isIdentity,\n  isIdentity3x3: isIdentity3x3,\n  determinant3x3: determinant3x3,\n  quaternionToMatrix3x3: quaternionToMatrix3x3,\n  areEquals: areEquals,\n  areMatricesEqual: areMatricesEqual,\n  roundNumber: roundNumber,\n  roundVector: roundVector,\n  matrix3x3ToQuaternion: matrix3x3ToQuaternion,\n  multiplyQuaternion: multiplyQuaternion,\n  orthogonalize3x3: orthogonalize3x3,\n  diagonalize3x3: diagonalize3x3,\n  singularValueDecomposition3x3: singularValueDecomposition3x3,\n  solveLinearSystem: solveLinearSystem,\n  invertMatrix: invertMatrix,\n  luFactorLinearSystem: luFactorLinearSystem,\n  luSolveLinearSystem: luSolveLinearSystem,\n  estimateMatrixCondition: estimateMatrixCondition,\n  jacobi: jacobi,\n  jacobiN: jacobiN,\n  solveHomogeneousLeastSquares: solveHomogeneousLeastSquares,\n  solveLeastSquares: solveLeastSquares,\n  hex2float: hex2float,\n  rgb2hsv: rgb2hsv,\n  hsv2rgb: hsv2rgb,\n  lab2xyz: lab2xyz,\n  xyz2lab: xyz2lab,\n  xyz2rgb: xyz2rgb,\n  rgb2xyz: rgb2xyz,\n  rgb2lab: rgb2lab,\n  lab2rgb: lab2rgb,\n  uninitializeBounds: uninitializeBounds,\n  areBoundsInitialized: areBoundsInitialized,\n  computeBoundsFromPoints: computeBoundsFromPoints,\n  clampValue: clampValue,\n  clampVector: clampVector,\n  clampAndNormalizeValue: clampAndNormalizeValue,\n  getScalarTypeFittingRange: getScalarTypeFittingRange,\n  getAdjustedScalarRange: getAdjustedScalarRange,\n  extentIsWithinOtherExtent: extentIsWithinOtherExtent,\n  boundsIsWithinOtherBounds: boundsIsWithinOtherBounds,\n  pointIsWithinBounds: pointIsWithinBounds,\n  solve3PointCircle: solve3PointCircle,\n  inf: inf,\n  negInf: negInf,\n  isInf: isInf,\n  isNan: isNaN,\n  isNaN: isNaN,\n  isFinite: isFinite,\n  // JS add-on\n  createUninitializedBounds: createUninitializedBounds,\n  getMajorAxisIndex: getMajorAxisIndex,\n  floatToHex2: floatToHex2,\n  floatRGB2HexCode: floatRGB2HexCode,\n  float2CssRGBA: float2CssRGBA\n};\n\nvar vtkMath$1 = /*#__PURE__*/Object.freeze({\n  __proto__: null,\n  createArray: createArray,\n  Pi: Pi,\n  radiansFromDegrees: radiansFromDegrees,\n  degreesFromRadians: degreesFromRadians,\n  round: round,\n  floor: floor,\n  ceil: ceil,\n  min: min,\n  max: max,\n  arrayMin: arrayMin,\n  arrayMax: arrayMax,\n  arrayRange: arrayRange,\n  ceilLog2: ceilLog2,\n  factorial: factorial,\n  nearestPowerOfTwo: nearestPowerOfTwo,\n  isPowerOfTwo: isPowerOfTwo,\n  binomial: binomial,\n  beginCombination: beginCombination,\n  nextCombination: nextCombination,\n  randomSeed: randomSeed,\n  getSeed: getSeed,\n  random: random,\n  gaussian: gaussian,\n  add: add,\n  subtract: subtract,\n  multiplyScalar: multiplyScalar,\n  multiplyScalar2D: multiplyScalar2D,\n  multiplyAccumulate: multiplyAccumulate,\n  multiplyAccumulate2D: multiplyAccumulate2D,\n  dot: dot,\n  outer: outer,\n  cross: cross,\n  norm: norm,\n  normalize: normalize,\n  perpendiculars: perpendiculars,\n  projectVector: projectVector,\n  dot2D: dot2D,\n  projectVector2D: projectVector2D,\n  distance2BetweenPoints: distance2BetweenPoints,\n  angleBetweenVectors: angleBetweenVectors,\n  signedAngleBetweenVectors: signedAngleBetweenVectors,\n  gaussianAmplitude: gaussianAmplitude,\n  gaussianWeight: gaussianWeight,\n  outer2D: outer2D,\n  norm2D: norm2D,\n  normalize2D: normalize2D,\n  rowsToMat4: rowsToMat4,\n  columnsToMat4: columnsToMat4,\n  rowsToMat3: rowsToMat3,\n  columnsToMat3: columnsToMat3,\n  determinant2x2: determinant2x2,\n  LUFactor3x3: LUFactor3x3,\n  LUSolve3x3: LUSolve3x3,\n  linearSolve3x3: linearSolve3x3,\n  multiply3x3_vect3: multiply3x3_vect3,\n  multiply3x3_mat3: multiply3x3_mat3,\n  multiplyMatrix: multiplyMatrix,\n  transpose3x3: transpose3x3,\n  invert3x3: invert3x3,\n  determinant3x3: determinant3x3,\n  areEquals: areEquals,\n  areMatricesEqual: areMatricesEqual,\n  identity3x3: identity3x3,\n  identity: identity,\n  isIdentity: isIdentity,\n  isIdentity3x3: isIdentity3x3,\n  quaternionToMatrix3x3: quaternionToMatrix3x3,\n  roundNumber: roundNumber,\n  roundVector: roundVector,\n  jacobiN: jacobiN,\n  matrix3x3ToQuaternion: matrix3x3ToQuaternion,\n  multiplyQuaternion: multiplyQuaternion,\n  orthogonalize3x3: orthogonalize3x3,\n  diagonalize3x3: diagonalize3x3,\n  singularValueDecomposition3x3: singularValueDecomposition3x3,\n  luFactorLinearSystem: luFactorLinearSystem,\n  luSolveLinearSystem: luSolveLinearSystem,\n  solveLinearSystem: solveLinearSystem,\n  invertMatrix: invertMatrix,\n  estimateMatrixCondition: estimateMatrixCondition,\n  jacobi: jacobi,\n  solveHomogeneousLeastSquares: solveHomogeneousLeastSquares,\n  solveLeastSquares: solveLeastSquares,\n  hex2float: hex2float,\n  rgb2hsv: rgb2hsv,\n  hsv2rgb: hsv2rgb,\n  lab2xyz: lab2xyz,\n  xyz2lab: xyz2lab,\n  xyz2rgb: xyz2rgb,\n  rgb2xyz: rgb2xyz,\n  rgb2lab: rgb2lab,\n  lab2rgb: lab2rgb,\n  uninitializeBounds: uninitializeBounds,\n  areBoundsInitialized: areBoundsInitialized,\n  computeBoundsFromPoints: computeBoundsFromPoints,\n  clampValue: clampValue,\n  clampVector: clampVector,\n  clampAndNormalizeValue: clampAndNormalizeValue,\n  getScalarTypeFittingRange: getScalarTypeFittingRange,\n  getAdjustedScalarRange: getAdjustedScalarRange,\n  extentIsWithinOtherExtent: extentIsWithinOtherExtent,\n  boundsIsWithinOtherBounds: boundsIsWithinOtherBounds,\n  pointIsWithinBounds: pointIsWithinBounds,\n  solve3PointCircle: solve3PointCircle,\n  inf: inf,\n  negInf: negInf,\n  isInf: isInf,\n  isFinite: isFinite,\n  isNaN: isNaN,\n  isNan: isNan,\n  createUninitializedBounds: createUninitializedBounds,\n  getMajorAxisIndex: getMajorAxisIndex,\n  floatToHex2: floatToHex2,\n  floatRGB2HexCode: floatRGB2HexCode,\n  float2CssRGBA: float2CssRGBA,\n  'default': vtkMath\n});\n\nexport { ceilLog2 as $, rowsToMat3 as A, degreesFromRadians as B, areEquals as C, clampValue as D, arrayRange as E, getMajorAxisIndex as F, isInf as G, rgb2hsv as H, rgb2lab as I, lab2rgb as J, floor as K, round as L, normalize2D as M, nearestPowerOfTwo as N, createUninitializedBounds as O, multiply3x3_vect3 as P, areBoundsInitialized as Q, isPowerOfTwo as R, angleBetweenVectors as S, signedAngleBetweenVectors as T, createArray as U, Pi as V, ceil as W, min as X, max as Y, arrayMin as Z, arrayMax as _, areMatricesEqual as a, factorial as a0, binomial as a1, beginCombination as a2, nextCombination as a3, randomSeed as a4, getSeed as a5, gaussian as a6, multiplyScalar2D as a7, multiplyAccumulate2D as a8, outer as a9, diagonalize3x3 as aA, singularValueDecomposition3x3 as aB, luFactorLinearSystem as aC, luSolveLinearSystem as aD, invertMatrix as aE, estimateMatrixCondition as aF, solveHomogeneousLeastSquares as aG, solveLeastSquares as aH, hex2float as aI, lab2xyz as aJ, xyz2lab as aK, xyz2rgb as aL, rgb2xyz as aM, clampAndNormalizeValue as aN, getScalarTypeFittingRange as aO, getAdjustedScalarRange as aP, extentIsWithinOtherExtent as aQ, boundsIsWithinOtherBounds as aR, pointIsWithinBounds as aS, solve3PointCircle as aT, inf as aU, negInf as aV, isFinite as aW, isNaN as aX, floatToHex2 as aY, floatRGB2HexCode as aZ, float2CssRGBA as a_, projectVector as aa, dot2D as ab, projectVector2D as ac, gaussianAmplitude as ad, gaussianWeight as ae, outer2D as af, norm2D as ag, rowsToMat4 as ah, columnsToMat4 as ai, columnsToMat3 as aj, LUFactor3x3 as ak, LUSolve3x3 as al, linearSolve3x3 as am, multiply3x3_mat3 as an, multiplyMatrix as ao, transpose3x3 as ap, invert3x3 as aq, identity3x3 as ar, identity as as, isIdentity as at, isIdentity3x3 as au, quaternionToMatrix3x3 as av, roundNumber as aw, matrix3x3ToQuaternion as ax, multiplyQuaternion as ay, orthogonalize3x3 as az, roundVector as b, computeBoundsFromPoints as c, dot as d, clampVector as e, distance2BetweenPoints as f, vtkMath as g, hsv2rgb as h, isNan as i, solveLinearSystem as j, cross as k, add as l, normalize as m, norm as n, multiplyAccumulate as o, determinant2x2 as p, jacobiN as q, radiansFromDegrees as r, subtract as s, perpendiculars as t, uninitializeBounds as u, vtkMath$1 as v, jacobi as w, multiplyScalar as x, random as y, determinant3x3 as z };\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 * 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\";\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}();","/**\n * Converts a binary buffer in an ArrayBuffer to a string.\n *\n * Note this does not take encoding into consideration, so don't\n * expect proper Unicode or any other encoding.\n */\nfunction arrayBufferToString(arrayBuffer) {\n  var decoder = new TextDecoder('latin1');\n  return decoder.decode(arrayBuffer);\n}\n/**\n * Extracts binary data out of a file ArrayBuffer given a prefix/suffix.\n */\n\n\nfunction extractBinary(arrayBuffer, prefixRegex) {\n  var suffixRegex = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n  var str = arrayBufferToString(arrayBuffer);\n  var prefixMatch = prefixRegex.exec(str);\n\n  if (!prefixMatch) {\n    return {\n      text: str\n    };\n  }\n\n  var dataStartIndex = prefixMatch.index + prefixMatch[0].length;\n  var strFirstHalf = str.substring(0, dataStartIndex);\n  var retVal = null;\n  var suffixMatch = suffixRegex ? suffixRegex.exec(str) : null;\n\n  if (suffixMatch) {\n    var strSecondHalf = str.substr(suffixMatch.index);\n    retVal = {\n      text: strFirstHalf + strSecondHalf,\n      binaryBuffer: arrayBuffer.slice(dataStartIndex, suffixMatch.index)\n    };\n  } else {\n    // no suffix, so just take all the data starting from dataStartIndex\n    retVal = {\n      text: strFirstHalf,\n      binaryBuffer: arrayBuffer.slice(dataStartIndex)\n    };\n  }\n\n  return retVal;\n}\n\nvar BinaryHelper = {\n  arrayBufferToString: arrayBufferToString,\n  extractBinary: extractBinary\n};\n\nexport { BinaryHelper as default };\n","var TYPE_MAPPING = {};\nfunction has(type) {\n  return !!TYPE_MAPPING[type];\n}\nfunction get() {\n  var type = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'http';\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return TYPE_MAPPING[type](options);\n}\nfunction registerType(type, fn) {\n  TYPE_MAPPING[type] = fn;\n}\nvar DataAccessHelper = {\n  get: get,\n  has: has,\n  registerType: registerType\n};\n\nexport { DataAccessHelper as default, get, has, registerType };\n","import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';\nimport _classCallCheck from '@babel/runtime/helpers/classCallCheck';\nimport _createClass from '@babel/runtime/helpers/createClass';\nimport { vec3, mat4, glMatrix } from 'gl-matrix';\nimport { a as areMatricesEqual } from './Math/index.js';\nimport { IDENTITY } from './Math/Constants.js';\n\nvar NoOp = function NoOp(v) {\n  return v;\n};\n\nvar EPSILON = 1e-6;\n\nvar Transform = /*#__PURE__*/function () {\n  function Transform() {\n    var useDegree = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n\n    _classCallCheck(this, Transform);\n\n    this.matrix = mat4.identity(new Float64Array(16));\n    this.tmp = new Float64Array(3);\n    this.angleConv = useDegree ? glMatrix.toRadian : NoOp;\n  }\n\n  _createClass(Transform, [{\n    key: \"rotateFromDirections\",\n    value: function rotateFromDirections(originDirection, targetDirection) {\n      var src = new Float64Array(3);\n      var dst = new Float64Array(3);\n      var transf = new Float64Array(16);\n      vec3.set(src, originDirection[0], originDirection[1], originDirection[2]);\n      vec3.set(dst, targetDirection[0], targetDirection[1], targetDirection[2]);\n      vec3.normalize(src, src);\n      vec3.normalize(dst, dst);\n      var cosAlpha = vec3.dot(src, dst);\n\n      if (cosAlpha >= 1) {\n        return this;\n      }\n\n      vec3.cross(this.tmp, src, dst);\n\n      if (vec3.length(this.tmp) < EPSILON) {\n        // cross product is 0, so pick arbitrary axis perpendicular\n        // to originDirection.\n        vec3.cross(this.tmp, [1, 0, 0], originDirection);\n\n        if (vec3.length(this.tmp) < EPSILON) {\n          vec3.cross(this.tmp, [0, 1, 0], originDirection);\n        }\n      }\n\n      mat4.fromRotation(transf, Math.acos(cosAlpha), this.tmp);\n      mat4.multiply(this.matrix, this.matrix, transf);\n      return this;\n    }\n  }, {\n    key: \"rotate\",\n    value: function rotate(angle, axis) {\n      vec3.set.apply(vec3, [this.tmp].concat(_toConsumableArray(axis)));\n      vec3.normalize(this.tmp, this.tmp);\n      mat4.rotate(this.matrix, this.matrix, this.angleConv(angle), this.tmp);\n      return this;\n    }\n  }, {\n    key: \"rotateX\",\n    value: function rotateX(angle) {\n      mat4.rotateX(this.matrix, this.matrix, this.angleConv(angle));\n      return this;\n    }\n  }, {\n    key: \"rotateY\",\n    value: function rotateY(angle) {\n      mat4.rotateY(this.matrix, this.matrix, this.angleConv(angle));\n      return this;\n    }\n  }, {\n    key: \"rotateZ\",\n    value: function rotateZ(angle) {\n      mat4.rotateZ(this.matrix, this.matrix, this.angleConv(angle));\n      return this;\n    }\n  }, {\n    key: \"translate\",\n    value: function translate(x, y, z) {\n      vec3.set(this.tmp, x, y, z);\n      mat4.translate(this.matrix, this.matrix, this.tmp);\n      return this;\n    }\n  }, {\n    key: \"scale\",\n    value: function scale(sx, sy, sz) {\n      vec3.set(this.tmp, sx, sy, sz);\n      mat4.scale(this.matrix, this.matrix, this.tmp);\n      return this;\n    }\n  }, {\n    key: \"multiply\",\n    value: function multiply(mat4x4) {\n      mat4.multiply(this.matrix, this.matrix, mat4x4);\n      return this;\n    }\n  }, {\n    key: \"multiply3x3\",\n    value: function multiply3x3(mat3x3) {\n      mat4.multiply(this.matrix, this.matrix, [mat3x3[0], mat3x3[1], mat3x3[2], 0, mat3x3[3], mat3x3[4], mat3x3[5], 0, mat3x3[6], mat3x3[7], mat3x3[8], 0, 0, 0, 0, 1]);\n      return this;\n    }\n  }, {\n    key: \"invert\",\n    value: function invert() {\n      mat4.invert(this.matrix, this.matrix);\n      return this;\n    }\n  }, {\n    key: \"identity\",\n    value: function identity() {\n      mat4.identity(this.matrix);\n      return this;\n    } //-----------\n\n  }, {\n    key: \"apply\",\n    value: function apply(typedArray) {\n      var offset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      var nbIterations = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;\n\n      if (areMatricesEqual(IDENTITY, this.matrix)) {\n        // Make sure we can chain apply...\n        return this;\n      }\n\n      var size = nbIterations === -1 ? typedArray.length : offset + nbIterations * 3;\n\n      for (var i = offset; i < size; i += 3) {\n        vec3.set(this.tmp, typedArray[i], typedArray[i + 1], typedArray[i + 2]);\n        vec3.transformMat4(this.tmp, this.tmp, this.matrix);\n        typedArray[i] = this.tmp[0];\n        typedArray[i + 1] = this.tmp[1];\n        typedArray[i + 2] = this.tmp[2];\n      } // Make sure we can chain apply...\n\n\n      return this;\n    }\n  }, {\n    key: \"getMatrix\",\n    value: function getMatrix() {\n      return this.matrix;\n    }\n  }, {\n    key: \"setMatrix\",\n    value: function setMatrix(mat4x4) {\n      if (!!mat4x4 && mat4x4.length === 16) {\n        mat4.copy(this.matrix, mat4x4);\n      }\n\n      return this;\n    }\n  }]);\n\n  return Transform;\n}();\n\nfunction buildFromDegree() {\n  return new Transform(true);\n}\n\nfunction buildFromRadian() {\n  return new Transform(false);\n}\n\nvar vtkMatrixBuilder = {\n  buildFromDegree: buildFromDegree,\n  buildFromRadian: buildFromRadian\n};\n\nexport { vtkMatrixBuilder as default };\n","import _defineProperty from '@babel/runtime/helpers/defineProperty';\nimport _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';\nimport macro from '../../macros.js';\nimport vtkDataArray from './DataArray.js';\nimport { VtkDataTypes } from './DataArray/Constants.js';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n// Global methods\n// ----------------------------------------------------------------------------\n\nfunction extractCellSizes(cellArray) {\n  var currentIdx = 0;\n  return cellArray.filter(function (value, index) {\n    if (index === currentIdx) {\n      currentIdx += value + 1;\n      return true;\n    }\n\n    return false;\n  });\n}\n\nfunction getNumberOfCells(cellArray) {\n  var cellId = 0;\n\n  for (var cellArrayIndex = 0; cellArrayIndex < cellArray.length;) {\n    cellArrayIndex += cellArray[cellArrayIndex] + 1;\n    cellId++;\n  }\n\n  return cellId;\n} // ----------------------------------------------------------------------------\n// Static API\n// ----------------------------------------------------------------------------\n\n\nvar STATIC = {\n  extractCellSizes: extractCellSizes,\n  getNumberOfCells: getNumberOfCells\n}; // ----------------------------------------------------------------------------\n// vtkCellArray methods\n// ----------------------------------------------------------------------------\n\nfunction vtkCellArray(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkCellArray');\n\n  publicAPI.getNumberOfCells = function (recompute) {\n    if (model.numberOfCells !== undefined && !recompute) {\n      return model.numberOfCells;\n    }\n\n    if (model.cellSizes) {\n      model.numberOfCells = model.cellSizes.length;\n    } else {\n      model.numberOfCells = getNumberOfCells(publicAPI.getData());\n    }\n\n    return model.numberOfCells;\n  };\n\n  publicAPI.getCellSizes = function (recompute) {\n    if (model.cellSizes !== undefined && !recompute) {\n      return model.cellSizes;\n    }\n\n    model.cellSizes = extractCellSizes(publicAPI.getData());\n    return model.cellSizes;\n  };\n\n  var superSetData = publicAPI.setData;\n\n  publicAPI.setData = function (typedArray) {\n    superSetData(typedArray, 1);\n    model.numberOfCells = undefined;\n    model.cellSizes = undefined;\n  };\n\n  publicAPI.getCell = function (loc) {\n    var cellLoc = loc;\n    var numberOfPoints = model.values[cellLoc++];\n    return model.values.subarray(cellLoc, cellLoc + numberOfPoints);\n  };\n\n  var superInitialize = publicAPI.initialize;\n\n  publicAPI.initialize = function () {\n    superInitialize(); // Set to undefined to ensure insertNextCell works correctly\n\n    model.numberOfCells = undefined;\n    model.cellSizes = undefined;\n  };\n\n  publicAPI.insertNextCell = function (cellPointIds) {\n    var cellId = publicAPI.getNumberOfCells();\n    publicAPI.insertNextTuples([cellPointIds.length].concat(_toConsumableArray(cellPointIds))); // By computing the number of cells earlier, we made sure that numberOfCells is defined\n\n    ++model.numberOfCells;\n\n    if (model.cellSizes != null) {\n      model.cellSizes.push(cellPointIds.length);\n    }\n\n    return cellId;\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nfunction defaultValues(initialValues) {\n  return _objectSpread({\n    empty: true,\n    numberOfComponents: 1,\n    dataType: VtkDataTypes.UNSIGNED_INT\n  }, initialValues);\n} // ----------------------------------------------------------------------------\n\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  vtkDataArray.extend(publicAPI, model, defaultValues(initialValues));\n  vtkCellArray(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkCellArray'); // ----------------------------------------------------------------------------\n\nvar vtkCellArray$1 = _objectSpread({\n  newInstance: newInstance,\n  extend: extend\n}, STATIC);\n\nexport { STATIC, vtkCellArray$1 as default, extend, newInstance };\n","import macro from '../../macros.js';\nimport vtkDataArray from './DataArray.js';\nimport { VtkDataTypes } from './DataArray/Constants.js';\n\nvar vtkErrorMacro = macro.vtkErrorMacro;\nvar INVALID_BOUNDS = [1, -1, 1, -1, 1, -1]; // ----------------------------------------------------------------------------\n// vtkPoints methods\n// ----------------------------------------------------------------------------\n\nfunction vtkPoints(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkPoints'); // Forwarding methods\n\n  publicAPI.getNumberOfPoints = publicAPI.getNumberOfTuples;\n\n  publicAPI.setNumberOfPoints = function (nbPoints) {\n    var dimension = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3;\n\n    if (publicAPI.getNumberOfPoints() !== nbPoints) {\n      model.size = nbPoints * dimension;\n      model.values = macro.newTypedArray(model.dataType, model.size);\n      publicAPI.setNumberOfComponents(dimension);\n      publicAPI.modified();\n    }\n  };\n\n  publicAPI.setPoint = function (idx) {\n    for (var _len = arguments.length, xyz = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      xyz[_key - 1] = arguments[_key];\n    }\n\n    publicAPI.setTuple(idx, xyz);\n  };\n\n  publicAPI.getPoint = publicAPI.getTuple;\n\n  publicAPI.insertNextPoint = function (x, y, z) {\n    return publicAPI.insertNextTuple([x, y, z]);\n  };\n\n  publicAPI.getBounds = function () {\n    if (publicAPI.getNumberOfComponents() === 3) {\n      var _xRange = publicAPI.getRange(0);\n\n      model.bounds[0] = _xRange[0];\n      model.bounds[1] = _xRange[1];\n\n      var _yRange = publicAPI.getRange(1);\n\n      model.bounds[2] = _yRange[0];\n      model.bounds[3] = _yRange[1];\n      var zRange = publicAPI.getRange(2);\n      model.bounds[4] = zRange[0];\n      model.bounds[5] = zRange[1];\n      return model.bounds;\n    }\n\n    if (publicAPI.getNumberOfComponents() !== 2) {\n      vtkErrorMacro(\"getBounds called on an array with components of\\n        \".concat(publicAPI.getNumberOfComponents()));\n      return INVALID_BOUNDS;\n    }\n\n    var xRange = publicAPI.getRange(0);\n    model.bounds[0] = xRange[0];\n    model.bounds[1] = xRange[1];\n    var yRange = publicAPI.getRange(1);\n    model.bounds[2] = yRange[0];\n    model.bounds[3] = yRange[1];\n    model.bounds[4] = 0;\n    model.bounds[5] = 0;\n    return model.bounds;\n  }; // Trigger the computation of bounds\n\n\n  publicAPI.computeBounds = publicAPI.getBounds; // Initialize\n\n  publicAPI.setNumberOfComponents(model.numberOfComponents < 2 ? 3 : model.numberOfComponents);\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  empty: true,\n  numberOfComponents: 3,\n  dataType: VtkDataTypes.FLOAT,\n  bounds: [1, -1, 1, -1, 1, -1]\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  vtkDataArray.extend(publicAPI, model, initialValues);\n  vtkPoints(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkPoints'); // ----------------------------------------------------------------------------\n\nvar vtkPoints$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { vtkPoints$1 as default, extend, newInstance };\n","import macro from '../../macros.js';\nimport { u as uninitializeBounds } from '../Core/Math/index.js';\nimport vtkPoints from '../Core/Points.js';\n\n// vtkCell methods\n// ----------------------------------------------------------------------------\n\nfunction vtkCell(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkCell');\n\n  publicAPI.initialize = function (points) {\n    var pointIdsList = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n    if (!pointIdsList) {\n      model.points = points;\n      model.pointsIds = new Array(points.getNumberOfPoints());\n\n      for (var i = points.getNumberOfPoints() - 1; i >= 0; --i) {\n        model.pointsIds[i] = i;\n      }\n    } else {\n      model.pointsIds = pointIdsList;\n      var triangleData = model.points.getData();\n\n      if (triangleData.length !== 3 * model.pointsIds.length) {\n        triangleData = macro.newTypedArray(points.getDataType(), 3 * model.pointsIds.length);\n      }\n\n      var pointsData = points.getData();\n      model.pointsIds.forEach(function (pointId, index) {\n        // const start = 3 * pointId;\n        // pointsData.set(p.subarray(start, start + 3), 3 * index);\n        var pointOffset = 3 * pointId;\n        var trianglePointOffset = 3 * index;\n        triangleData[trianglePointOffset] = pointsData[pointOffset];\n        triangleData[++trianglePointOffset] = pointsData[++pointOffset];\n        triangleData[++trianglePointOffset] = pointsData[++pointOffset];\n      });\n      model.points.setData(triangleData);\n    }\n  };\n\n  publicAPI.getBounds = function () {\n    var nbPoints = model.points.getNumberOfPoints();\n    var x = [];\n\n    if (nbPoints) {\n      model.points.getPoint(0, x);\n      model.bounds[0] = x[0];\n      model.bounds[1] = x[0];\n      model.bounds[2] = x[1];\n      model.bounds[3] = x[1];\n      model.bounds[4] = x[2];\n      model.bounds[5] = x[2];\n\n      for (var i = 1; i < nbPoints; i++) {\n        model.points.getPoint(i, x);\n        model.bounds[0] = x[0] < model.bounds[0] ? x[0] : model.bounds[0];\n        model.bounds[1] = x[0] > model.bounds[1] ? x[0] : model.bounds[1];\n        model.bounds[2] = x[1] < model.bounds[2] ? x[1] : model.bounds[2];\n        model.bounds[3] = x[1] > model.bounds[3] ? x[1] : model.bounds[3];\n        model.bounds[4] = x[2] < model.bounds[4] ? x[2] : model.bounds[4];\n        model.bounds[5] = x[2] > model.bounds[5] ? x[2] : model.bounds[5];\n      }\n    } else {\n      uninitializeBounds(model.bounds);\n    }\n\n    return model.bounds;\n  };\n\n  publicAPI.getLength2 = function () {\n    publicAPI.getBounds();\n    var length = 0.0;\n    var diff = 0;\n\n    for (var i = 0; i < 3; i++) {\n      diff = model.bounds[2 * i + 1] - model.bounds[2 * i];\n      length += diff * diff;\n    }\n\n    return length;\n  };\n\n  publicAPI.getParametricDistance = function (pcoords) {\n    var pDist;\n    var pDistMax = 0.0;\n\n    for (var i = 0; i < 3; i++) {\n      if (pcoords[i] < 0.0) {\n        pDist = -pcoords[i];\n      } else if (pcoords[i] > 1.0) {\n        pDist = pcoords[i] - 1.0;\n      } else {\n        // inside the cell in the parametric direction\n        pDist = 0.0;\n      }\n\n      if (pDist > pDistMax) {\n        pDistMax = pDist;\n      }\n    }\n\n    return pDistMax;\n  };\n\n  publicAPI.getNumberOfPoints = function () {\n    return model.points.getNumberOfPoints();\n  };\n\n  publicAPI.deepCopy = function (cell) {\n    cell.initialize(model.points, model.pointsIds);\n  };\n\n  publicAPI.getCellDimension = function () {}; // virtual\n\n\n  publicAPI.intersectWithLine = function (p1, p2, tol, t, x, pcoords, subId) {}; // virtual\n\n\n  publicAPI.evaluatePosition = function (x, closestPoint, subId, pcoords, dist2, weights) {\n    macro.vtkErrorMacro('vtkCell.evaluatePosition is not implemented.');\n  }; // virtual\n\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  bounds: [-1, -1, -1, -1, -1, -1],\n  pointsIds: []\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  macro.obj(publicAPI, model);\n\n  if (!model.points) {\n    model.points = vtkPoints.newInstance();\n  }\n\n  macro.get(publicAPI, model, ['points', 'pointsIds']);\n  vtkCell(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkCell'); // ----------------------------------------------------------------------------\n\nvar vtkCell$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { vtkCell$1 as default, extend, newInstance };\n","import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';\nimport macro from '../../macros.js';\nimport vtkCell from './Cell.js';\n\n// Global methods\n// ----------------------------------------------------------------------------\n\nvar InitLink = {\n  ncells: 0,\n  cells: null\n};\n\nfunction resize(model, sz) {\n  var newSize = sz;\n\n  if (sz >= model.array.length) {\n    newSize += model.array.length;\n  }\n\n  while (newSize > model.array.length) {\n    model.array.push({\n      ncells: 0,\n      cells: null\n    });\n  }\n\n  model.array.length = newSize;\n} // ----------------------------------------------------------------------------\n// vtkCellLinks methods\n// ----------------------------------------------------------------------------\n\n\nfunction vtkCellLinks(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkCellLinks');\n  /**\n   * Build the link list array. All subclasses of vtkAbstractCellLinks\n   * must support this method.\n   */\n\n  publicAPI.buildLinks = function (data) {\n    var numPts = data.getPoints().getNumberOfPoints();\n    var numCells = data.getNumberOfCells(); // fill out lists with number of references to cells\n\n    var linkLoc = new Uint32Array(numPts); // Use fast path if polydata\n\n    if (data.isA('vtkPolyData')) {\n      // traverse data to determine number of uses of each point\n      for (var cellId = 0; cellId < numCells; ++cellId) {\n        var _data$getCellPoints = data.getCellPoints(cellId),\n            cellPointIds = _data$getCellPoints.cellPointIds;\n\n        cellPointIds.forEach(function (cellPointId) {\n          publicAPI.incrementLinkCount(cellPointId);\n        });\n      } // now allocate storage for the links\n\n\n      publicAPI.allocateLinks(numPts);\n      model.maxId = numPts - 1;\n\n      var _loop = function _loop(_cellId) {\n        var _data$getCellPoints2 = data.getCellPoints(_cellId),\n            cellPointIds = _data$getCellPoints2.cellPointIds;\n\n        cellPointIds.forEach(function (cellPointId) {\n          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, _cellId);\n        });\n      };\n\n      for (var _cellId = 0; _cellId < numCells; ++_cellId) {\n        _loop(_cellId);\n      }\n    } // any other type of dataset\n    else {\n      // traverse data to determine number of uses of each point\n      for (var _cellId2 = 0; _cellId2 < numCells; _cellId2++) {\n        // TODO: Currently not supported: const cell = data.getCell(cellId);\n        var cell = vtkCell.newInstance();\n        cell.getPointsIds().forEach(function (cellPointId) {\n          publicAPI.incrementLinkCount(cellPointId);\n        });\n      } // now allocate storage for the links\n\n\n      publicAPI.allocateLinks(numPts);\n      model.maxId = numPts - 1;\n\n      var _loop2 = function _loop2(_cellId3) {\n        // TODO: Currently not supported: const cell = data.getCell(cellId);\n        var cell = vtkCell.newInstance();\n        cell.getPointsIds().forEach(function (cellPointId) {\n          publicAPI.insertCellReference(cellPointId, linkLoc[cellPointId]++, _cellId3);\n        });\n      };\n\n      for (var _cellId3 = 0; _cellId3 < numCells; ++_cellId3) {\n        _loop2(_cellId3);\n      }\n    } // end else\n\n  };\n  /**\n   * Build the link list array with a provided connectivity array.\n   */\n  // publicAPI.buildLinks = (data, connectivity) => {};\n\n  /**\n   * Allocate the specified number of links (i.e., number of points) that\n   * will be built.\n   */\n\n\n  publicAPI.allocate = function (numLinks) {\n    var ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    model.array = Array(numLinks).fill().map(function () {\n      return {\n        ncells: 0,\n        cells: null\n      };\n    });\n    model.extend = ext;\n    model.maxId = -1;\n  };\n\n  publicAPI.initialize = function () {\n    model.array = null;\n  };\n  /**\n   * Get a link structure given a point id.\n   */\n\n\n  publicAPI.getLink = function (ptId) {\n    return model.array[ptId];\n  };\n  /**\n   * Get the number of cells using the point specified by ptId.\n   */\n\n\n  publicAPI.getNcells = function (ptId) {\n    return model.array[ptId].ncells;\n  };\n  /**\n   * Return a list of cell ids using the point.\n   */\n\n\n  publicAPI.getCells = function (ptId) {\n    return model.array[ptId].cells;\n  };\n  /**\n   * Insert a new point into the cell-links data structure. The size parameter\n   * is the initial size of the list.\n   */\n\n\n  publicAPI.insertNextPoint = function (numLinks) {\n    model.array.push({\n      ncells: numLinks,\n      cells: Array(numLinks)\n    });\n    ++model.maxId;\n  };\n  /**\n   * Insert a cell id into the list of cells (at the end) using the cell id\n   * provided. (Make sure to extend the link list (if necessary) using the\n   * method resizeCellList().)\n   */\n\n\n  publicAPI.insertNextCellReference = function (ptId, cellId) {\n    model.array[ptId].cells[model.array[ptId].ncells++] = cellId;\n  };\n  /**\n   * Delete point (and storage) by destroying links to using cells.\n   */\n\n\n  publicAPI.deletePoint = function (ptId) {\n    model.array[ptId].ncells = 0;\n    model.array[ptId].cells = null;\n  };\n  /**\n   * Delete the reference to the cell (cellId) from the point (ptId). This\n   * removes the reference to the cellId from the cell list, but does not\n   * resize the list (recover memory with resizeCellList(), if necessary).\n   */\n\n\n  publicAPI.removeCellReference = function (cellId, ptId) {\n    model.array[ptId].cells = model.array[ptId].cells.filter(function (cell) {\n      return cell !== cellId;\n    });\n    model.array[ptId].ncells = model.array[ptId].cells.length;\n  };\n  /**\n   * Add the reference to the cell (cellId) from the point (ptId). This\n   * adds a reference to the cellId from the cell list, but does not resize\n   * the list (extend memory with resizeCellList(), if necessary).\n   */\n\n\n  publicAPI.addCellReference = function (cellId, ptId) {\n    model.array[ptId].cells[model.array[ptId].ncells++] = cellId;\n  };\n  /**\n   * Change the length of a point's link list (i.e., list of cells using a\n   * point) by the size specified.\n   */\n\n\n  publicAPI.resizeCellList = function (ptId, size) {\n    model.array[ptId].cells.length = size;\n  };\n  /**\n   * Reclaim any unused memory.\n   */\n\n\n  publicAPI.squeeze = function () {\n    resize(model, model.maxId + 1);\n  };\n  /**\n   * Reset to a state of no entries without freeing the memory.\n   */\n\n\n  publicAPI.reset = function () {\n    model.maxId = -1;\n  };\n  /**\n   * Standard DeepCopy method.  Since this object contains no reference\n   * to other objects, there is no ShallowCopy.\n   */\n\n\n  publicAPI.deepCopy = function (src) {\n    model.array = _toConsumableArray(src.array);\n    model.extend = src.extend;\n    model.maxId = src.maxId;\n  };\n  /**\n   * Increment the count of the number of cells using the point.\n   */\n\n\n  publicAPI.incrementLinkCount = function (ptId) {\n    ++model.array[ptId].ncells;\n  };\n\n  publicAPI.allocateLinks = function (n) {\n    for (var i = 0; i < n; ++i) {\n      model.array[i].cells = new Array(model.array[i].ncells);\n    }\n  };\n  /**\n   * Insert a cell id into the list of cells using the point.\n   */\n\n\n  publicAPI.insertCellReference = function (ptId, pos, cellId) {\n    model.array[ptId].cells[pos] = cellId;\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  array: null,\n  // pointer to data\n  maxId: 0,\n  // maximum index inserted thus far\n  extend: 0 // grow array by this point\n\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  macro.obj(publicAPI, model);\n  vtkCellLinks(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkCellLinks'); // ----------------------------------------------------------------------------\n\nvar vtkCellLinks$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { InitLink, vtkCellLinks$1 as default, extend, newInstance };\n","var CellType = {\n  // Linear cells\n  VTK_EMPTY_CELL: 0,\n  VTK_VERTEX: 1,\n  VTK_POLY_VERTEX: 2,\n  VTK_LINE: 3,\n  VTK_POLY_LINE: 4,\n  VTK_TRIANGLE: 5,\n  VTK_TRIANGLE_STRIP: 6,\n  VTK_POLYGON: 7,\n  VTK_PIXEL: 8,\n  VTK_QUAD: 9,\n  VTK_TETRA: 10,\n  VTK_VOXEL: 11,\n  VTK_HEXAHEDRON: 12,\n  VTK_WEDGE: 13,\n  VTK_PYRAMID: 14,\n  VTK_PENTAGONAL_PRISM: 15,\n  VTK_HEXAGONAL_PRISM: 16,\n  // Quadratic, isoparametric cells\n  VTK_QUADRATIC_EDGE: 21,\n  VTK_QUADRATIC_TRIANGLE: 22,\n  VTK_QUADRATIC_QUAD: 23,\n  VTK_QUADRATIC_POLYGON: 36,\n  VTK_QUADRATIC_TETRA: 24,\n  VTK_QUADRATIC_HEXAHEDRON: 25,\n  VTK_QUADRATIC_WEDGE: 26,\n  VTK_QUADRATIC_PYRAMID: 27,\n  VTK_BIQUADRATIC_QUAD: 28,\n  VTK_TRIQUADRATIC_HEXAHEDRON: 29,\n  VTK_QUADRATIC_LINEAR_QUAD: 30,\n  VTK_QUADRATIC_LINEAR_WEDGE: 31,\n  VTK_BIQUADRATIC_QUADRATIC_WEDGE: 32,\n  VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON: 33,\n  VTK_BIQUADRATIC_TRIANGLE: 34,\n  // Cubic, isoparametric cell\n  VTK_CUBIC_LINE: 35,\n  // Special class of cells formed by convex group of points\n  VTK_CONVEX_POINT_SET: 41,\n  // Polyhedron cell (consisting of polygonal faces)\n  VTK_POLYHEDRON: 42,\n  // Higher order cells in parametric form\n  VTK_PARAMETRIC_CURVE: 51,\n  VTK_PARAMETRIC_SURFACE: 52,\n  VTK_PARAMETRIC_TRI_SURFACE: 53,\n  VTK_PARAMETRIC_QUAD_SURFACE: 54,\n  VTK_PARAMETRIC_TETRA_REGION: 55,\n  VTK_PARAMETRIC_HEX_REGION: 56,\n  // Higher order cells\n  VTK_HIGHER_ORDER_EDGE: 60,\n  VTK_HIGHER_ORDER_TRIANGLE: 61,\n  VTK_HIGHER_ORDER_QUAD: 62,\n  VTK_HIGHER_ORDER_POLYGON: 63,\n  VTK_HIGHER_ORDER_TETRAHEDRON: 64,\n  VTK_HIGHER_ORDER_WEDGE: 65,\n  VTK_HIGHER_ORDER_PYRAMID: 66,\n  VTK_HIGHER_ORDER_HEXAHEDRON: 67,\n  // Arbitrary order Lagrange elements (formulated separated from generic higher order cells)\n  VTK_LAGRANGE_CURVE: 68,\n  VTK_LAGRANGE_TRIANGLE: 69,\n  VTK_LAGRANGE_QUADRILATERAL: 70,\n  VTK_LAGRANGE_TETRAHEDRON: 71,\n  VTK_LAGRANGE_HEXAHEDRON: 72,\n  VTK_LAGRANGE_WEDGE: 73,\n  VTK_LAGRANGE_PYRAMID: 74,\n  VTK_NUMBER_OF_CELL_TYPES: 75\n}; // This list should contain the cell class names in\n// the same order as in CellType.\n\nvar CellTypesStrings = ['vtkEmptyCell', 'vtkVertex', 'vtkPolyVertex', 'vtkLine', 'vtkPolyLine', 'vtkTriangle', 'vtkTriangleStrip', 'vtkPolygon', 'vtkPixel', 'vtkQuad', 'vtkTetra', 'vtkVoxel', 'vtkHexahedron', 'vtkWedge', 'vtkPyramid', 'vtkPentagonalPrism', 'vtkHexagonalPrism', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkQuadraticEdge', 'vtkQuadraticTriangle', 'vtkQuadraticQuad', 'vtkQuadraticTetra', 'vtkQuadraticHexahedron', 'vtkQuadraticWedge', 'vtkQuadraticPyramid', 'vtkBiQuadraticQuad', 'vtkTriQuadraticHexahedron', 'vtkQuadraticLinearQuad', 'vtkQuadraticLinearWedge', 'vtkBiQuadraticQuadraticWedge', 'vtkBiQuadraticQuadraticHexahedron', 'vtkBiQuadraticTriangle', 'vtkCubicLine', 'vtkQuadraticPolygon', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkConvexPointSet', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkParametricCurve', 'vtkParametricSurface', 'vtkParametricTriSurface', 'vtkParametricQuadSurface', 'vtkParametricTetraRegion', 'vtkParametricHexRegion', 'UnknownClass', 'UnknownClass', 'UnknownClass', 'vtkHigherOrderEdge', 'vtkHigherOrderTriangle', 'vtkHigherOrderQuad', 'vtkHigherOrderPolygon', 'vtkHigherOrderTetrahedron', 'vtkHigherOrderWedge', 'vtkHigherOrderPyramid', 'vtkHigherOrderHexahedron'];\nvar Constants = {\n  CellType: CellType,\n  CellTypesStrings: CellTypesStrings\n};\n\nexport { CellType, CellTypesStrings, Constants as default };\n","import _defineProperty from '@babel/runtime/helpers/defineProperty';\nimport macro from '../../macros.js';\nimport { CellTypesStrings, CellType } from './CellTypes/Constants.js';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n// Global methods\n// ----------------------------------------------------------------------------\n\n/**\n * Given an int (as defined in vtkCellType.h) identifier for a class\n * return it's classname.\n */\n\nfunction getClassNameFromTypeId(typeId) {\n  return typeId < CellTypesStrings.length ? CellTypesStrings[typeId] : 'UnknownClass';\n}\n/**\n * Given a data object classname, return it's int identified (as\n * defined in vtkCellType.h)\n */\n\n\nfunction getTypeIdFromClassName(cellTypeString) {\n  return CellTypesStrings.findIndex(cellTypeString);\n}\n/**\n * This convenience method is a fast check to determine if a cell type\n * represents a linear or nonlinear cell.  This is generally much more\n * efficient than getting the appropriate vtkCell and checking its IsLinear\n * method.\n */\n\n\nfunction isLinear(type) {\n  return type < CellType.VTK_QUADRATIC_EDGE || type === CellType.VTK_CONVEX_POINT_SET || type === CellType.VTK_POLYHEDRON;\n}\n\nfunction hasSubCells(cellType) {\n  return cellType === CellType.VTK_TRIANGLE_STRIP || cellType === CellType.VTK_POLY_LINE || cellType === CellType.VTK_POLY_VERTEX;\n} // ----------------------------------------------------------------------------\n// Static API\n// ----------------------------------------------------------------------------\n\n\nvar STATIC = {\n  getClassNameFromTypeId: getClassNameFromTypeId,\n  getTypeIdFromClassName: getTypeIdFromClassName,\n  isLinear: isLinear,\n  hasSubCells: hasSubCells\n}; // ----------------------------------------------------------------------------\n// vtkCellTypes methods\n// ----------------------------------------------------------------------------\n\nfunction vtkCellTypes(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkCellTypes');\n  /**\n   * Allocate memory for this array. Delete old storage only if necessary.\n   */\n\n  publicAPI.allocate = function () {\n    var sz = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 512;\n    var ext = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1000;\n    model.size = sz > 0 ? sz : 1;\n    model.extend = ext > 0 ? ext : 1;\n    model.maxId = -1;\n    model.typeArray = new Uint8Array(sz);\n    model.locationArray = new Uint32Array(sz);\n  };\n  /**\n   * Add a cell at specified id.\n   */\n\n\n  publicAPI.insertCell = function (cellId, type, loc) {\n    model.typeArray[cellId] = type;\n    model.locationArray[cellId] = loc;\n\n    if (cellId > model.maxId) {\n      model.maxId = cellId;\n    }\n  };\n  /**\n   * Add a cell to the object in the next available slot.\n   */\n\n\n  publicAPI.insertNextCell = function (type, loc) {\n    publicAPI.insertCell(++model.maxId, type, loc);\n    return model.maxId;\n  };\n  /**\n   * Specify a group of cell types. This version is provided to maintain\n   * backwards compatibility and does a copy of the cellLocations\n   */\n\n\n  publicAPI.setCellTypes = function (ncells, cellTypes, cellLocations) {\n    model.size = ncells;\n    model.typeArray = cellTypes;\n    model.locationArray = cellLocations;\n    model.maxId = ncells - 1;\n  };\n  /**\n   * Return the location of the cell in the associated vtkCellArray.\n   */\n\n\n  publicAPI.getCellLocation = function (cellId) {\n    return model.locationArray[cellId];\n  };\n  /**\n   * Delete cell by setting to nullptr cell type.\n   */\n\n\n  publicAPI.deleteCell = function (cellId) {\n    model.typeArray[cellId] = CellType.VTK_EMPTY_CELL;\n  };\n  /**\n   * Return the number of types in the list.\n   */\n\n\n  publicAPI.getNumberOfTypes = function () {\n    return model.maxId + 1;\n  };\n  /**\n   * Return true if type specified is contained in list; false otherwise.\n   */\n\n\n  publicAPI.isType = function (type) {\n    var numTypes = publicAPI.getNumberOfTypes();\n\n    for (var i = 0; i < numTypes; ++i) {\n      if (type === publicAPI.getCellType(i)) {\n        return true;\n      }\n    }\n\n    return false;\n  };\n  /**\n   * Add the type specified to the end of the list. Range checking is performed.\n   */\n\n\n  publicAPI.insertNextType = function (type) {\n    return publicAPI.insertNextCell(type, -1);\n  };\n  /**\n   * Return the type of cell.\n   */\n\n\n  publicAPI.getCellType = function (cellId) {\n    return model.typeArray[cellId];\n  };\n  /**\n   * Reclaim any extra memory.\n   */\n  // TODO: publicAPI.squeeze = () =>  {};\n\n  /**\n   * Initialize object without releasing memory.\n   */\n\n\n  publicAPI.reset = function () {\n    model.maxId = -1;\n  };\n  /**\n   * Standard DeepCopy method.  Since this object contains no reference\n   * to other objects, there is no ShallowCopy.\n   */\n\n\n  publicAPI.deepCopy = function (src) {\n    publicAPI.allocate(src.getSize(), src.getExtend());\n    model.typeArray.set(src.getTypeArray());\n    model.locationArray.set(src.getLocationArray());\n    model.maxId = src.getMaxId();\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  // typeArray: null, // pointer to types array\n  // locationArray: null;   // pointer to array of offsets\n  size: 0,\n  // allocated size of data\n  maxId: -1,\n  // maximum index inserted thus far\n  extend: 1000 // grow array by this point\n\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  macro.obj(publicAPI, model);\n  macro.get(publicAPI, model, ['size', 'maxId', 'extend']);\n  macro.getArray(publicAPI, model, ['typeArray', 'locationArray']);\n  vtkCellTypes(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkCellTypes'); // ----------------------------------------------------------------------------\n\nvar vtkCellTypes$1 = _objectSpread({\n  newInstance: newInstance,\n  extend: extend\n}, STATIC);\n\nexport { STATIC, vtkCellTypes$1 as default, extend, newInstance };\n","var IntersectionState = {\n  NO_INTERSECTION: 0,\n  YES_INTERSECTION: 1,\n  ON_LINE: 2\n};\nvar Constants = {\n  IntersectionState: IntersectionState\n};\n\nexport { IntersectionState, Constants as default };\n","import _defineProperty from '@babel/runtime/helpers/defineProperty';\nimport macro from '../../macros.js';\nimport Constants from './Line/Constants.js';\nimport vtkCell from './Cell.js';\nimport { d as dot, f as distance2BetweenPoints, s as subtract, j as solveLinearSystem } from '../Core/Math/index.js';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\nvar IntersectionState = Constants.IntersectionState; // ----------------------------------------------------------------------------\n// Global methods\n// ----------------------------------------------------------------------------\n\nfunction distanceToLine(x, p1, p2) {\n  var closestPoint = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n  var outObj = {\n    t: Number.MIN_VALUE,\n    distance: 0\n  };\n  var p21 = [];\n  var closest; // Determine appropriate vector\n\n  p21[0] = p2[0] - p1[0];\n  p21[1] = p2[1] - p1[1];\n  p21[2] = p2[2] - p1[2]; // Get parametric location\n\n  var num = p21[0] * (x[0] - p1[0]) + p21[1] * (x[1] - p1[1]) + p21[2] * (x[2] - p1[2]);\n  var denom = dot(p21, p21); // trying to avoid an expensive fabs\n\n  var tolerance = 1e-5 * num;\n\n  if (denom !== 0.0) {\n    outObj.t = num / denom;\n  }\n\n  if (tolerance < 0.0) {\n    tolerance = -tolerance;\n  }\n\n  if (-tolerance < denom && denom < tolerance) {\n    closest = p1;\n  } else if (denom <= 0.0 || outObj.t < 0.0) {\n    // If parametric coordinate is within 0<=p<=1, then the point is closest to\n    // the line.  Otherwise, it's closest to a point at the end of the line.\n    closest = p1;\n  } else if (outObj.t > 1.0) {\n    closest = p2;\n  } else {\n    closest = p21;\n    p21[0] = p1[0] + outObj.t * p21[0];\n    p21[1] = p1[1] + outObj.t * p21[1];\n    p21[2] = p1[2] + outObj.t * p21[2];\n  }\n\n  if (closestPoint) {\n    closestPoint[0] = closest[0];\n    closestPoint[1] = closest[1];\n    closestPoint[2] = closest[2];\n  }\n\n  outObj.distance = distance2BetweenPoints(closest, x);\n  return outObj;\n}\n\nfunction intersection(a1, a2, b1, b2, u, v) {\n  var a21 = [];\n  var b21 = [];\n  var b1a1 = [];\n  u[0] = 0.0;\n  v[0] = 0.0; // Determine line vectors.\n\n  subtract(a2, a1, a21);\n  subtract(b2, b1, b21);\n  subtract(b1, a1, b1a1); // Compute the system (least squares) matrix.\n\n  var A = [dot(a21, a21), -dot(a21, b21), -dot(a21, b21), dot(b21, b21)]; // Compute the least squares system constant term.\n\n  var c = [];\n  c[0] = dot(a21, b1a1);\n  c[1] = -dot(b21, b1a1); // Solve the system of equations\n\n  if (solveLinearSystem(A, c, 2) === 0) {\n    // The lines are colinear. Therefore, one of the four endpoints is the\n    // point of closest approach\n    var minDist = Number.MAX_VALUE;\n    var p = [a1, a2, b1, b2];\n    var l1 = [b1, b1, a1, a1];\n    var l2 = [b2, b2, a2, a2];\n    var uv1 = [v[0], v[0], u[0], u[0]];\n    var uv2 = [u[0], u[0], v[0], v[0]];\n    var obj;\n\n    for (var i = 0; i < 4; i++) {\n      obj = distanceToLine(p[i], l1[i], l2[i]);\n\n      if (obj.distance < minDist) {\n        minDist = obj.distance;\n        uv1[i] = obj.t;\n        uv2[i] = i % 2;\n      }\n    }\n\n    return IntersectionState.ON_LINE;\n  }\n\n  u[0] = c[0];\n  v[0] = c[1]; // Check parametric coordinates for intersection.\n\n  if (u[0] >= 0.0 && u[0] <= 1.0 && v[0] >= 0.0 && v[0] <= 1.0) {\n    return IntersectionState.YES_INTERSECTION;\n  }\n\n  return IntersectionState.NO_INTERSECTION;\n} // ----------------------------------------------------------------------------\n// Static API\n// ----------------------------------------------------------------------------\n\n\nvar STATIC = {\n  distanceToLine: distanceToLine,\n  intersection: intersection\n}; // ----------------------------------------------------------------------------\n// vtkLine methods\n// ----------------------------------------------------------------------------\n\nfunction vtkLine(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkLine');\n\n  function isBetweenPoints(t) {\n    return t >= 0.0 && t <= 1.0;\n  }\n\n  publicAPI.getCellDimension = function () {\n    return 1;\n  };\n\n  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {\n    var outObj = {\n      intersect: 0,\n      t: Number.MAX_VALUE,\n      subId: 0,\n      betweenPoints: null\n    };\n    pcoords[1] = 0.0;\n    pcoords[2] = 0.0;\n    var projXYZ = [];\n    var a1 = [];\n    var a2 = [];\n    model.points.getPoint(0, a1);\n    model.points.getPoint(1, a2);\n    var u = [];\n    var v = [];\n    var intersect = intersection(p1, p2, a1, a2, u, v);\n    outObj.t = u[0];\n    outObj.betweenPoints = isBetweenPoints(outObj.t);\n    pcoords[0] = v[0];\n\n    if (intersect === IntersectionState.YES_INTERSECTION) {\n      // make sure we are within tolerance\n      for (var i = 0; i < 3; i++) {\n        x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);\n        projXYZ[i] = p1[i] + outObj.t * (p2[i] - p1[i]);\n      }\n\n      if (distance2BetweenPoints(x, projXYZ) <= tol * tol) {\n        outObj.intersect = 1;\n        return outObj;\n      }\n    } else {\n      var outDistance; // check to see if it lies within tolerance\n      // one of the parametric coords must be outside 0-1\n\n      if (outObj.t < 0.0) {\n        outDistance = distanceToLine(p1, a1, a2, x);\n\n        if (outDistance.distance <= tol * tol) {\n          outObj.t = 0.0;\n          outObj.intersect = 1;\n          outObj.betweenPoints = true; // Intersection is near p1\n\n          return outObj;\n        }\n\n        return outObj;\n      }\n\n      if (outObj.t > 1.0) {\n        outDistance = distanceToLine(p2, a1, a2, x);\n\n        if (outDistance.distance <= tol * tol) {\n          outObj.t = 1.0;\n          outObj.intersect = 1;\n          outObj.betweenPoints = true; // Intersection is near p2\n\n          return outObj;\n        }\n\n        return outObj;\n      }\n\n      if (pcoords[0] < 0.0) {\n        pcoords[0] = 0.0;\n        outDistance = distanceToLine(a1, p1, p2, x);\n        outObj.t = outDistance.t;\n\n        if (outDistance.distance <= tol * tol) {\n          outObj.intersect = 1;\n          return outObj;\n        }\n\n        return outObj;\n      }\n\n      if (pcoords[0] > 1.0) {\n        pcoords[0] = 1.0;\n        outDistance = distanceToLine(a2, p1, p2, x);\n        outObj.t = outDistance.t;\n\n        if (outDistance.distance <= tol * tol) {\n          outObj.intersect = 1;\n          return outObj;\n        }\n\n        return outObj;\n      }\n    }\n\n    return outObj;\n  };\n\n  publicAPI.evaluateLocation = function (pcoords, x, weights) {\n    var a1 = [];\n    var a2 = [];\n    model.points.getPoint(0, a1);\n    model.points.getPoint(1, a2);\n\n    for (var i = 0; i < 3; i++) {\n      x[i] = a1[i] + pcoords[0] * (a2[i] - a1[i]);\n    }\n\n    weights[0] = 1.0 - pcoords[0];\n    weights[1] = pcoords[0];\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  vtkCell.extend(publicAPI, model, initialValues);\n  vtkLine(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkLine'); // ----------------------------------------------------------------------------\n\nvar vtkLine$1 = _objectSpread(_objectSpread({\n  newInstance: newInstance,\n  extend: extend\n}, STATIC), Constants);\n\nexport { STATIC, vtkLine$1 as default, extend, newInstance };\n","import vtk from '../../vtk.js';\nimport macro from '../../macros.js';\nimport vtkDataSet from './DataSet.js';\nimport vtkPoints from '../Core/Points.js';\n\n// Global methods\n// ----------------------------------------------------------------------------\n// ----------------------------------------------------------------------------\n// vtkPointSet methods\n// ----------------------------------------------------------------------------\n\nfunction vtkPointSet(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkPointSet'); // Create empty points\n\n  if (!model.points) {\n    model.points = vtkPoints.newInstance();\n  } else {\n    model.points = vtk(model.points);\n  }\n\n  publicAPI.getNumberOfPoints = function () {\n    return model.points.getNumberOfPoints();\n  };\n\n  publicAPI.getBounds = function () {\n    return model.points.getBounds();\n  };\n\n  publicAPI.computeBounds = function () {\n    publicAPI.getBounds();\n  };\n\n  var superShallowCopy = publicAPI.shallowCopy;\n\n  publicAPI.shallowCopy = function (other) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    superShallowCopy(other, debug);\n    model.points = vtkPoints.newInstance();\n    model.points.shallowCopy(other.getPoints());\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {// points: null,\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance\n\n  vtkDataSet.extend(publicAPI, model, initialValues);\n  macro.setGet(publicAPI, model, ['points']); // Object specific methods\n\n  vtkPointSet(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkPointSet'); // ----------------------------------------------------------------------------\n\nvar vtkPointSet$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { vtkPointSet$1 as default, extend, newInstance };\n","import _defineProperty from '@babel/runtime/helpers/defineProperty';\nimport macro from '../../macros.js';\nimport vtkCell from './Cell.js';\nimport { d as dot, k as cross, m as normalize, o as multiplyAccumulate, f as distance2BetweenPoints, p as determinant2x2 } from '../Core/Math/index.js';\nimport vtkLine from './Line.js';\nimport vtkPlane from './Plane.js';\n\nfunction ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }\n\nfunction _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }\n// Global methods\n// ----------------------------------------------------------------------------\n\nfunction computeNormalDirection(v1, v2, v3, n) {\n  // order is important!!! maintain consistency with triangle vertex order\n  var ax = v3[0] - v2[0];\n  var ay = v3[1] - v2[1];\n  var az = v3[2] - v2[2];\n  var bx = v1[0] - v2[0];\n  var by = v1[1] - v2[1];\n  var bz = v1[2] - v2[2];\n  n[0] = ay * bz - az * by;\n  n[1] = az * bx - ax * bz;\n  n[2] = ax * by - ay * bx;\n}\n\nfunction computeNormal(v1, v2, v3, n) {\n  computeNormalDirection(v1, v2, v3, n);\n  var length = Math.sqrt(n[0] * n[0] + n[1] * n[1] + n[2] * n[2]);\n\n  if (length !== 0.0) {\n    n[0] /= length;\n    n[1] /= length;\n    n[2] /= length;\n  }\n}\n\nfunction intersectWithTriangle(p1, q1, r1, p2, q2, r2) {\n  var tolerance = arguments.length > 6 && arguments[6] !== undefined ? arguments[6] : 1e-6;\n  var coplanar = false;\n  var pt1 = [];\n  var pt2 = [];\n  var surfaceId = [];\n  var n1 = [];\n  var n2 = []; // Compute supporting plane normals.\n\n  computeNormal(p1, q1, r1, n1);\n  computeNormal(p2, q2, r2, n2);\n  var s1 = -dot(n1, p1);\n  var s2 = -dot(n2, p2); // Compute signed distances of points p1, q1, r1 from supporting\n  // plane of second triangle.\n\n  var dist1 = [dot(n2, p1) + s2, dot(n2, q1) + s2, dot(n2, r1) + s2]; // If signs of all points are the same, all the points lie on the\n  // same side of the supporting plane, and we can exit early.\n\n  if (dist1[0] * dist1[1] > tolerance && dist1[0] * dist1[2] > tolerance) {\n    // vtkDebugMacro(<<\"Same side supporting plane 1!\");\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    };\n  } // Do the same for p2, q2, r2 and supporting plane of first\n  // triangle.\n\n\n  var dist2 = [dot(n1, p2) + s1, dot(n1, q2) + s1, dot(n1, r2) + s1]; // If signs of all points are the same, all the points lie on the\n  // same side of the supporting plane, and we can exit early.\n\n  if (dist2[0] * dist2[1] > tolerance && dist2[0] * dist2[2] > tolerance) {\n    // vtkDebugMacro(<<\"Same side supporting plane 2!\");\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    };\n  } // Check for coplanarity of the supporting planes.\n\n\n  if (Math.abs(n1[0] - n2[0]) < 1e-9 && Math.abs(n1[1] - n2[1]) < 1e-9 && Math.abs(n1[2] - n2[2]) < 1e-9 && Math.abs(s1 - s2) < 1e-9) {\n    coplanar = true; // vtkDebugMacro(<<\"Coplanar!\");\n\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    };\n  } // There are more efficient ways to find the intersection line (if\n  // it exists), but this is clear enough.\n\n\n  var pts1 = [p1, q1, r1];\n  var pts2 = [p2, q2, r2]; // Find line of intersection (L = p + t*v) between two planes.\n\n  var n1n2 = dot(n1, n2);\n  var a = (s1 - s2 * n1n2) / (n1n2 * n1n2 - 1.0);\n  var b = (s2 - s1 * n1n2) / (n1n2 * n1n2 - 1.0);\n  var p = [a * n1[0] + b * n2[0], a * n1[1] + b * n2[1], a * n1[2] + b * n2[2]];\n  var v = cross(n1, n2, []);\n  normalize(v);\n  var index1 = 0;\n  var index2 = 0;\n  var t1 = [];\n  var t2 = [];\n  var ts1 = 50;\n  var ts2 = 50;\n\n  for (var i = 0; i < 3; i++) {\n    var id1 = i;\n    var id2 = (i + 1) % 3; // Find t coordinate on line of intersection between two planes.\n\n    var val1 = vtkPlane.intersectWithLine(pts1[id1], pts1[id2], p2, n2);\n\n    if (val1.intersection && val1.t > 0 - tolerance && val1.t < 1 + tolerance) {\n      if (val1.t < 1 + tolerance && val1.t > 1 - tolerance) {\n        ts1 = index1;\n      }\n\n      t1[index1++] = dot(val1.x, v) - dot(p, v);\n    }\n\n    var val2 = vtkPlane.intersectWithLine(pts2[id1], pts2[id2], p1, n1);\n\n    if (val2.intersection && val2.t > 0 - tolerance && val2.t < 1 + tolerance) {\n      if (val2.t < 1 + tolerance && val2.t > 1 - tolerance) {\n        ts2 = index2;\n      }\n\n      t2[index2++] = dot(val2.x, v) - dot(p, v);\n    }\n  } // If the value of the index is greater than 2, the intersecting point\n  // actually is intersected by all three edges. In this case, set the two\n  // edges to the two edges where the intersecting point is not the end point\n\n\n  if (index1 > 2) {\n    index1--; // swap\n\n    var t12 = t1[2];\n    t1[2] = t1[ts1];\n    t1[ts1] = t12;\n  }\n\n  if (index2 > 2) {\n    index2--;\n    var t22 = t2[2];\n    t2[2] = t2[ts2];\n    t2[ts2] = t22;\n  } // Check if only one edge or all edges intersect the supporting\n  // planes intersection.\n\n\n  if (index1 !== 2 || index2 !== 2) {\n    // vtkDebugMacro(<<\"Only one edge intersecting!\");\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    };\n  } // Check for NaNs\n\n\n  if (Number.isNaN(t1[0]) || Number.isNaN(t1[1]) || Number.isNaN(t2[0]) || Number.isNaN(t2[1])) {\n    // vtkWarningMacro(<<\"NaNs!\");\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    };\n  }\n\n  if (t1[0] > t1[1]) {\n    // swap\n    var t11 = t1[1];\n    t1[1] = t1[0];\n    t1[0] = t11;\n  }\n\n  if (t2[0] > t2[1]) {\n    // swap\n    var t21 = t2[1];\n    t2[1] = t2[0];\n    t2[0] = t21;\n  } // Handle the different interval configuration cases.\n\n\n  var tt1;\n  var tt2;\n\n  if (t1[1] < t2[0] || t2[1] < t1[0]) {\n    // vtkDebugMacro(<<\"No Overlap!\");\n    return {\n      intersect: false,\n      coplanar: coplanar,\n      pt1: pt1,\n      pt2: pt2,\n      surfaceId: surfaceId\n    }; // No overlap\n  }\n\n  if (t1[0] < t2[0]) {\n    if (t1[1] < t2[1]) {\n      // First point on surface 2, second point on surface 1\n      surfaceId[0] = 2;\n      surfaceId[1] = 1;\n      tt1 = t2[0];\n      tt2 = t1[1];\n    } else {\n      // Both points belong to lines on surface 2\n      surfaceId[0] = 2;\n      surfaceId[1] = 2;\n      tt1 = t2[0];\n      tt2 = t2[1];\n    }\n  } // t1[0] >= t2[0]\n  else if (t1[1] < t2[1]) {\n    // Both points belong to lines on surface 1\n    surfaceId[0] = 1;\n    surfaceId[1] = 1;\n    tt1 = t1[0];\n    tt2 = t1[1];\n  } else {\n    // First point on surface 1, second point on surface 2\n    surfaceId[0] = 1;\n    surfaceId[1] = 2;\n    tt1 = t1[0];\n    tt2 = t2[1];\n  } // Create actual intersection points.\n\n\n  multiplyAccumulate(p, v, tt1, pt1);\n  multiplyAccumulate(p, v, tt2, pt2);\n  return {\n    intersect: true,\n    coplanar: coplanar,\n    pt1: pt1,\n    pt2: pt2,\n    surfaceId: surfaceId\n  };\n} // ----------------------------------------------------------------------------\n// Static API\n// ----------------------------------------------------------------------------\n\n\nvar STATIC = {\n  computeNormalDirection: computeNormalDirection,\n  computeNormal: computeNormal,\n  intersectWithTriangle: intersectWithTriangle\n}; // ----------------------------------------------------------------------------\n// vtkTriangle methods\n// ----------------------------------------------------------------------------\n\nfunction vtkTriangle(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkTriangle');\n\n  publicAPI.getCellDimension = function () {\n    return 2;\n  };\n\n  publicAPI.intersectWithLine = function (p1, p2, tol, x, pcoords) {\n    var outObj = {\n      subId: 0,\n      t: Number.MAX_VALUE,\n      intersect: 0,\n      betweenPoints: false\n    };\n    pcoords[2] = 0.0;\n    var closestPoint = [];\n    var tol2 = tol * tol; // Get normal for triangle\n\n    var pt1 = [];\n    var pt2 = [];\n    var pt3 = [];\n    model.points.getPoint(0, pt1);\n    model.points.getPoint(1, pt2);\n    model.points.getPoint(2, pt3);\n    var n = [];\n    var weights = [];\n    computeNormal(pt1, pt2, pt3, n);\n\n    if (n[0] !== 0 || n[1] !== 0 || n[2] !== 0) {\n      // Intersect plane of triangle with line\n      var plane = vtkPlane.intersectWithLine(p1, p2, pt1, n);\n      outObj.betweenPoints = plane.betweenPoints;\n      outObj.t = plane.t;\n      x[0] = plane.x[0];\n      x[1] = plane.x[1];\n      x[2] = plane.x[2];\n\n      if (!plane.intersection) {\n        pcoords[0] = 0.0;\n        pcoords[1] = 0.0;\n        outObj.intersect = 0;\n        return outObj;\n      } // Evaluate position\n\n\n      var inside = publicAPI.evaluatePosition(x, closestPoint, pcoords, weights);\n\n      if (inside.evaluation >= 0) {\n        if (inside.dist2 <= tol2) {\n          outObj.intersect = 1;\n          return outObj;\n        }\n\n        outObj.intersect = inside.evaluation;\n        return outObj;\n      }\n    } // Normals are null, so the triangle is degenerated and\n    // we still need to check intersection between line and\n    // the longest edge.\n\n\n    var dist2Pt1Pt2 = distance2BetweenPoints(pt1, pt2);\n    var dist2Pt2Pt3 = distance2BetweenPoints(pt2, pt3);\n    var dist2Pt3Pt1 = distance2BetweenPoints(pt3, pt1);\n\n    if (!model.line) {\n      model.line = vtkLine.newInstance();\n    }\n\n    if (dist2Pt1Pt2 > dist2Pt2Pt3 && dist2Pt1Pt2 > dist2Pt3Pt1) {\n      model.line.getPoints().setPoint(0, pt1);\n      model.line.getPoints().setPoint(1, pt2);\n    } else if (dist2Pt2Pt3 > dist2Pt3Pt1 && dist2Pt2Pt3 > dist2Pt1Pt2) {\n      model.line.getPoints().setPoint(0, pt2);\n      model.line.getPoints().setPoint(1, pt3);\n    } else {\n      model.line.getPoints().setPoint(0, pt3);\n      model.line.getPoints().setPoint(1, pt1);\n    }\n\n    var intersectLine = model.line.intersectWithLine(p1, p2, tol, x, pcoords);\n    outObj.betweenPoints = intersectLine.betweenPoints;\n    outObj.t = intersectLine.t;\n\n    if (intersectLine.intersect) {\n      var pt3Pt1 = [];\n      var pt3Pt2 = [];\n      var pt3X = []; // Compute r and s manually, using dot and norm.\n\n      for (var i = 0; i < 3; i++) {\n        pt3Pt1[i] = pt1[i] - pt3[i];\n        pt3Pt2[i] = pt2[i] - pt3[i];\n        pt3X[i] = x[i] - pt3[i];\n      }\n\n      pcoords[0] = dot(pt3X, pt3Pt1) / dist2Pt3Pt1;\n      pcoords[1] = dot(pt3X, pt3Pt2) / dist2Pt2Pt3;\n      outObj.intersect = 1;\n      return outObj;\n    }\n\n    pcoords[0] = 0.0;\n    pcoords[1] = 0.0;\n    outObj.intersect = 0;\n    return outObj;\n  };\n\n  publicAPI.evaluatePosition = function (x, closestPoint, pcoords, weights) {\n    // will return obj\n    var outObj = {\n      subId: 0,\n      dist2: 0,\n      evaluation: -1\n    };\n    var i;\n    var j;\n    var pt1 = [];\n    var pt2 = [];\n    var pt3 = [];\n    var n = [];\n    var fabsn;\n    var rhs = [];\n    var c1 = [];\n    var c2 = [];\n    var det = 0;\n    var idx = 0;\n    var indices = [];\n    var dist2Point;\n    var dist2Line1;\n    var dist2Line2;\n    var closest = [];\n    var closestPoint1 = [];\n    var closestPoint2 = [];\n    var cp = [];\n    outObj.subId = 0;\n    pcoords[2] = 0.0; // Get normal for triangle, only the normal direction is needed, i.e. the\n    // normal need not be normalized (unit length)\n    //\n\n    model.points.getPoint(1, pt1);\n    model.points.getPoint(2, pt2);\n    model.points.getPoint(0, pt3);\n    computeNormalDirection(pt1, pt2, pt3, n); // Project point to plane\n\n    vtkPlane.generalizedProjectPoint(x, pt1, n, cp); // Construct matrices.  Since we have over determined system, need to find\n    // which 2 out of 3 equations to use to develop equations. (Any 2 should\n    // work since we've projected point to plane.)\n\n    var maxComponent = 0.0;\n\n    for (i = 0; i < 3; i++) {\n      // trying to avoid an expensive call to fabs()\n      if (n[i] < 0) {\n        fabsn = -n[i];\n      } else {\n        fabsn = n[i];\n      }\n\n      if (fabsn > maxComponent) {\n        maxComponent = fabsn;\n        idx = i;\n      }\n    }\n\n    for (j = 0, i = 0; i < 3; i++) {\n      if (i !== idx) {\n        indices[j++] = i;\n      }\n    }\n\n    for (i = 0; i < 2; i++) {\n      rhs[i] = cp[indices[i]] - pt3[indices[i]];\n      c1[i] = pt1[indices[i]] - pt3[indices[i]];\n      c2[i] = pt2[indices[i]] - pt3[indices[i]];\n    }\n\n    det = determinant2x2(c1, c2);\n\n    if (det === 0.0) {\n      pcoords[0] = 0.0;\n      pcoords[1] = 0.0;\n      outObj.evaluation = -1;\n      return outObj;\n    }\n\n    pcoords[0] = determinant2x2(rhs, c2) / det;\n    pcoords[1] = determinant2x2(c1, rhs) / det; // Okay, now find closest point to element\n\n    weights[0] = 1 - (pcoords[0] + pcoords[1]);\n    weights[1] = pcoords[0];\n    weights[2] = pcoords[1];\n\n    if (weights[0] >= 0.0 && weights[0] <= 1.0 && weights[1] >= 0.0 && weights[1] <= 1.0 && weights[2] >= 0.0 && weights[2] <= 1.0) {\n      // projection distance\n      if (closestPoint) {\n        outObj.dist2 = distance2BetweenPoints(cp, x);\n        closestPoint[0] = cp[0];\n        closestPoint[1] = cp[1];\n        closestPoint[2] = cp[2];\n      }\n\n      outObj.evaluation = 1;\n    } else {\n      var t;\n\n      if (closestPoint) {\n        if (weights[1] < 0.0 && weights[2] < 0.0) {\n          dist2Point = distance2BetweenPoints(x, pt3);\n          dist2Line1 = vtkLine.distanceToLine(x, pt1, pt3, t, closestPoint1);\n          dist2Line2 = vtkLine.distanceToLine(x, pt3, pt2, t, closestPoint2);\n\n          if (dist2Point < dist2Line1) {\n            outObj.dist2 = dist2Point;\n            closest = pt3;\n          } else {\n            outObj.dist2 = dist2Line1;\n            closest = closestPoint1;\n          }\n\n          if (dist2Line2 < outObj.dist2) {\n            outObj.dist2 = dist2Line2;\n            closest = closestPoint2;\n          }\n\n          for (i = 0; i < 3; i++) {\n            closestPoint[i] = closest[i];\n          }\n        } else if (weights[2] < 0.0 && weights[0] < 0.0) {\n          dist2Point = distance2BetweenPoints(x, pt1);\n          dist2Line1 = vtkLine.distanceToLine(x, pt1, pt3, t, closestPoint1);\n          dist2Line2 = vtkLine.distanceToLine(x, pt1, pt2, t, closestPoint2);\n\n          if (dist2Point < dist2Line1) {\n            outObj.dist2 = dist2Point;\n            closest = pt1;\n          } else {\n            outObj.dist2 = dist2Line1;\n            closest = closestPoint1;\n          }\n\n          if (dist2Line2 < outObj.dist2) {\n            outObj.dist2 = dist2Line2;\n            closest = closestPoint2;\n          }\n\n          for (i = 0; i < 3; i++) {\n            closestPoint[i] = closest[i];\n          }\n        } else if (weights[1] < 0.0 && weights[0] < 0.0) {\n          dist2Point = distance2BetweenPoints(x, pt2);\n          dist2Line1 = vtkLine.distanceToLine(x, pt2, pt3, t, closestPoint1);\n          dist2Line2 = vtkLine.distanceToLine(x, pt1, pt2, t, closestPoint2);\n\n          if (dist2Point < dist2Line1) {\n            outObj.dist2 = dist2Point;\n            closest = pt2;\n          } else {\n            outObj.dist2 = dist2Line1;\n            closest = closestPoint1;\n          }\n\n          if (dist2Line2 < outObj.dist2) {\n            outObj.dist2 = dist2Line2;\n            closest = closestPoint2;\n          }\n\n          for (i = 0; i < 3; i++) {\n            closestPoint[i] = closest[i];\n          }\n        } else if (weights[0] < 0.0) {\n          var lineDistance = vtkLine.distanceToLine(x, pt1, pt2, closestPoint);\n          outObj.dist2 = lineDistance.distance;\n        } else if (weights[1] < 0.0) {\n          var _lineDistance = vtkLine.distanceToLine(x, pt2, pt3, closestPoint);\n\n          outObj.dist2 = _lineDistance.distance;\n        } else if (weights[2] < 0.0) {\n          var _lineDistance2 = vtkLine.distanceToLine(x, pt1, pt3, closestPoint);\n\n          outObj.dist2 = _lineDistance2.distance;\n        }\n      }\n\n      outObj.evaluation = 0;\n    }\n\n    return outObj;\n  };\n\n  publicAPI.evaluateLocation = function (pcoords, x, weights) {\n    var p0 = [];\n    var p1 = [];\n    var p2 = [];\n    model.points.getPoint(0, p0);\n    model.points.getPoint(1, p1);\n    model.points.getPoint(2, p2);\n    var u3 = 1.0 - pcoords[0] - pcoords[1];\n\n    for (var i = 0; i < 3; i++) {\n      x[i] = p0[i] * u3 + p1[i] * pcoords[0] + p2[i] * pcoords[1];\n    }\n\n    weights[0] = u3;\n    weights[1] = pcoords[0];\n    weights[2] = pcoords[1];\n  };\n\n  publicAPI.getParametricDistance = function (pcoords) {\n    var pDist;\n    var pDistMax = 0.0;\n    var pc = [];\n    pc[0] = pcoords[0];\n    pc[1] = pcoords[1];\n    pc[2] = 1.0 - pcoords[0] - pcoords[1];\n\n    for (var i = 0; i < 3; i++) {\n      if (pc[i] < 0.0) {\n        pDist = -pc[i];\n      } else if (pc[i] > 1.0) {\n        pDist = pc[i] - 1.0;\n      } else {\n        // inside the cell in the parametric direction\n        pDist = 0.0;\n      }\n\n      if (pDist > pDistMax) {\n        pDistMax = pDist;\n      }\n    }\n\n    return pDistMax;\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  vtkCell.extend(publicAPI, model, initialValues);\n  vtkTriangle(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkTriangle'); // ----------------------------------------------------------------------------\n\nvar vtkTriangle$1 = _objectSpread({\n  newInstance: newInstance,\n  extend: extend\n}, STATIC);\n\nexport { STATIC, vtkTriangle$1 as default, extend, newInstance };\n","import _defineProperty from '@babel/runtime/helpers/defineProperty';\nimport macro from '../../macros.js';\nimport vtk from '../../vtk.js';\nimport vtkCellArray from '../Core/CellArray.js';\nimport vtkCellLinks from './CellLinks.js';\nimport vtkCellTypes from './CellTypes.js';\nimport vtkLine from './Line.js';\nimport vtkPointSet from './PointSet.js';\nimport vtkTriangle from './Triangle.js';\nimport { CellType } from './CellTypes/Constants.js';\nimport { POLYDATA_FIELDS } from './PolyData/Constants.js';\n\nvar _CELL_FACTORY;\nvar vtkWarningMacro = macro.vtkWarningMacro;\nvar CELL_FACTORY = (_CELL_FACTORY = {}, _defineProperty(_CELL_FACTORY, CellType.VTK_LINE, vtkLine), _defineProperty(_CELL_FACTORY, CellType.VTK_POLY_LINE, vtkLine), _defineProperty(_CELL_FACTORY, CellType.VTK_TRIANGLE, vtkTriangle), _CELL_FACTORY); // ----------------------------------------------------------------------------\n// vtkPolyData methods\n// ----------------------------------------------------------------------------\n\nfunction vtkPolyData(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkPolyData');\n\n  function camelize(str) {\n    return str.replace(/(?:^\\w|[A-Z]|\\b\\w)/g, function (letter) {\n      return letter.toUpperCase();\n    }).replace(/\\s+/g, '');\n  } // build empty cell arrays and set methods\n\n\n  POLYDATA_FIELDS.forEach(function (type) {\n    publicAPI[\"getNumberOf\".concat(camelize(type))] = function () {\n      return model[type].getNumberOfCells();\n    };\n\n    if (!model[type]) {\n      model[type] = vtkCellArray.newInstance();\n    } else {\n      model[type] = vtk(model[type]);\n    }\n  });\n\n  publicAPI.getNumberOfCells = function () {\n    return POLYDATA_FIELDS.reduce(function (num, cellType) {\n      return num + model[cellType].getNumberOfCells();\n    }, 0);\n  };\n\n  var superShallowCopy = publicAPI.shallowCopy;\n\n  publicAPI.shallowCopy = function (other) {\n    var debug = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n    superShallowCopy(other, debug);\n    POLYDATA_FIELDS.forEach(function (type) {\n      model[type] = vtkCellArray.newInstance();\n      model[type].shallowCopy(other.getReferenceByName(type));\n    });\n  };\n\n  publicAPI.buildCells = function () {\n    // here are the number of cells we have\n    var nVerts = publicAPI.getNumberOfVerts();\n    var nLines = publicAPI.getNumberOfLines();\n    var nPolys = publicAPI.getNumberOfPolys();\n    var nStrips = publicAPI.getNumberOfStrips(); // pre-allocate the space we need\n\n    var nCells = nVerts + nLines + nPolys + nStrips;\n    var types = new Uint8Array(nCells);\n    var pTypes = types;\n    var locs = new Uint32Array(nCells);\n    var pLocs = locs; // record locations and type of each cell.\n    // verts\n\n    if (nVerts) {\n      var nextCellPts = 0;\n      model.verts.getCellSizes().forEach(function (numCellPts, index) {\n        pLocs[index] = nextCellPts;\n        pTypes[index] = numCellPts > 1 ? CellType.VTK_POLY_VERTEX : CellType.VTK_VERTEX;\n        nextCellPts += numCellPts + 1;\n      });\n      pLocs = pLocs.subarray(nVerts);\n      pTypes = pTypes.subarray(nVerts);\n    } // lines\n\n\n    if (nLines) {\n      var _nextCellPts = 0;\n      model.lines.getCellSizes().forEach(function (numCellPts, index) {\n        pLocs[index] = _nextCellPts;\n        pTypes[index] = numCellPts > 2 ? CellType.VTK_POLY_LINE : CellType.VTK_LINE;\n\n        if (numCellPts === 1) {\n          vtkWarningMacro('Building VTK_LINE ', index, ' with only one point, but VTK_LINE needs at least two points. Check the input.');\n        }\n\n        _nextCellPts += numCellPts + 1;\n      });\n      pLocs = pLocs.subarray(nLines);\n      pTypes = pTypes.subarray(nLines);\n    } // polys\n\n\n    if (nPolys) {\n      var _nextCellPts2 = 0;\n      model.polys.getCellSizes().forEach(function (numCellPts, index) {\n        pLocs[index] = _nextCellPts2;\n\n        switch (numCellPts) {\n          case 3:\n            pTypes[index] = CellType.VTK_TRIANGLE;\n            break;\n\n          case 4:\n            pTypes[index] = CellType.VTK_QUAD;\n            break;\n\n          default:\n            pTypes[index] = CellType.VTK_POLYGON;\n            break;\n        }\n\n        if (numCellPts < 3) {\n          vtkWarningMacro('Building VTK_TRIANGLE ', index, ' with less than three points, but VTK_TRIANGLE needs at least three points. Check the input.');\n        }\n\n        _nextCellPts2 += numCellPts + 1;\n      });\n      pLocs += pLocs.subarray(nPolys);\n      pTypes += pTypes.subarray(nPolys);\n    } // strips\n\n\n    if (nStrips) {\n      var _nextCellPts3 = 0;\n      pTypes.fill(CellType.VTK_TRIANGLE_STRIP, 0, nStrips);\n      model.strips.getCellSizes().forEach(function (numCellPts, index) {\n        pLocs[index] = _nextCellPts3;\n        _nextCellPts3 += numCellPts + 1;\n      });\n    } // set up the cell types data structure\n\n\n    model.cells = vtkCellTypes.newInstance();\n    model.cells.setCellTypes(nCells, types, locs);\n  };\n  /**\n   * Create upward links from points to cells that use each point. Enables\n   * topologically complex queries.\n   */\n\n\n  publicAPI.buildLinks = function () {\n    var initialSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n\n    if (model.cells === undefined) {\n      publicAPI.buildCells();\n    }\n\n    model.links = vtkCellLinks.newInstance();\n\n    if (initialSize > 0) {\n      model.links.allocate(initialSize);\n    } else {\n      model.links.allocate(publicAPI.getPoints().getNumberOfPoints());\n    }\n\n    model.links.buildLinks(publicAPI);\n  };\n\n  publicAPI.getCellType = function (cellId) {\n    return model.cells.getCellType(cellId);\n  };\n\n  publicAPI.getCellPoints = function (cellId) {\n    var cellType = publicAPI.getCellType(cellId);\n    var cells = null;\n\n    switch (cellType) {\n      case CellType.VTK_VERTEX:\n      case CellType.VTK_POLY_VERTEX:\n        cells = model.verts;\n        break;\n\n      case CellType.VTK_LINE:\n      case CellType.VTK_POLY_LINE:\n        cells = model.lines;\n        break;\n\n      case CellType.VTK_TRIANGLE:\n      case CellType.VTK_QUAD:\n      case CellType.VTK_POLYGON:\n        cells = model.polys;\n        break;\n\n      case CellType.VTK_TRIANGLE_STRIP:\n        cells = model.strips;\n        break;\n\n      default:\n        cells = null;\n        return {\n          type: 0,\n          cellPointIds: null\n        };\n    }\n\n    var loc = model.cells.getCellLocation(cellId);\n    var cellPointIds = cells.getCell(loc);\n    return {\n      cellType: cellType,\n      cellPointIds: cellPointIds\n    };\n  };\n\n  publicAPI.getPointCells = function (ptId) {\n    return model.links.getCells(ptId);\n  };\n\n  publicAPI.getCellEdgeNeighbors = function (cellId, point1, point2) {\n    var link1 = model.links.getLink(point1);\n    var link2 = model.links.getLink(point2);\n    return link1.cells.filter(function (cell) {\n      return cell !== cellId && link2.cells.indexOf(cell) !== -1;\n    });\n  };\n  /**\n   * If you know the type of cell, you may provide it to improve performances.\n   */\n\n\n  publicAPI.getCell = function (cellId) {\n    var cellHint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var cellInfo = publicAPI.getCellPoints(cellId);\n    var cell = cellHint || CELL_FACTORY[cellInfo.cellType].newInstance();\n    cell.initialize(publicAPI.getPoints(), cellInfo.cellPointIds);\n    return cell;\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {// verts: null,\n  // lines: null,\n  // polys: null,\n  // strips: null,\n  // cells: null,\n  // links: null,\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues); // Inheritance\n\n  vtkPointSet.extend(publicAPI, model, initialValues);\n  macro.get(publicAPI, model, ['cells', 'links']);\n  macro.setGet(publicAPI, model, ['verts', 'lines', 'polys', 'strips']); // Object specific methods\n\n  vtkPolyData(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkPolyData'); // ----------------------------------------------------------------------------\n\nvar vtkPolyData$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { CELL_FACTORY, vtkPolyData$1 as default, extend, newInstance };\n","var POLYDATA_FIELDS = ['verts', 'lines', 'polys', 'strips'];\nvar Constants = {\n  POLYDATA_FIELDS: POLYDATA_FIELDS\n};\n\nexport { POLYDATA_FIELDS, Constants as default };\n","function getEndianness() {\n  var a = new ArrayBuffer(4);\n  var b = new Uint8Array(a);\n  var c = new Uint32Array(a);\n  b[0] = 0xa1;\n  b[1] = 0xb2;\n  b[2] = 0xc3;\n  b[3] = 0xd4;\n  if (c[0] === 0xd4c3b2a1) return 'LittleEndian';\n  if (c[0] === 0xa1b2c3d4) return 'BigEndian';\n  return null;\n}\nvar ENDIANNESS = getEndianness();\nfunction swapBytes(buffer, wordSize) {\n  if (wordSize < 2) {\n    return;\n  }\n\n  var bytes = new Int8Array(buffer);\n  var size = bytes.length;\n  var tempBuffer = [];\n\n  for (var i = 0; i < size; i += wordSize) {\n    for (var j = 0; j < wordSize; j++) {\n      tempBuffer.push(bytes[i + j]);\n    }\n\n    for (var _j = 0; _j < wordSize; _j++) {\n      bytes[i + _j] = tempBuffer.pop();\n    }\n  }\n}\nvar Endian = {\n  ENDIANNESS: ENDIANNESS,\n  getEndianness: getEndianness,\n  swapBytes: swapBytes\n};\n\nexport { ENDIANNESS, Endian as default, getEndianness, swapBytes };\n","import _slicedToArray from '@babel/runtime/helpers/slicedToArray';\nimport macro from '../../../macros.js';\nimport Endian from '../../../Common/Core/Endian.js';\nimport { DataTypeByteSize } from '../../../Common/Core/DataArray/Constants.js';\nimport { has, registerType } from '../DataAccessHelper.js';\n\nvar vtkErrorMacro = macro.vtkErrorMacro,\n    vtkDebugMacro = macro.vtkDebugMacro;\n\nvar REJECT_COMPRESSION = function REJECT_COMPRESSION() {\n  vtkErrorMacro('LiteHttpDataAccessHelper does not support compression. Need to register HttpDataAccessHelper instead.');\n  return Promise.reject(new Error('LiteHttpDataAccessHelper does not support compression. Need to register HttpDataAccessHelper instead.'));\n};\n/* eslint-disable prefer-promise-reject-errors */\n\n\nvar requestCount = 0;\n\nfunction openAsyncXHR(method, url) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  var xhr = new XMLHttpRequest();\n  xhr.open(method, url, true);\n\n  if (options.headers) {\n    Object.entries(options.headers).forEach(function (_ref) {\n      var _ref2 = _slicedToArray(_ref, 2),\n          key = _ref2[0],\n          value = _ref2[1];\n\n      return xhr.setRequestHeader(key, value);\n    });\n  }\n\n  if (options.progressCallback) {\n    xhr.addEventListener('progress', options.progressCallback);\n  }\n\n  return xhr;\n}\n\nfunction fetchBinary(url) {\n  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n  return new Promise(function (resolve, reject) {\n    var xhr = openAsyncXHR('GET', url, options);\n\n    xhr.onreadystatechange = function (e) {\n      if (xhr.readyState === 4) {\n        if (xhr.status === 200 || xhr.status === 0) {\n          resolve(xhr.response);\n        } else {\n          reject({\n            xhr: xhr,\n            e: e\n          });\n        }\n      }\n    }; // Make request\n\n\n    xhr.responseType = 'arraybuffer';\n    xhr.send();\n  });\n}\n\nfunction fetchArray(instance, baseURL, array) {\n  var options = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};\n\n  if (options && options.compression) {\n    return REJECT_COMPRESSION();\n  }\n\n  if (array.ref && !array.ref.pending) {\n    return new Promise(function (resolve, reject) {\n      var url = [baseURL, array.ref.basepath, array.ref.id].join('/');\n      var xhr = openAsyncXHR('GET', url, options);\n\n      xhr.onreadystatechange = function (e) {\n        if (xhr.readyState === 1) {\n          array.ref.pending = true;\n\n          if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n            instance.invokeBusy(true);\n          }\n        }\n\n        if (xhr.readyState === 4) {\n          array.ref.pending = false;\n\n          if (xhr.status === 200 || xhr.status === 0) {\n            array.buffer = xhr.response;\n\n            if (array.ref.encode === 'JSON') {\n              array.values = JSON.parse(array.buffer);\n            } else {\n              if (Endian.ENDIANNESS !== array.ref.encode && Endian.ENDIANNESS) {\n                // Need to swap bytes\n                vtkDebugMacro(\"Swap bytes of \".concat(array.name));\n                Endian.swapBytes(array.buffer, DataTypeByteSize[array.dataType]);\n              }\n\n              array.values = macro.newTypedArray(array.dataType, array.buffer);\n            }\n\n            if (array.values.length !== array.size) {\n              vtkErrorMacro(\"Error in FetchArray: \".concat(array.name, \", does not have the proper array size. Got \").concat(array.values.length, \", instead of \").concat(array.size));\n            } // Done with the ref and work\n\n\n            delete array.ref;\n\n            if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n              instance.invokeBusy(false);\n            }\n\n            if (instance !== null && instance !== void 0 && instance.modified) {\n              instance.modified();\n            }\n\n            resolve(array);\n          } else {\n            reject({\n              xhr: xhr,\n              e: e\n            });\n          }\n        }\n      }; // Make request\n\n\n      xhr.responseType = array.dataType !== 'string' ? 'arraybuffer' : 'text';\n      xhr.send();\n    });\n  }\n\n  return Promise.resolve(array);\n} // ----------------------------------------------------------------------------\n\n\nfunction fetchJSON(instance, url) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  if (options && options.compression) {\n    return REJECT_COMPRESSION();\n  }\n\n  return new Promise(function (resolve, reject) {\n    var xhr = openAsyncXHR('GET', url, options);\n\n    xhr.onreadystatechange = function (e) {\n      if (xhr.readyState === 1) {\n        if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n          instance.invokeBusy(true);\n        }\n      }\n\n      if (xhr.readyState === 4) {\n        if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n          instance.invokeBusy(false);\n        }\n\n        if (xhr.status === 200 || xhr.status === 0) {\n          resolve(JSON.parse(xhr.responseText));\n        } else {\n          reject({\n            xhr: xhr,\n            e: e\n          });\n        }\n      }\n    }; // Make request\n\n\n    xhr.responseType = 'text';\n    xhr.send();\n  });\n} // ----------------------------------------------------------------------------\n\n\nfunction fetchText(instance, url) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n\n  if (options && options.compression) {\n    return REJECT_COMPRESSION();\n  }\n\n  return new Promise(function (resolve, reject) {\n    var xhr = openAsyncXHR('GET', url, options);\n\n    xhr.onreadystatechange = function (e) {\n      if (xhr.readyState === 1) {\n        if (++requestCount === 1 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n          instance.invokeBusy(true);\n        }\n      }\n\n      if (xhr.readyState === 4) {\n        if (--requestCount === 0 && instance !== null && instance !== void 0 && instance.invokeBusy) {\n          instance.invokeBusy(false);\n        }\n\n        if (xhr.status === 200 || xhr.status === 0) {\n          resolve(xhr.responseText);\n        } else {\n          reject({\n            xhr: xhr,\n            e: e\n          });\n        }\n      }\n    }; // Make request\n\n\n    xhr.responseType = 'text';\n    xhr.send();\n  });\n} // ----------------------------------------------------------------------------\n\n\nfunction fetchImage(instance, url) {\n  var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  return new Promise(function (resolve, reject) {\n    var img = new Image();\n\n    if (options.crossOrigin) {\n      img.crossOrigin = options.crossOrigin;\n    }\n\n    img.onload = function () {\n      return resolve(img);\n    };\n\n    img.onerror = reject;\n    img.src = url;\n  });\n}\n/* eslint-enable prefer-promise-reject-errors */\n// ----------------------------------------------------------------------------\n\n\nvar LiteHttpDataAccessHelper = {\n  fetchArray: fetchArray,\n  fetchJSON: fetchJSON,\n  fetchText: fetchText,\n  fetchBinary: fetchBinary,\n  // Only for HTTP\n  fetchImage: fetchImage\n}; // The lite version should never override a full feature one...\n\nif (!has('http')) {\n  registerType('http', function (options) {\n    return LiteHttpDataAccessHelper;\n  });\n}\n\nexport { LiteHttpDataAccessHelper as default };\n","import BinaryHelper from '../Core/BinaryHelper.js';\nimport DataAccessHelper from '../Core/DataAccessHelper.js';\nimport macro from '../../macros.js';\nimport vtkDataArray from '../../Common/Core/DataArray.js';\nimport vtkMatrixBuilder from '../../Common/Core/MatrixBuilder.js';\nimport vtkPolyData from '../../Common/DataModel/PolyData.js';\nimport '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';\n\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip\n\nvar vtkErrorMacro = macro.vtkErrorMacro;\n\nfunction parseHeader(headerString) {\n  var headerSubStr = headerString.split(' ');\n  var fieldValues = headerSubStr.filter(function (e) {\n    return e.indexOf('=') > -1;\n  });\n  var header = {};\n\n  for (var i = 0; i < fieldValues.length; ++i) {\n    var fieldValueStr = fieldValues[i];\n    var fieldValueSubStr = fieldValueStr.split('=');\n\n    if (fieldValueSubStr.length === 2) {\n      header[fieldValueSubStr[0]] = fieldValueSubStr[1];\n    }\n  }\n\n  return header;\n}\n\nfunction addValuesToArray(src, dst) {\n  for (var i = 0; i < src.length; i++) {\n    dst.push(src[i]);\n  }\n} // facet normal ni nj nk\n//     outer loop\n//         vertex v1x v1y v1z\n//         vertex v2x v2y v2z\n//         vertex v3x v3y v3z\n//     endloop\n// endfacet\n\n\nfunction readTriangle(lines, offset, points, cellArray, cellNormals) {\n  var normalLine = lines[offset];\n\n  if (normalLine === undefined) {\n    return -1;\n  }\n\n  if (normalLine.indexOf('endfacet') !== -1) {\n    return offset + 1;\n  }\n\n  if (normalLine.indexOf('facet') === -1) {\n    return offset + 1; // Move to next line\n  }\n\n  var nbVertex = 0;\n  var nbConsumedLines = 2;\n  var firstVertexIndex = points.length / 3;\n  var normal = normalLine.split(/[ \\t]+/).filter(function (i) {\n    return i;\n  }).slice(-3).map(Number);\n  addValuesToArray(normal, cellNormals);\n\n  while (lines[offset + nbConsumedLines].indexOf('vertex') !== -1) {\n    var line = lines[offset + nbConsumedLines];\n    var coords = line.split(/[ \\t]+/).filter(function (i) {\n      return i;\n    }).slice(-3).map(Number);\n    addValuesToArray(coords, points);\n    nbVertex++;\n    nbConsumedLines++;\n  }\n\n  cellArray.push(nbVertex);\n\n  for (var i = 0; i < nbVertex; i++) {\n    cellArray.push(firstVertexIndex + i);\n  }\n\n  while (lines[offset + nbConsumedLines] && lines[offset + nbConsumedLines].indexOf('endfacet') !== -1) {\n    nbConsumedLines++;\n  } // +1 (endfacet) +1 (next facet)\n\n\n  return offset + nbConsumedLines + 2;\n} // ----------------------------------------------------------------------------\n// vtkSTLReader methods\n// ----------------------------------------------------------------------------\n\n\nfunction vtkSTLReader(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkSTLReader'); // Create default dataAccessHelper if not available\n\n  if (!model.dataAccessHelper) {\n    model.dataAccessHelper = DataAccessHelper.get('http');\n  } // Internal method to fetch Array\n\n\n  function fetchData(url) {\n    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    var compression = option.compression !== undefined ? option.compression : model.compression;\n    var progressCallback = option.progressCallback !== undefined ? option.progressCallback : model.progressCallback;\n\n    if (option.binary) {\n      return model.dataAccessHelper.fetchBinary(url, {\n        compression: compression,\n        progressCallback: progressCallback\n      });\n    }\n\n    return model.dataAccessHelper.fetchText(publicAPI, url, {\n      compression: compression,\n      progressCallback: progressCallback\n    });\n  } // Set DataSet url\n\n\n  publicAPI.setUrl = function (url) {\n    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {\n      binary: true\n    };\n    model.url = url; // Remove the file in the URL\n\n    var path = url.split('/');\n    path.pop();\n    model.baseURL = path.join('/'); // Fetch metadata\n\n    return publicAPI.loadData(option);\n  }; // Fetch the actual data arrays\n\n\n  publicAPI.loadData = function () {\n    var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    var promise = fetchData(model.url, option);\n    promise.then(publicAPI.parse);\n    return promise;\n  };\n\n  publicAPI.parse = function (content) {\n    if (typeof content === 'string') {\n      publicAPI.parseAsText(content);\n    } else {\n      publicAPI.parseAsArrayBuffer(content);\n    }\n  };\n\n  publicAPI.parseAsArrayBuffer = function (content) {\n    if (!content) {\n      return;\n    }\n\n    if (content !== model.parseData) {\n      publicAPI.modified();\n    } else {\n      return;\n    }\n\n    model.parseData = content; // ascii/binary detection\n\n    var isBinary = false; // 80=STL header, 4=uint32 of num of triangles (le)\n\n    var dview = new DataView(content, 0, 80 + 4);\n    var numTriangles = dview.getUint32(80, true); // 50 bytes per triangle\n\n    isBinary = 84 + numTriangles * 50 === content.byteLength; // Check if ascii format\n\n    if (!isBinary) {\n      publicAPI.parseAsText(BinaryHelper.arrayBufferToString(content));\n      return;\n    } // Binary parsing\n    // Header\n\n\n    var headerData = content.slice(0, 80);\n    var headerStr = BinaryHelper.arrayBufferToString(headerData);\n    var header = parseHeader(headerStr); // Data\n\n    var dataView = new DataView(content, 84); // global.dataview = dataView;\n\n    var nbFaces = (content.byteLength - 84) / 50;\n    var pointValues = new Float32Array(nbFaces * 9);\n    var normalValues = new Float32Array(nbFaces * 3);\n    var cellValues = new Uint32Array(nbFaces * 4);\n    var cellDataValues = new Uint16Array(nbFaces);\n    var cellOffset = 0;\n\n    for (var faceIdx = 0; faceIdx < nbFaces; faceIdx++) {\n      var offset = faceIdx * 50;\n      normalValues[faceIdx * 3 + 0] = dataView.getFloat32(offset + 0, true);\n      normalValues[faceIdx * 3 + 1] = dataView.getFloat32(offset + 4, true);\n      normalValues[faceIdx * 3 + 2] = dataView.getFloat32(offset + 8, true);\n      pointValues[faceIdx * 9 + 0] = dataView.getFloat32(offset + 12, true);\n      pointValues[faceIdx * 9 + 1] = dataView.getFloat32(offset + 16, true);\n      pointValues[faceIdx * 9 + 2] = dataView.getFloat32(offset + 20, true);\n      pointValues[faceIdx * 9 + 3] = dataView.getFloat32(offset + 24, true);\n      pointValues[faceIdx * 9 + 4] = dataView.getFloat32(offset + 28, true);\n      pointValues[faceIdx * 9 + 5] = dataView.getFloat32(offset + 32, true);\n      pointValues[faceIdx * 9 + 6] = dataView.getFloat32(offset + 36, true);\n      pointValues[faceIdx * 9 + 7] = dataView.getFloat32(offset + 40, true);\n      pointValues[faceIdx * 9 + 8] = dataView.getFloat32(offset + 44, true);\n      cellValues[cellOffset++] = 3;\n      cellValues[cellOffset++] = faceIdx * 3 + 0;\n      cellValues[cellOffset++] = faceIdx * 3 + 1;\n      cellValues[cellOffset++] = faceIdx * 3 + 2;\n      cellDataValues[faceIdx] = dataView.getUint16(offset + 48, true);\n    } // Rotate points\n\n\n    var orientationField = 'SPACE';\n\n    if (orientationField in header && header[orientationField] !== 'LPS') {\n      var XYZ = header[orientationField];\n      var mat4 = new Float32Array(16);\n      mat4[15] = 1;\n\n      switch (XYZ[0]) {\n        case 'L':\n          mat4[0] = 1;\n          break;\n\n        case 'R':\n          mat4[0] = -1;\n          break;\n\n        default:\n          vtkErrorMacro(\"Can not convert STL file from \".concat(XYZ, \" to LPS space: \") + \"permutations not supported. Use itk.js STL reader instead.\");\n          return;\n      }\n\n      switch (XYZ[1]) {\n        case 'P':\n          mat4[5] = 1;\n          break;\n\n        case 'A':\n          mat4[5] = -1;\n          break;\n\n        default:\n          vtkErrorMacro(\"Can not convert STL file from \".concat(XYZ, \" to LPS space: \") + \"permutations not supported. Use itk.js STL reader instead.\");\n          return;\n      }\n\n      switch (XYZ[2]) {\n        case 'S':\n          mat4[10] = 1;\n          break;\n\n        case 'I':\n          mat4[10] = -1;\n          break;\n\n        default:\n          vtkErrorMacro(\"Can not convert STL file from \".concat(XYZ, \" to LPS space: \") + \"permutations not supported. Use itk.js STL reader instead.\");\n          return;\n      }\n\n      vtkMatrixBuilder.buildFromDegree().setMatrix(mat4).apply(pointValues).apply(normalValues);\n    }\n\n    var polydata = vtkPolyData.newInstance();\n    polydata.getPoints().setData(pointValues, 3);\n    polydata.getPolys().setData(cellValues);\n    polydata.getCellData().setScalars(vtkDataArray.newInstance({\n      name: 'Attribute',\n      values: cellDataValues\n    }));\n    polydata.getCellData().setNormals(vtkDataArray.newInstance({\n      name: 'Normals',\n      values: normalValues,\n      numberOfComponents: 3\n    })); // Add new output\n\n    model.output[0] = polydata;\n  };\n\n  publicAPI.parseAsText = function (content) {\n    if (!content) {\n      return;\n    }\n\n    if (content !== model.parseData) {\n      publicAPI.modified();\n    } else {\n      return;\n    }\n\n    model.parseData = content;\n    var lines = content.split('\\n');\n    var offset = 1;\n    var points = [];\n    var cellArray = [];\n    var cellNormals = [];\n\n    while (offset !== -1) {\n      offset = readTriangle(lines, offset, points, cellArray, cellNormals);\n    }\n\n    var polydata = vtkPolyData.newInstance();\n    polydata.getPoints().setData(Float32Array.from(points), 3);\n    polydata.getPolys().setData(Uint32Array.from(cellArray));\n    polydata.getCellData().setNormals(vtkDataArray.newInstance({\n      name: 'Normals',\n      values: Float32Array.from(cellNormals),\n      numberOfComponents: 3\n    })); // Add new output\n\n    model.output[0] = polydata;\n  };\n\n  publicAPI.requestData = function (inData, outData) {\n    publicAPI.parse(model.parseData);\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {// baseURL: null,\n  // dataAccessHelper: null,\n  // url: null,\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API\n\n  macro.obj(publicAPI, model);\n  macro.get(publicAPI, model, ['url', 'baseURL']);\n  macro.setGet(publicAPI, model, ['dataAccessHelper']);\n  macro.algo(publicAPI, model, 0, 1); // vtkSTLReader methods\n\n  vtkSTLReader(publicAPI, model); // To support destructuring\n\n  if (!model.compression) {\n    model.compression = null;\n  }\n\n  if (!model.progressCallback) {\n    model.progressCallback = null;\n  }\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkSTLReader'); // ----------------------------------------------------------------------------\n\nvar vtkSTLReader$1 = {\n  extend: extend,\n  newInstance: newInstance\n};\n\nexport { vtkSTLReader$1 as default, extend, newInstance };\n","// DEFLATE is a complex format; to read this code, you should probably check the RFC first:\n// https://tools.ietf.org/html/rfc1951\n// You may also wish to take a look at the guide I made about this program:\n// https://gist.github.com/101arrowz/253f31eb5abc3d9275ab943003ffecad\n// Some of the following code is similar to that of UZIP.js:\n// https://github.com/photopea/UZIP.js\n// However, the vast majority of the codebase has diverged from UZIP.js to increase performance and reduce bundle size.\n// Sometimes 0 will appear where -1 would be more appropriate. This is because using a uint\n// is better for memory in most engines (I *think*).\nvar ch2 = {};\nvar wk = (function (c, id, msg, transfer, cb) {\n    var w = new Worker(ch2[id] || (ch2[id] = URL.createObjectURL(new Blob([\n        c + ';addEventListener(\"error\",function(e){e=e.error;postMessage({$e$:[e.message,e.code,e.stack]})})'\n    ], { type: 'text/javascript' }))));\n    w.onmessage = function (e) {\n        var d = e.data, ed = d.$e$;\n        if (ed) {\n            var err = new Error(ed[0]);\n            err['code'] = ed[1];\n            err.stack = ed[2];\n            cb(err, null);\n        }\n        else\n            cb(null, d);\n    };\n    w.postMessage(msg, transfer);\n    return w;\n});\n\n// aliases for shorter compressed code (most minifers don't do this)\nvar u8 = Uint8Array, u16 = Uint16Array, u32 = Uint32Array;\n// fixed length extra bits\nvar fleb = new u8([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, /* unused */ 0, 0, /* impossible */ 0]);\n// fixed distance extra bits\n// see fleb note\nvar fdeb = new u8([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, /* unused */ 0, 0]);\n// code length index map\nvar clim = new u8([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);\n// get base, reverse index map from extra bits\nvar freb = function (eb, start) {\n    var b = new u16(31);\n    for (var i = 0; i < 31; ++i) {\n        b[i] = start += 1 << eb[i - 1];\n    }\n    // numbers here are at max 18 bits\n    var r = new u32(b[30]);\n    for (var i = 1; i < 30; ++i) {\n        for (var j = b[i]; j < b[i + 1]; ++j) {\n            r[j] = ((j - b[i]) << 5) | i;\n        }\n    }\n    return [b, r];\n};\nvar _a = freb(fleb, 2), fl = _a[0], revfl = _a[1];\n// we can ignore the fact that the other numbers are wrong; they never happen anyway\nfl[28] = 258, revfl[258] = 28;\nvar _b = freb(fdeb, 0), fd = _b[0], revfd = _b[1];\n// map of value to reverse (assuming 16 bits)\nvar rev = new u16(32768);\nfor (var i = 0; i < 32768; ++i) {\n    // reverse table algorithm from SO\n    var x = ((i & 0xAAAA) >>> 1) | ((i & 0x5555) << 1);\n    x = ((x & 0xCCCC) >>> 2) | ((x & 0x3333) << 2);\n    x = ((x & 0xF0F0) >>> 4) | ((x & 0x0F0F) << 4);\n    rev[i] = (((x & 0xFF00) >>> 8) | ((x & 0x00FF) << 8)) >>> 1;\n}\n// create huffman tree from u8 \"map\": index -> code length for code index\n// mb (max bits) must be at most 15\n// TODO: optimize/split up?\nvar hMap = (function (cd, mb, r) {\n    var s = cd.length;\n    // index\n    var i = 0;\n    // u16 \"map\": index -> # of codes with bit length = index\n    var l = new u16(mb);\n    // length of cd must be 288 (total # of codes)\n    for (; i < s; ++i) {\n        if (cd[i])\n            ++l[cd[i] - 1];\n    }\n    // u16 \"map\": index -> minimum code for bit length = index\n    var le = new u16(mb);\n    for (i = 0; i < mb; ++i) {\n        le[i] = (le[i - 1] + l[i - 1]) << 1;\n    }\n    var co;\n    if (r) {\n        // u16 \"map\": index -> number of actual bits, symbol for code\n        co = new u16(1 << mb);\n        // bits to remove for reverser\n        var rvb = 15 - mb;\n        for (i = 0; i < s; ++i) {\n            // ignore 0 lengths\n            if (cd[i]) {\n                // num encoding both symbol and bits read\n                var sv = (i << 4) | cd[i];\n                // free bits\n                var r_1 = mb - cd[i];\n                // start value\n                var v = le[cd[i] - 1]++ << r_1;\n                // m is end value\n                for (var m = v | ((1 << r_1) - 1); v <= m; ++v) {\n                    // every 16 bit value starting with the code yields the same result\n                    co[rev[v] >>> rvb] = sv;\n                }\n            }\n        }\n    }\n    else {\n        co = new u16(s);\n        for (i = 0; i < s; ++i) {\n            if (cd[i]) {\n                co[i] = rev[le[cd[i] - 1]++] >>> (15 - cd[i]);\n            }\n        }\n    }\n    return co;\n});\n// fixed length tree\nvar flt = new u8(288);\nfor (var i = 0; i < 144; ++i)\n    flt[i] = 8;\nfor (var i = 144; i < 256; ++i)\n    flt[i] = 9;\nfor (var i = 256; i < 280; ++i)\n    flt[i] = 7;\nfor (var i = 280; i < 288; ++i)\n    flt[i] = 8;\n// fixed distance tree\nvar fdt = new u8(32);\nfor (var i = 0; i < 32; ++i)\n    fdt[i] = 5;\n// fixed length map\nvar flm = /*#__PURE__*/ hMap(flt, 9, 0), flrm = /*#__PURE__*/ hMap(flt, 9, 1);\n// fixed distance map\nvar fdm = /*#__PURE__*/ hMap(fdt, 5, 0), fdrm = /*#__PURE__*/ hMap(fdt, 5, 1);\n// find max of array\nvar max = function (a) {\n    var m = a[0];\n    for (var i = 1; i < a.length; ++i) {\n        if (a[i] > m)\n            m = a[i];\n    }\n    return m;\n};\n// read d, starting at bit p and mask with m\nvar bits = function (d, p, m) {\n    var o = (p / 8) | 0;\n    return ((d[o] | (d[o + 1] << 8)) >> (p & 7)) & m;\n};\n// read d, starting at bit p continuing for at least 16 bits\nvar bits16 = function (d, p) {\n    var o = (p / 8) | 0;\n    return ((d[o] | (d[o + 1] << 8) | (d[o + 2] << 16)) >> (p & 7));\n};\n// get end of byte\nvar shft = function (p) { return ((p + 7) / 8) | 0; };\n// typed array slice - allows garbage collector to free original reference,\n// while being more compatible than .slice\nvar slc = function (v, s, e) {\n    if (s == null || s < 0)\n        s = 0;\n    if (e == null || e > v.length)\n        e = v.length;\n    // can't use .constructor in case user-supplied\n    var n = new (v.BYTES_PER_ELEMENT == 2 ? u16 : v.BYTES_PER_ELEMENT == 4 ? u32 : u8)(e - s);\n    n.set(v.subarray(s, e));\n    return n;\n};\n/**\n * Codes for errors generated within this library\n */\nexport var FlateErrorCode = {\n    UnexpectedEOF: 0,\n    InvalidBlockType: 1,\n    InvalidLengthLiteral: 2,\n    InvalidDistance: 3,\n    StreamFinished: 4,\n    NoStreamHandler: 5,\n    InvalidHeader: 6,\n    NoCallback: 7,\n    InvalidUTF8: 8,\n    ExtraFieldTooLong: 9,\n    InvalidDate: 10,\n    FilenameTooLong: 11,\n    StreamFinishing: 12,\n    InvalidZipData: 13,\n    UnknownCompressionMethod: 14\n};\n// error codes\nvar ec = [\n    'unexpected EOF',\n    'invalid block type',\n    'invalid length/literal',\n    'invalid distance',\n    'stream finished',\n    'no stream handler',\n    ,\n    'no callback',\n    'invalid UTF-8 data',\n    'extra field too long',\n    'date not in range 1980-2099',\n    'filename too long',\n    'stream finishing',\n    'invalid zip data'\n    // determined by unknown compression method\n];\n;\nvar err = function (ind, msg, nt) {\n    var e = new Error(msg || ec[ind]);\n    e.code = ind;\n    if (Error.captureStackTrace)\n        Error.captureStackTrace(e, err);\n    if (!nt)\n        throw e;\n    return e;\n};\n// expands raw DEFLATE data\nvar inflt = function (dat, buf, st) {\n    // source length\n    var sl = dat.length;\n    if (!sl || (st && st.f && !st.l))\n        return buf || new u8(0);\n    // have to estimate size\n    var noBuf = !buf || st;\n    // no state\n    var noSt = !st || st.i;\n    if (!st)\n        st = {};\n    // Assumes roughly 33% compression ratio average\n    if (!buf)\n        buf = new u8(sl * 3);\n    // ensure buffer can fit at least l elements\n    var cbuf = function (l) {\n        var bl = buf.length;\n        // need to increase size to fit\n        if (l > bl) {\n            // Double or set to necessary, whichever is greater\n            var nbuf = new u8(Math.max(bl * 2, l));\n            nbuf.set(buf);\n            buf = nbuf;\n        }\n    };\n    //  last chunk         bitpos           bytes\n    var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;\n    // total bits\n    var tbts = sl * 8;\n    do {\n        if (!lm) {\n            // BFINAL - this is only 1 when last chunk is next\n            final = bits(dat, pos, 1);\n            // type: 0 = no compression, 1 = fixed huffman, 2 = dynamic huffman\n            var type = bits(dat, pos + 1, 3);\n            pos += 3;\n            if (!type) {\n                // go to end of byte boundary\n                var s = shft(pos) + 4, l = dat[s - 4] | (dat[s - 3] << 8), t = s + l;\n                if (t > sl) {\n                    if (noSt)\n                        err(0);\n                    break;\n                }\n                // ensure size\n                if (noBuf)\n                    cbuf(bt + l);\n                // Copy over uncompressed data\n                buf.set(dat.subarray(s, t), bt);\n                // Get new bitpos, update byte count\n                st.b = bt += l, st.p = pos = t * 8, st.f = final;\n                continue;\n            }\n            else if (type == 1)\n                lm = flrm, dm = fdrm, lbt = 9, dbt = 5;\n            else if (type == 2) {\n                //  literal                            lengths\n                var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;\n                var tl = hLit + bits(dat, pos + 5, 31) + 1;\n                pos += 14;\n                // length+distance tree\n                var ldt = new u8(tl);\n                // code length tree\n                var clt = new u8(19);\n                for (var i = 0; i < hcLen; ++i) {\n                    // use index map to get real code\n                    clt[clim[i]] = bits(dat, pos + i * 3, 7);\n                }\n                pos += hcLen * 3;\n                // code lengths bits\n                var clb = max(clt), clbmsk = (1 << clb) - 1;\n                // code lengths map\n                var clm = hMap(clt, clb, 1);\n                for (var i = 0; i < tl;) {\n                    var r = clm[bits(dat, pos, clbmsk)];\n                    // bits read\n                    pos += r & 15;\n                    // symbol\n                    var s = r >>> 4;\n                    // code length to copy\n                    if (s < 16) {\n                        ldt[i++] = s;\n                    }\n                    else {\n                        //  copy   count\n                        var c = 0, n = 0;\n                        if (s == 16)\n                            n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];\n                        else if (s == 17)\n                            n = 3 + bits(dat, pos, 7), pos += 3;\n                        else if (s == 18)\n                            n = 11 + bits(dat, pos, 127), pos += 7;\n                        while (n--)\n                            ldt[i++] = c;\n                    }\n                }\n                //    length tree                 distance tree\n                var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);\n                // max length bits\n                lbt = max(lt);\n                // max dist bits\n                dbt = max(dt);\n                lm = hMap(lt, lbt, 1);\n                dm = hMap(dt, dbt, 1);\n            }\n            else\n                err(1);\n            if (pos > tbts) {\n                if (noSt)\n                    err(0);\n                break;\n            }\n        }\n        // Make sure the buffer can hold this + the largest possible addition\n        // Maximum chunk size (practically, theoretically infinite) is 2^17;\n        if (noBuf)\n            cbuf(bt + 131072);\n        var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;\n        var lpos = pos;\n        for (;; lpos = pos) {\n            // bits read, code\n            var c = lm[bits16(dat, pos) & lms], sym = c >>> 4;\n            pos += c & 15;\n            if (pos > tbts) {\n                if (noSt)\n                    err(0);\n                break;\n            }\n            if (!c)\n                err(2);\n            if (sym < 256)\n                buf[bt++] = sym;\n            else if (sym == 256) {\n                lpos = pos, lm = null;\n                break;\n            }\n            else {\n                var add = sym - 254;\n                // no extra bits needed if less\n                if (sym > 264) {\n                    // index\n                    var i = sym - 257, b = fleb[i];\n                    add = bits(dat, pos, (1 << b) - 1) + fl[i];\n                    pos += b;\n                }\n                // dist\n                var d = dm[bits16(dat, pos) & dms], dsym = d >>> 4;\n                if (!d)\n                    err(3);\n                pos += d & 15;\n                var dt = fd[dsym];\n                if (dsym > 3) {\n                    var b = fdeb[dsym];\n                    dt += bits16(dat, pos) & ((1 << b) - 1), pos += b;\n                }\n                if (pos > tbts) {\n                    if (noSt)\n                        err(0);\n                    break;\n                }\n                if (noBuf)\n                    cbuf(bt + 131072);\n                var end = bt + add;\n                for (; bt < end; bt += 4) {\n                    buf[bt] = buf[bt - dt];\n                    buf[bt + 1] = buf[bt + 1 - dt];\n                    buf[bt + 2] = buf[bt + 2 - dt];\n                    buf[bt + 3] = buf[bt + 3 - dt];\n                }\n                bt = end;\n            }\n        }\n        st.l = lm, st.p = lpos, st.b = bt, st.f = final;\n        if (lm)\n            final = 1, st.m = lbt, st.d = dm, st.n = dbt;\n    } while (!final);\n    return bt == buf.length ? buf : slc(buf, 0, bt);\n};\n// starting at p, write the minimum number of bits that can hold v to d\nvar wbits = function (d, p, v) {\n    v <<= p & 7;\n    var o = (p / 8) | 0;\n    d[o] |= v;\n    d[o + 1] |= v >>> 8;\n};\n// starting at p, write the minimum number of bits (>8) that can hold v to d\nvar wbits16 = function (d, p, v) {\n    v <<= p & 7;\n    var o = (p / 8) | 0;\n    d[o] |= v;\n    d[o + 1] |= v >>> 8;\n    d[o + 2] |= v >>> 16;\n};\n// creates code lengths from a frequency table\nvar hTree = function (d, mb) {\n    // Need extra info to make a tree\n    var t = [];\n    for (var i = 0; i < d.length; ++i) {\n        if (d[i])\n            t.push({ s: i, f: d[i] });\n    }\n    var s = t.length;\n    var t2 = t.slice();\n    if (!s)\n        return [et, 0];\n    if (s == 1) {\n        var v = new u8(t[0].s + 1);\n        v[t[0].s] = 1;\n        return [v, 1];\n    }\n    t.sort(function (a, b) { return a.f - b.f; });\n    // after i2 reaches last ind, will be stopped\n    // freq must be greater than largest possible number of symbols\n    t.push({ s: -1, f: 25001 });\n    var l = t[0], r = t[1], i0 = 0, i1 = 1, i2 = 2;\n    t[0] = { s: -1, f: l.f + r.f, l: l, r: r };\n    // efficient algorithm from UZIP.js\n    // i0 is lookbehind, i2 is lookahead - after processing two low-freq\n    // symbols that combined have high freq, will start processing i2 (high-freq,\n    // non-composite) symbols instead\n    // see https://reddit.com/r/photopea/comments/ikekht/uzipjs_questions/\n    while (i1 != s - 1) {\n        l = t[t[i0].f < t[i2].f ? i0++ : i2++];\n        r = t[i0 != i1 && t[i0].f < t[i2].f ? i0++ : i2++];\n        t[i1++] = { s: -1, f: l.f + r.f, l: l, r: r };\n    }\n    var maxSym = t2[0].s;\n    for (var i = 1; i < s; ++i) {\n        if (t2[i].s > maxSym)\n            maxSym = t2[i].s;\n    }\n    // code lengths\n    var tr = new u16(maxSym + 1);\n    // max bits in tree\n    var mbt = ln(t[i1 - 1], tr, 0);\n    if (mbt > mb) {\n        // more algorithms from UZIP.js\n        // TODO: find out how this code works (debt)\n        //  ind    debt\n        var i = 0, dt = 0;\n        //    left            cost\n        var lft = mbt - mb, cst = 1 << lft;\n        t2.sort(function (a, b) { return tr[b.s] - tr[a.s] || a.f - b.f; });\n        for (; i < s; ++i) {\n            var i2_1 = t2[i].s;\n            if (tr[i2_1] > mb) {\n                dt += cst - (1 << (mbt - tr[i2_1]));\n                tr[i2_1] = mb;\n            }\n            else\n                break;\n        }\n        dt >>>= lft;\n        while (dt > 0) {\n            var i2_2 = t2[i].s;\n            if (tr[i2_2] < mb)\n                dt -= 1 << (mb - tr[i2_2]++ - 1);\n            else\n                ++i;\n        }\n        for (; i >= 0 && dt; --i) {\n            var i2_3 = t2[i].s;\n            if (tr[i2_3] == mb) {\n                --tr[i2_3];\n                ++dt;\n            }\n        }\n        mbt = mb;\n    }\n    return [new u8(tr), mbt];\n};\n// get the max length and assign length codes\nvar ln = function (n, l, d) {\n    return n.s == -1\n        ? Math.max(ln(n.l, l, d + 1), ln(n.r, l, d + 1))\n        : (l[n.s] = d);\n};\n// length codes generation\nvar lc = function (c) {\n    var s = c.length;\n    // Note that the semicolon was intentional\n    while (s && !c[--s])\n        ;\n    var cl = new u16(++s);\n    //  ind      num         streak\n    var cli = 0, cln = c[0], cls = 1;\n    var w = function (v) { cl[cli++] = v; };\n    for (var i = 1; i <= s; ++i) {\n        if (c[i] == cln && i != s)\n            ++cls;\n        else {\n            if (!cln && cls > 2) {\n                for (; cls > 138; cls -= 138)\n                    w(32754);\n                if (cls > 2) {\n                    w(cls > 10 ? ((cls - 11) << 5) | 28690 : ((cls - 3) << 5) | 12305);\n                    cls = 0;\n                }\n            }\n            else if (cls > 3) {\n                w(cln), --cls;\n                for (; cls > 6; cls -= 6)\n                    w(8304);\n                if (cls > 2)\n                    w(((cls - 3) << 5) | 8208), cls = 0;\n            }\n            while (cls--)\n                w(cln);\n            cls = 1;\n            cln = c[i];\n        }\n    }\n    return [cl.subarray(0, cli), s];\n};\n// calculate the length of output from tree, code lengths\nvar clen = function (cf, cl) {\n    var l = 0;\n    for (var i = 0; i < cl.length; ++i)\n        l += cf[i] * cl[i];\n    return l;\n};\n// writes a fixed block\n// returns the new bit pos\nvar wfblk = function (out, pos, dat) {\n    // no need to write 00 as type: TypedArray defaults to 0\n    var s = dat.length;\n    var o = shft(pos + 2);\n    out[o] = s & 255;\n    out[o + 1] = s >>> 8;\n    out[o + 2] = out[o] ^ 255;\n    out[o + 3] = out[o + 1] ^ 255;\n    for (var i = 0; i < s; ++i)\n        out[o + i + 4] = dat[i];\n    return (o + 4 + s) * 8;\n};\n// writes a block\nvar wblk = function (dat, out, final, syms, lf, df, eb, li, bs, bl, p) {\n    wbits(out, p++, final);\n    ++lf[256];\n    var _a = hTree(lf, 15), dlt = _a[0], mlb = _a[1];\n    var _b = hTree(df, 15), ddt = _b[0], mdb = _b[1];\n    var _c = lc(dlt), lclt = _c[0], nlc = _c[1];\n    var _d = lc(ddt), lcdt = _d[0], ndc = _d[1];\n    var lcfreq = new u16(19);\n    for (var i = 0; i < lclt.length; ++i)\n        lcfreq[lclt[i] & 31]++;\n    for (var i = 0; i < lcdt.length; ++i)\n        lcfreq[lcdt[i] & 31]++;\n    var _e = hTree(lcfreq, 7), lct = _e[0], mlcb = _e[1];\n    var nlcc = 19;\n    for (; nlcc > 4 && !lct[clim[nlcc - 1]]; --nlcc)\n        ;\n    var flen = (bl + 5) << 3;\n    var ftlen = clen(lf, flt) + clen(df, fdt) + eb;\n    var dtlen = clen(lf, dlt) + clen(df, ddt) + eb + 14 + 3 * nlcc + clen(lcfreq, lct) + (2 * lcfreq[16] + 3 * lcfreq[17] + 7 * lcfreq[18]);\n    if (flen <= ftlen && flen <= dtlen)\n        return wfblk(out, p, dat.subarray(bs, bs + bl));\n    var lm, ll, dm, dl;\n    wbits(out, p, 1 + (dtlen < ftlen)), p += 2;\n    if (dtlen < ftlen) {\n        lm = hMap(dlt, mlb, 0), ll = dlt, dm = hMap(ddt, mdb, 0), dl = ddt;\n        var llm = hMap(lct, mlcb, 0);\n        wbits(out, p, nlc - 257);\n        wbits(out, p + 5, ndc - 1);\n        wbits(out, p + 10, nlcc - 4);\n        p += 14;\n        for (var i = 0; i < nlcc; ++i)\n            wbits(out, p + 3 * i, lct[clim[i]]);\n        p += 3 * nlcc;\n        var lcts = [lclt, lcdt];\n        for (var it = 0; it < 2; ++it) {\n            var clct = lcts[it];\n            for (var i = 0; i < clct.length; ++i) {\n                var len = clct[i] & 31;\n                wbits(out, p, llm[len]), p += lct[len];\n                if (len > 15)\n                    wbits(out, p, (clct[i] >>> 5) & 127), p += clct[i] >>> 12;\n            }\n        }\n    }\n    else {\n        lm = flm, ll = flt, dm = fdm, dl = fdt;\n    }\n    for (var i = 0; i < li; ++i) {\n        if (syms[i] > 255) {\n            var len = (syms[i] >>> 18) & 31;\n            wbits16(out, p, lm[len + 257]), p += ll[len + 257];\n            if (len > 7)\n                wbits(out, p, (syms[i] >>> 23) & 31), p += fleb[len];\n            var dst = syms[i] & 31;\n            wbits16(out, p, dm[dst]), p += dl[dst];\n            if (dst > 3)\n                wbits16(out, p, (syms[i] >>> 5) & 8191), p += fdeb[dst];\n        }\n        else {\n            wbits16(out, p, lm[syms[i]]), p += ll[syms[i]];\n        }\n    }\n    wbits16(out, p, lm[256]);\n    return p + ll[256];\n};\n// deflate options (nice << 13) | chain\nvar deo = /*#__PURE__*/ new u32([65540, 131080, 131088, 131104, 262176, 1048704, 1048832, 2114560, 2117632]);\n// empty\nvar et = /*#__PURE__*/ new u8(0);\n// compresses data into a raw DEFLATE buffer\nvar dflt = function (dat, lvl, plvl, pre, post, lst) {\n    var s = dat.length;\n    var o = new u8(pre + s + 5 * (1 + Math.ceil(s / 7000)) + post);\n    // writing to this writes to the output buffer\n    var w = o.subarray(pre, o.length - post);\n    var pos = 0;\n    if (!lvl || s < 8) {\n        for (var i = 0; i <= s; i += 65535) {\n            // end\n            var e = i + 65535;\n            if (e >= s) {\n                // write final block\n                w[pos >> 3] = lst;\n            }\n            pos = wfblk(w, pos + 1, dat.subarray(i, e));\n        }\n    }\n    else {\n        var opt = deo[lvl - 1];\n        var n = opt >>> 13, c = opt & 8191;\n        var msk_1 = (1 << plvl) - 1;\n        //    prev 2-byte val map    curr 2-byte val map\n        var prev = new u16(32768), head = new u16(msk_1 + 1);\n        var bs1_1 = Math.ceil(plvl / 3), bs2_1 = 2 * bs1_1;\n        var hsh = function (i) { return (dat[i] ^ (dat[i + 1] << bs1_1) ^ (dat[i + 2] << bs2_1)) & msk_1; };\n        // 24576 is an arbitrary number of maximum symbols per block\n        // 424 buffer for last block\n        var syms = new u32(25000);\n        // length/literal freq   distance freq\n        var lf = new u16(288), df = new u16(32);\n        //  l/lcnt  exbits  index  l/lind  waitdx  bitpos\n        var lc_1 = 0, eb = 0, i = 0, li = 0, wi = 0, bs = 0;\n        for (; i < s; ++i) {\n            // hash value\n            // deopt when i > s - 3 - at end, deopt acceptable\n            var hv = hsh(i);\n            // index mod 32768    previous index mod\n            var imod = i & 32767, pimod = head[hv];\n            prev[imod] = pimod;\n            head[hv] = imod;\n            // We always should modify head and prev, but only add symbols if\n            // this data is not yet processed (\"wait\" for wait index)\n            if (wi <= i) {\n                // bytes remaining\n                var rem = s - i;\n                if ((lc_1 > 7000 || li > 24576) && rem > 423) {\n                    pos = wblk(dat, w, 0, syms, lf, df, eb, li, bs, i - bs, pos);\n                    li = lc_1 = eb = 0, bs = i;\n                    for (var j = 0; j < 286; ++j)\n                        lf[j] = 0;\n                    for (var j = 0; j < 30; ++j)\n                        df[j] = 0;\n                }\n                //  len    dist   chain\n                var l = 2, d = 0, ch_1 = c, dif = (imod - pimod) & 32767;\n                if (rem > 2 && hv == hsh(i - dif)) {\n                    var maxn = Math.min(n, rem) - 1;\n                    var maxd = Math.min(32767, i);\n                    // max possible length\n                    // not capped at dif because decompressors implement \"rolling\" index population\n                    var ml = Math.min(258, rem);\n                    while (dif <= maxd && --ch_1 && imod != pimod) {\n                        if (dat[i + l] == dat[i + l - dif]) {\n                            var nl = 0;\n                            for (; nl < ml && dat[i + nl] == dat[i + nl - dif]; ++nl)\n                                ;\n                            if (nl > l) {\n                                l = nl, d = dif;\n                                // break out early when we reach \"nice\" (we are satisfied enough)\n                                if (nl > maxn)\n                                    break;\n                                // now, find the rarest 2-byte sequence within this\n                                // length of literals and search for that instead.\n                                // Much faster than just using the start\n                                var mmd = Math.min(dif, nl - 2);\n                                var md = 0;\n                                for (var j = 0; j < mmd; ++j) {\n                                    var ti = (i - dif + j + 32768) & 32767;\n                                    var pti = prev[ti];\n                                    var cd = (ti - pti + 32768) & 32767;\n                                    if (cd > md)\n                                        md = cd, pimod = ti;\n                                }\n                            }\n                        }\n                        // check the previous match\n                        imod = pimod, pimod = prev[imod];\n                        dif += (imod - pimod + 32768) & 32767;\n                    }\n                }\n                // d will be nonzero only when a match was found\n                if (d) {\n                    // store both dist and len data in one Uint32\n                    // Make sure this is recognized as a len/dist with 28th bit (2^28)\n                    syms[li++] = 268435456 | (revfl[l] << 18) | revfd[d];\n                    var lin = revfl[l] & 31, din = revfd[d] & 31;\n                    eb += fleb[lin] + fdeb[din];\n                    ++lf[257 + lin];\n                    ++df[din];\n                    wi = i + l;\n                    ++lc_1;\n                }\n                else {\n                    syms[li++] = dat[i];\n                    ++lf[dat[i]];\n                }\n            }\n        }\n        pos = wblk(dat, w, lst, syms, lf, df, eb, li, bs, i - bs, pos);\n        // this is the easiest way to avoid needing to maintain state\n        if (!lst && pos & 7)\n            pos = wfblk(w, pos + 1, et);\n    }\n    return slc(o, 0, pre + shft(pos) + post);\n};\n// CRC32 table\nvar crct = /*#__PURE__*/ (function () {\n    var t = new Int32Array(256);\n    for (var i = 0; i < 256; ++i) {\n        var c = i, k = 9;\n        while (--k)\n            c = ((c & 1) && -306674912) ^ (c >>> 1);\n        t[i] = c;\n    }\n    return t;\n})();\n// CRC32\nvar crc = function () {\n    var c = -1;\n    return {\n        p: function (d) {\n            // closures have awful performance\n            var cr = c;\n            for (var i = 0; i < d.length; ++i)\n                cr = crct[(cr & 255) ^ d[i]] ^ (cr >>> 8);\n            c = cr;\n        },\n        d: function () { return ~c; }\n    };\n};\n// Alder32\nvar adler = function () {\n    var a = 1, b = 0;\n    return {\n        p: function (d) {\n            // closures have awful performance\n            var n = a, m = b;\n            var l = d.length | 0;\n            for (var i = 0; i != l;) {\n                var e = Math.min(i + 2655, l);\n                for (; i < e; ++i)\n                    m += n += d[i];\n                n = (n & 65535) + 15 * (n >> 16), m = (m & 65535) + 15 * (m >> 16);\n            }\n            a = n, b = m;\n        },\n        d: function () {\n            a %= 65521, b %= 65521;\n            return (a & 255) << 24 | (a >>> 8) << 16 | (b & 255) << 8 | (b >>> 8);\n        }\n    };\n};\n;\n// deflate with opts\nvar dopt = function (dat, opt, pre, post, st) {\n    return dflt(dat, opt.level == null ? 6 : opt.level, opt.mem == null ? Math.ceil(Math.max(8, Math.min(13, Math.log(dat.length))) * 1.5) : (12 + opt.mem), pre, post, !st);\n};\n// Walmart object spread\nvar mrg = function (a, b) {\n    var o = {};\n    for (var k in a)\n        o[k] = a[k];\n    for (var k in b)\n        o[k] = b[k];\n    return o;\n};\n// worker clone\n// This is possibly the craziest part of the entire codebase, despite how simple it may seem.\n// The only parameter to this function is a closure that returns an array of variables outside of the function scope.\n// We're going to try to figure out the variable names used in the closure as strings because that is crucial for workerization.\n// We will return an object mapping of true variable name to value (basically, the current scope as a JS object).\n// The reason we can't just use the original variable names is minifiers mangling the toplevel scope.\n// This took me three weeks to figure out how to do.\nvar wcln = function (fn, fnStr, td) {\n    var dt = fn();\n    var st = fn.toString();\n    var ks = st.slice(st.indexOf('[') + 1, st.lastIndexOf(']')).replace(/\\s+/g, '').split(',');\n    for (var i = 0; i < dt.length; ++i) {\n        var v = dt[i], k = ks[i];\n        if (typeof v == 'function') {\n            fnStr += ';' + k + '=';\n            var st_1 = v.toString();\n            if (v.prototype) {\n                // for global objects\n                if (st_1.indexOf('[native code]') != -1) {\n                    var spInd = st_1.indexOf(' ', 8) + 1;\n                    fnStr += st_1.slice(spInd, st_1.indexOf('(', spInd));\n                }\n                else {\n                    fnStr += st_1;\n                    for (var t in v.prototype)\n                        fnStr += ';' + k + '.prototype.' + t + '=' + v.prototype[t].toString();\n                }\n            }\n            else\n                fnStr += st_1;\n        }\n        else\n            td[k] = v;\n    }\n    return [fnStr, td];\n};\nvar ch = [];\n// clone bufs\nvar cbfs = function (v) {\n    var tl = [];\n    for (var k in v) {\n        if (v[k].buffer) {\n            tl.push((v[k] = new v[k].constructor(v[k])).buffer);\n        }\n    }\n    return tl;\n};\n// use a worker to execute code\nvar wrkr = function (fns, init, id, cb) {\n    var _a;\n    if (!ch[id]) {\n        var fnStr = '', td_1 = {}, m = fns.length - 1;\n        for (var i = 0; i < m; ++i)\n            _a = wcln(fns[i], fnStr, td_1), fnStr = _a[0], td_1 = _a[1];\n        ch[id] = wcln(fns[m], fnStr, td_1);\n    }\n    var td = mrg({}, ch[id][1]);\n    return wk(ch[id][0] + ';onmessage=function(e){for(var k in e.data)self[k]=e.data[k];onmessage=' + init.toString() + '}', id, td, cbfs(td), cb);\n};\n// base async inflate fn\nvar bInflt = function () { return [u8, u16, u32, fleb, fdeb, clim, fl, fd, flrm, fdrm, rev, ec, hMap, max, bits, bits16, shft, slc, err, inflt, inflateSync, pbf, gu8]; };\nvar bDflt = function () { return [u8, u16, u32, fleb, fdeb, clim, revfl, revfd, flm, flt, fdm, fdt, rev, deo, et, hMap, wbits, wbits16, hTree, ln, lc, clen, wfblk, wblk, shft, slc, dflt, dopt, deflateSync, pbf]; };\n// gzip extra\nvar gze = function () { return [gzh, gzhl, wbytes, crc, crct]; };\n// gunzip extra\nvar guze = function () { return [gzs, gzl]; };\n// zlib extra\nvar zle = function () { return [zlh, wbytes, adler]; };\n// unzlib extra\nvar zule = function () { return [zlv]; };\n// post buf\nvar pbf = function (msg) { return postMessage(msg, [msg.buffer]); };\n// get u8\nvar gu8 = function (o) { return o && o.size && new u8(o.size); };\n// async helper\nvar cbify = function (dat, opts, fns, init, id, cb) {\n    var w = wrkr(fns, init, id, function (err, dat) {\n        w.terminate();\n        cb(err, dat);\n    });\n    w.postMessage([dat, opts], opts.consume ? [dat.buffer] : []);\n    return function () { w.terminate(); };\n};\n// auto stream\nvar astrm = function (strm) {\n    strm.ondata = function (dat, final) { return postMessage([dat, final], [dat.buffer]); };\n    return function (ev) { return strm.push(ev.data[0], ev.data[1]); };\n};\n// async stream attach\nvar astrmify = function (fns, strm, opts, init, id) {\n    var t;\n    var w = wrkr(fns, init, id, function (err, dat) {\n        if (err)\n            w.terminate(), strm.ondata.call(strm, err);\n        else {\n            if (dat[1])\n                w.terminate();\n            strm.ondata.call(strm, err, dat[0], dat[1]);\n        }\n    });\n    w.postMessage(opts);\n    strm.push = function (d, f) {\n        if (!strm.ondata)\n            err(5);\n        if (t)\n            strm.ondata(err(4, 0, 1), null, !!f);\n        w.postMessage([d, t = f], [d.buffer]);\n    };\n    strm.terminate = function () { w.terminate(); };\n};\n// read 2 bytes\nvar b2 = function (d, b) { return d[b] | (d[b + 1] << 8); };\n// read 4 bytes\nvar b4 = function (d, b) { return (d[b] | (d[b + 1] << 8) | (d[b + 2] << 16) | (d[b + 3] << 24)) >>> 0; };\nvar b8 = function (d, b) { return b4(d, b) + (b4(d, b + 4) * 4294967296); };\n// write bytes\nvar wbytes = function (d, b, v) {\n    for (; v; ++b)\n        d[b] = v, v >>>= 8;\n};\n// gzip header\nvar gzh = function (c, o) {\n    var fn = o.filename;\n    c[0] = 31, c[1] = 139, c[2] = 8, c[8] = o.level < 2 ? 4 : o.level == 9 ? 2 : 0, c[9] = 3; // assume Unix\n    if (o.mtime != 0)\n        wbytes(c, 4, Math.floor(new Date(o.mtime || Date.now()) / 1000));\n    if (fn) {\n        c[3] = 8;\n        for (var i = 0; i <= fn.length; ++i)\n            c[i + 10] = fn.charCodeAt(i);\n    }\n};\n// gzip footer: -8 to -4 = CRC, -4 to -0 is length\n// gzip start\nvar gzs = function (d) {\n    if (d[0] != 31 || d[1] != 139 || d[2] != 8)\n        err(6, 'invalid gzip data');\n    var flg = d[3];\n    var st = 10;\n    if (flg & 4)\n        st += d[10] | (d[11] << 8) + 2;\n    for (var zs = (flg >> 3 & 1) + (flg >> 4 & 1); zs > 0; zs -= !d[st++])\n        ;\n    return st + (flg & 2);\n};\n// gzip length\nvar gzl = function (d) {\n    var l = d.length;\n    return ((d[l - 4] | d[l - 3] << 8 | d[l - 2] << 16) | (d[l - 1] << 24)) >>> 0;\n};\n// gzip header length\nvar gzhl = function (o) { return 10 + ((o.filename && (o.filename.length + 1)) || 0); };\n// zlib header\nvar zlh = function (c, o) {\n    var lv = o.level, fl = lv == 0 ? 0 : lv < 6 ? 1 : lv == 9 ? 3 : 2;\n    c[0] = 120, c[1] = (fl << 6) | (fl ? (32 - 2 * fl) : 1);\n};\n// zlib valid\nvar zlv = function (d) {\n    if ((d[0] & 15) != 8 || (d[0] >>> 4) > 7 || ((d[0] << 8 | d[1]) % 31))\n        err(6, 'invalid zlib data');\n    if (d[1] & 32)\n        err(6, 'invalid zlib data: preset dictionaries not supported');\n};\nfunction AsyncCmpStrm(opts, cb) {\n    if (!cb && typeof opts == 'function')\n        cb = opts, opts = {};\n    this.ondata = cb;\n    return opts;\n}\n// zlib footer: -4 to -0 is Adler32\n/**\n * Streaming DEFLATE compression\n */\nvar Deflate = /*#__PURE__*/ (function () {\n    function Deflate(opts, cb) {\n        if (!cb && typeof opts == 'function')\n            cb = opts, opts = {};\n        this.ondata = cb;\n        this.o = opts || {};\n    }\n    Deflate.prototype.p = function (c, f) {\n        this.ondata(dopt(c, this.o, 0, 0, !f), f);\n    };\n    /**\n     * Pushes a chunk to be deflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Deflate.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            err(5);\n        if (this.d)\n            err(4);\n        this.d = final;\n        this.p(chunk, final || false);\n    };\n    return Deflate;\n}());\nexport { Deflate };\n/**\n * Asynchronous streaming DEFLATE compression\n */\nvar AsyncDeflate = /*#__PURE__*/ (function () {\n    function AsyncDeflate(opts, cb) {\n        astrmify([\n            bDflt,\n            function () { return [astrm, Deflate]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Deflate(ev.data);\n            onmessage = astrm(strm);\n        }, 6);\n    }\n    return AsyncDeflate;\n}());\nexport { AsyncDeflate };\nexport function deflate(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bDflt,\n    ], function (ev) { return pbf(deflateSync(ev.data[0], ev.data[1])); }, 0, cb);\n}\n/**\n * Compresses data with DEFLATE without any wrapper\n * @param data The data to compress\n * @param opts The compression options\n * @returns The deflated version of the data\n */\nexport function deflateSync(data, opts) {\n    return dopt(data, opts || {}, 0, 0);\n}\n/**\n * Streaming DEFLATE decompression\n */\nvar Inflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates an inflation stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Inflate(cb) {\n        this.s = {};\n        this.p = new u8(0);\n        this.ondata = cb;\n    }\n    Inflate.prototype.e = function (c) {\n        if (!this.ondata)\n            err(5);\n        if (this.d)\n            err(4);\n        var l = this.p.length;\n        var n = new u8(l + c.length);\n        n.set(this.p), n.set(c, l), this.p = n;\n    };\n    Inflate.prototype.c = function (final) {\n        this.d = this.s.i = final || false;\n        var bts = this.s.b;\n        var dt = inflt(this.p, this.o, this.s);\n        this.ondata(slc(dt, bts, this.s.b), this.d);\n        this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;\n        this.p = slc(this.p, (this.s.p / 8) | 0), this.s.p &= 7;\n    };\n    /**\n     * Pushes a chunk to be inflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the final chunk\n     */\n    Inflate.prototype.push = function (chunk, final) {\n        this.e(chunk), this.c(final);\n    };\n    return Inflate;\n}());\nexport { Inflate };\n/**\n * Asynchronous streaming DEFLATE decompression\n */\nvar AsyncInflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous inflation stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncInflate(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            function () { return [astrm, Inflate]; }\n        ], this, 0, function () {\n            var strm = new Inflate();\n            onmessage = astrm(strm);\n        }, 7);\n    }\n    return AsyncInflate;\n}());\nexport { AsyncInflate };\nexport function inflate(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bInflt\n    ], function (ev) { return pbf(inflateSync(ev.data[0], gu8(ev.data[1]))); }, 1, cb);\n}\n/**\n * Expands DEFLATE data with no wrapper\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function inflateSync(data, out) {\n    return inflt(data, out);\n}\n// before you yell at me for not just using extends, my reason is that TS inheritance is hard to workerize.\n/**\n * Streaming GZIP compression\n */\nvar Gzip = /*#__PURE__*/ (function () {\n    function Gzip(opts, cb) {\n        this.c = crc();\n        this.l = 0;\n        this.v = 1;\n        Deflate.call(this, opts, cb);\n    }\n    /**\n     * Pushes a chunk to be GZIPped\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Gzip.prototype.push = function (chunk, final) {\n        Deflate.prototype.push.call(this, chunk, final);\n    };\n    Gzip.prototype.p = function (c, f) {\n        this.c.p(c);\n        this.l += c.length;\n        var raw = dopt(c, this.o, this.v && gzhl(this.o), f && 8, !f);\n        if (this.v)\n            gzh(raw, this.o), this.v = 0;\n        if (f)\n            wbytes(raw, raw.length - 8, this.c.d()), wbytes(raw, raw.length - 4, this.l);\n        this.ondata(raw, f);\n    };\n    return Gzip;\n}());\nexport { Gzip };\n/**\n * Asynchronous streaming GZIP compression\n */\nvar AsyncGzip = /*#__PURE__*/ (function () {\n    function AsyncGzip(opts, cb) {\n        astrmify([\n            bDflt,\n            gze,\n            function () { return [astrm, Deflate, Gzip]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Gzip(ev.data);\n            onmessage = astrm(strm);\n        }, 8);\n    }\n    return AsyncGzip;\n}());\nexport { AsyncGzip };\nexport function gzip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bDflt,\n        gze,\n        function () { return [gzipSync]; }\n    ], function (ev) { return pbf(gzipSync(ev.data[0], ev.data[1])); }, 2, cb);\n}\n/**\n * Compresses data with GZIP\n * @param data The data to compress\n * @param opts The compression options\n * @returns The gzipped version of the data\n */\nexport function gzipSync(data, opts) {\n    if (!opts)\n        opts = {};\n    var c = crc(), l = data.length;\n    c.p(data);\n    var d = dopt(data, opts, gzhl(opts), 8), s = d.length;\n    return gzh(d, opts), wbytes(d, s - 8, c.d()), wbytes(d, s - 4, l), d;\n}\n/**\n * Streaming GZIP decompression\n */\nvar Gunzip = /*#__PURE__*/ (function () {\n    /**\n     * Creates a GUNZIP stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Gunzip(cb) {\n        this.v = 1;\n        Inflate.call(this, cb);\n    }\n    /**\n     * Pushes a chunk to be GUNZIPped\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Gunzip.prototype.push = function (chunk, final) {\n        Inflate.prototype.e.call(this, chunk);\n        if (this.v) {\n            var s = this.p.length > 3 ? gzs(this.p) : 4;\n            if (s >= this.p.length && !final)\n                return;\n            this.p = this.p.subarray(s), this.v = 0;\n        }\n        if (final) {\n            if (this.p.length < 8)\n                err(6, 'invalid gzip data');\n            this.p = this.p.subarray(0, -8);\n        }\n        // necessary to prevent TS from using the closure value\n        // This allows for workerization to function correctly\n        Inflate.prototype.c.call(this, final);\n    };\n    return Gunzip;\n}());\nexport { Gunzip };\n/**\n * Asynchronous streaming GZIP decompression\n */\nvar AsyncGunzip = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous GUNZIP stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncGunzip(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            guze,\n            function () { return [astrm, Inflate, Gunzip]; }\n        ], this, 0, function () {\n            var strm = new Gunzip();\n            onmessage = astrm(strm);\n        }, 9);\n    }\n    return AsyncGunzip;\n}());\nexport { AsyncGunzip };\nexport function gunzip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bInflt,\n        guze,\n        function () { return [gunzipSync]; }\n    ], function (ev) { return pbf(gunzipSync(ev.data[0])); }, 3, cb);\n}\n/**\n * Expands GZIP data\n * @param data The data to decompress\n * @param out Where to write the data. GZIP already encodes the output size, so providing this doesn't save memory.\n * @returns The decompressed version of the data\n */\nexport function gunzipSync(data, out) {\n    return inflt(data.subarray(gzs(data), -8), out || new u8(gzl(data)));\n}\n/**\n * Streaming Zlib compression\n */\nvar Zlib = /*#__PURE__*/ (function () {\n    function Zlib(opts, cb) {\n        this.c = adler();\n        this.v = 1;\n        Deflate.call(this, opts, cb);\n    }\n    /**\n     * Pushes a chunk to be zlibbed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Zlib.prototype.push = function (chunk, final) {\n        Deflate.prototype.push.call(this, chunk, final);\n    };\n    Zlib.prototype.p = function (c, f) {\n        this.c.p(c);\n        var raw = dopt(c, this.o, this.v && 2, f && 4, !f);\n        if (this.v)\n            zlh(raw, this.o), this.v = 0;\n        if (f)\n            wbytes(raw, raw.length - 4, this.c.d());\n        this.ondata(raw, f);\n    };\n    return Zlib;\n}());\nexport { Zlib };\n/**\n * Asynchronous streaming Zlib compression\n */\nvar AsyncZlib = /*#__PURE__*/ (function () {\n    function AsyncZlib(opts, cb) {\n        astrmify([\n            bDflt,\n            zle,\n            function () { return [astrm, Deflate, Zlib]; }\n        ], this, AsyncCmpStrm.call(this, opts, cb), function (ev) {\n            var strm = new Zlib(ev.data);\n            onmessage = astrm(strm);\n        }, 10);\n    }\n    return AsyncZlib;\n}());\nexport { AsyncZlib };\nexport function zlib(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bDflt,\n        zle,\n        function () { return [zlibSync]; }\n    ], function (ev) { return pbf(zlibSync(ev.data[0], ev.data[1])); }, 4, cb);\n}\n/**\n * Compress data with Zlib\n * @param data The data to compress\n * @param opts The compression options\n * @returns The zlib-compressed version of the data\n */\nexport function zlibSync(data, opts) {\n    if (!opts)\n        opts = {};\n    var a = adler();\n    a.p(data);\n    var d = dopt(data, opts, 2, 4);\n    return zlh(d, opts), wbytes(d, d.length - 4, a.d()), d;\n}\n/**\n * Streaming Zlib decompression\n */\nvar Unzlib = /*#__PURE__*/ (function () {\n    /**\n     * Creates a Zlib decompression stream\n     * @param cb The callback to call whenever data is inflated\n     */\n    function Unzlib(cb) {\n        this.v = 1;\n        Inflate.call(this, cb);\n    }\n    /**\n     * Pushes a chunk to be unzlibbed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Unzlib.prototype.push = function (chunk, final) {\n        Inflate.prototype.e.call(this, chunk);\n        if (this.v) {\n            if (this.p.length < 2 && !final)\n                return;\n            this.p = this.p.subarray(2), this.v = 0;\n        }\n        if (final) {\n            if (this.p.length < 4)\n                err(6, 'invalid zlib data');\n            this.p = this.p.subarray(0, -4);\n        }\n        // necessary to prevent TS from using the closure value\n        // This allows for workerization to function correctly\n        Inflate.prototype.c.call(this, final);\n    };\n    return Unzlib;\n}());\nexport { Unzlib };\n/**\n * Asynchronous streaming Zlib decompression\n */\nvar AsyncUnzlib = /*#__PURE__*/ (function () {\n    /**\n     * Creates an asynchronous Zlib decompression stream\n     * @param cb The callback to call whenever data is deflated\n     */\n    function AsyncUnzlib(cb) {\n        this.ondata = cb;\n        astrmify([\n            bInflt,\n            zule,\n            function () { return [astrm, Inflate, Unzlib]; }\n        ], this, 0, function () {\n            var strm = new Unzlib();\n            onmessage = astrm(strm);\n        }, 11);\n    }\n    return AsyncUnzlib;\n}());\nexport { AsyncUnzlib };\nexport function unzlib(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return cbify(data, opts, [\n        bInflt,\n        zule,\n        function () { return [unzlibSync]; }\n    ], function (ev) { return pbf(unzlibSync(ev.data[0], gu8(ev.data[1]))); }, 5, cb);\n}\n/**\n * Expands Zlib data\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function unzlibSync(data, out) {\n    return inflt((zlv(data), data.subarray(2, -4)), out);\n}\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzip as compress, AsyncGzip as AsyncCompress };\n// Default algorithm for compression (used because having a known output size allows faster decompression)\nexport { gzipSync as compressSync, Gzip as Compress };\n/**\n * Streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar Decompress = /*#__PURE__*/ (function () {\n    /**\n     * Creates a decompression stream\n     * @param cb The callback to call whenever data is decompressed\n     */\n    function Decompress(cb) {\n        this.G = Gunzip;\n        this.I = Inflate;\n        this.Z = Unzlib;\n        this.ondata = cb;\n    }\n    /**\n     * Pushes a chunk to be decompressed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Decompress.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            err(5);\n        if (!this.s) {\n            if (this.p && this.p.length) {\n                var n = new u8(this.p.length + chunk.length);\n                n.set(this.p), n.set(chunk, this.p.length);\n            }\n            else\n                this.p = chunk;\n            if (this.p.length > 2) {\n                var _this_1 = this;\n                var cb = function () { _this_1.ondata.apply(_this_1, arguments); };\n                this.s = (this.p[0] == 31 && this.p[1] == 139 && this.p[2] == 8)\n                    ? new this.G(cb)\n                    : ((this.p[0] & 15) != 8 || (this.p[0] >> 4) > 7 || ((this.p[0] << 8 | this.p[1]) % 31))\n                        ? new this.I(cb)\n                        : new this.Z(cb);\n                this.s.push(this.p, final);\n                this.p = null;\n            }\n        }\n        else\n            this.s.push(chunk, final);\n    };\n    return Decompress;\n}());\nexport { Decompress };\n/**\n * Asynchronous streaming GZIP, Zlib, or raw DEFLATE decompression\n */\nvar AsyncDecompress = /*#__PURE__*/ (function () {\n    /**\n   * Creates an asynchronous decompression stream\n   * @param cb The callback to call whenever data is decompressed\n   */\n    function AsyncDecompress(cb) {\n        this.G = AsyncGunzip;\n        this.I = AsyncInflate;\n        this.Z = AsyncUnzlib;\n        this.ondata = cb;\n    }\n    /**\n     * Pushes a chunk to be decompressed\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    AsyncDecompress.prototype.push = function (chunk, final) {\n        Decompress.prototype.push.call(this, chunk, final);\n    };\n    return AsyncDecompress;\n}());\nexport { AsyncDecompress };\nexport function decompress(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n        ? gunzip(data, opts, cb)\n        : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n            ? inflate(data, opts, cb)\n            : unzlib(data, opts, cb);\n}\n/**\n * Expands compressed GZIP, Zlib, or raw DEFLATE data, automatically detecting the format\n * @param data The data to decompress\n * @param out Where to write the data. Saves memory if you know the decompressed size and provide an output buffer of that length.\n * @returns The decompressed version of the data\n */\nexport function decompressSync(data, out) {\n    return (data[0] == 31 && data[1] == 139 && data[2] == 8)\n        ? gunzipSync(data, out)\n        : ((data[0] & 15) != 8 || (data[0] >> 4) > 7 || ((data[0] << 8 | data[1]) % 31))\n            ? inflateSync(data, out)\n            : unzlibSync(data, out);\n}\n// flatten a directory structure\nvar fltn = function (d, p, t, o) {\n    for (var k in d) {\n        var val = d[k], n = p + k, op = o;\n        if (Array.isArray(val))\n            op = mrg(o, val[1]), val = val[0];\n        if (val instanceof u8)\n            t[n] = [val, op];\n        else {\n            t[n += '/'] = [new u8(0), op];\n            fltn(val, n, t, o);\n        }\n    }\n};\n// text encoder\nvar te = typeof TextEncoder != 'undefined' && /*#__PURE__*/ new TextEncoder();\n// text decoder\nvar td = typeof TextDecoder != 'undefined' && /*#__PURE__*/ new TextDecoder();\n// text decoder stream\nvar tds = 0;\ntry {\n    td.decode(et, { stream: true });\n    tds = 1;\n}\ncatch (e) { }\n// decode UTF8\nvar dutf8 = function (d) {\n    for (var r = '', i = 0;;) {\n        var c = d[i++];\n        var eb = (c > 127) + (c > 223) + (c > 239);\n        if (i + eb > d.length)\n            return [r, slc(d, i - 1)];\n        if (!eb)\n            r += String.fromCharCode(c);\n        else if (eb == 3) {\n            c = ((c & 15) << 18 | (d[i++] & 63) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63)) - 65536,\n                r += String.fromCharCode(55296 | (c >> 10), 56320 | (c & 1023));\n        }\n        else if (eb & 1)\n            r += String.fromCharCode((c & 31) << 6 | (d[i++] & 63));\n        else\n            r += String.fromCharCode((c & 15) << 12 | (d[i++] & 63) << 6 | (d[i++] & 63));\n    }\n};\n/**\n * Streaming UTF-8 decoding\n */\nvar DecodeUTF8 = /*#__PURE__*/ (function () {\n    /**\n     * Creates a UTF-8 decoding stream\n     * @param cb The callback to call whenever data is decoded\n     */\n    function DecodeUTF8(cb) {\n        this.ondata = cb;\n        if (tds)\n            this.t = new TextDecoder();\n        else\n            this.p = et;\n    }\n    /**\n     * Pushes a chunk to be decoded from UTF-8 binary\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    DecodeUTF8.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            err(5);\n        final = !!final;\n        if (this.t) {\n            this.ondata(this.t.decode(chunk, { stream: true }), final);\n            if (final) {\n                if (this.t.decode().length)\n                    err(8);\n                this.t = null;\n            }\n            return;\n        }\n        if (!this.p)\n            err(4);\n        var dat = new u8(this.p.length + chunk.length);\n        dat.set(this.p);\n        dat.set(chunk, this.p.length);\n        var _a = dutf8(dat), ch = _a[0], np = _a[1];\n        if (final) {\n            if (np.length)\n                err(8);\n            this.p = null;\n        }\n        else\n            this.p = np;\n        this.ondata(ch, final);\n    };\n    return DecodeUTF8;\n}());\nexport { DecodeUTF8 };\n/**\n * Streaming UTF-8 encoding\n */\nvar EncodeUTF8 = /*#__PURE__*/ (function () {\n    /**\n     * Creates a UTF-8 decoding stream\n     * @param cb The callback to call whenever data is encoded\n     */\n    function EncodeUTF8(cb) {\n        this.ondata = cb;\n    }\n    /**\n     * Pushes a chunk to be encoded to UTF-8\n     * @param chunk The string data to push\n     * @param final Whether this is the last chunk\n     */\n    EncodeUTF8.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            err(5);\n        if (this.d)\n            err(4);\n        this.ondata(strToU8(chunk), this.d = final || false);\n    };\n    return EncodeUTF8;\n}());\nexport { EncodeUTF8 };\n/**\n * Converts a string into a Uint8Array for use with compression/decompression methods\n * @param str The string to encode\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n *               not need to be true unless decoding a binary string.\n * @returns The string encoded in UTF-8/Latin-1 binary\n */\nexport function strToU8(str, latin1) {\n    if (latin1) {\n        var ar_1 = new u8(str.length);\n        for (var i = 0; i < str.length; ++i)\n            ar_1[i] = str.charCodeAt(i);\n        return ar_1;\n    }\n    if (te)\n        return te.encode(str);\n    var l = str.length;\n    var ar = new u8(str.length + (str.length >> 1));\n    var ai = 0;\n    var w = function (v) { ar[ai++] = v; };\n    for (var i = 0; i < l; ++i) {\n        if (ai + 5 > ar.length) {\n            var n = new u8(ai + 8 + ((l - i) << 1));\n            n.set(ar);\n            ar = n;\n        }\n        var c = str.charCodeAt(i);\n        if (c < 128 || latin1)\n            w(c);\n        else if (c < 2048)\n            w(192 | (c >> 6)), w(128 | (c & 63));\n        else if (c > 55295 && c < 57344)\n            c = 65536 + (c & 1023 << 10) | (str.charCodeAt(++i) & 1023),\n                w(240 | (c >> 18)), w(128 | ((c >> 12) & 63)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n        else\n            w(224 | (c >> 12)), w(128 | ((c >> 6) & 63)), w(128 | (c & 63));\n    }\n    return slc(ar, 0, ai);\n}\n/**\n * Converts a Uint8Array to a string\n * @param dat The data to decode to string\n * @param latin1 Whether or not to interpret the data as Latin-1. This should\n *               not need to be true unless encoding to binary string.\n * @returns The original UTF-8/Latin-1 string\n */\nexport function strFromU8(dat, latin1) {\n    if (latin1) {\n        var r = '';\n        for (var i = 0; i < dat.length; i += 16384)\n            r += String.fromCharCode.apply(null, dat.subarray(i, i + 16384));\n        return r;\n    }\n    else if (td)\n        return td.decode(dat);\n    else {\n        var _a = dutf8(dat), out = _a[0], ext = _a[1];\n        if (ext.length)\n            err(8);\n        return out;\n    }\n}\n;\n// deflate bit flag\nvar dbf = function (l) { return l == 1 ? 3 : l < 6 ? 2 : l == 9 ? 1 : 0; };\n// skip local zip header\nvar slzh = function (d, b) { return b + 30 + b2(d, b + 26) + b2(d, b + 28); };\n// read zip header\nvar zh = function (d, b, z) {\n    var fnl = b2(d, b + 28), fn = strFromU8(d.subarray(b + 46, b + 46 + fnl), !(b2(d, b + 8) & 2048)), es = b + 46 + fnl, bs = b4(d, b + 20);\n    var _a = z && bs == 4294967295 ? z64e(d, es) : [bs, b4(d, b + 24), b4(d, b + 42)], sc = _a[0], su = _a[1], off = _a[2];\n    return [b2(d, b + 10), sc, su, fn, es + b2(d, b + 30) + b2(d, b + 32), off];\n};\n// read zip64 extra field\nvar z64e = function (d, b) {\n    for (; b2(d, b) != 1; b += 4 + b2(d, b + 2))\n        ;\n    return [b8(d, b + 12), b8(d, b + 4), b8(d, b + 20)];\n};\n// extra field length\nvar exfl = function (ex) {\n    var le = 0;\n    if (ex) {\n        for (var k in ex) {\n            var l = ex[k].length;\n            if (l > 65535)\n                err(9);\n            le += l + 4;\n        }\n    }\n    return le;\n};\n// write zip header\nvar wzh = function (d, b, f, fn, u, c, ce, co) {\n    var fl = fn.length, ex = f.extra, col = co && co.length;\n    var exl = exfl(ex);\n    wbytes(d, b, ce != null ? 0x2014B50 : 0x4034B50), b += 4;\n    if (ce != null)\n        d[b++] = 20, d[b++] = f.os;\n    d[b] = 20, b += 2; // spec compliance? what's that?\n    d[b++] = (f.flag << 1) | (c == null && 8), d[b++] = u && 8;\n    d[b++] = f.compression & 255, d[b++] = f.compression >> 8;\n    var dt = new Date(f.mtime == null ? Date.now() : f.mtime), y = dt.getFullYear() - 1980;\n    if (y < 0 || y > 119)\n        err(10);\n    wbytes(d, b, (y << 25) | ((dt.getMonth() + 1) << 21) | (dt.getDate() << 16) | (dt.getHours() << 11) | (dt.getMinutes() << 5) | (dt.getSeconds() >>> 1)), b += 4;\n    if (c != null) {\n        wbytes(d, b, f.crc);\n        wbytes(d, b + 4, c);\n        wbytes(d, b + 8, f.size);\n    }\n    wbytes(d, b + 12, fl);\n    wbytes(d, b + 14, exl), b += 16;\n    if (ce != null) {\n        wbytes(d, b, col);\n        wbytes(d, b + 6, f.attrs);\n        wbytes(d, b + 10, ce), b += 14;\n    }\n    d.set(fn, b);\n    b += fl;\n    if (exl) {\n        for (var k in ex) {\n            var exf = ex[k], l = exf.length;\n            wbytes(d, b, +k);\n            wbytes(d, b + 2, l);\n            d.set(exf, b + 4), b += 4 + l;\n        }\n    }\n    if (col)\n        d.set(co, b), b += col;\n    return b;\n};\n// write zip footer (end of central directory)\nvar wzf = function (o, b, c, d, e) {\n    wbytes(o, b, 0x6054B50); // skip disk\n    wbytes(o, b + 8, c);\n    wbytes(o, b + 10, c);\n    wbytes(o, b + 12, d);\n    wbytes(o, b + 16, e);\n};\n/**\n * A pass-through stream to keep data uncompressed in a ZIP archive.\n */\nvar ZipPassThrough = /*#__PURE__*/ (function () {\n    /**\n     * Creates a pass-through stream that can be added to ZIP archives\n     * @param filename The filename to associate with this data stream\n     */\n    function ZipPassThrough(filename) {\n        this.filename = filename;\n        this.c = crc();\n        this.size = 0;\n        this.compression = 0;\n    }\n    /**\n     * Processes a chunk and pushes to the output stream. You can override this\n     * method in a subclass for custom behavior, but by default this passes\n     * the data through. You must call this.ondata(err, chunk, final) at some\n     * point in this method.\n     * @param chunk The chunk to process\n     * @param final Whether this is the last chunk\n     */\n    ZipPassThrough.prototype.process = function (chunk, final) {\n        this.ondata(null, chunk, final);\n    };\n    /**\n     * Pushes a chunk to be added. If you are subclassing this with a custom\n     * compression algorithm, note that you must push data from the source\n     * file only, pre-compression.\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    ZipPassThrough.prototype.push = function (chunk, final) {\n        if (!this.ondata)\n            err(5);\n        this.c.p(chunk);\n        this.size += chunk.length;\n        if (final)\n            this.crc = this.c.d();\n        this.process(chunk, final || false);\n    };\n    return ZipPassThrough;\n}());\nexport { ZipPassThrough };\n// I don't extend because TypeScript extension adds 1kB of runtime bloat\n/**\n * Streaming DEFLATE compression for ZIP archives. Prefer using AsyncZipDeflate\n * for better performance\n */\nvar ZipDeflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates a DEFLATE stream that can be added to ZIP archives\n     * @param filename The filename to associate with this data stream\n     * @param opts The compression options\n     */\n    function ZipDeflate(filename, opts) {\n        var _this_1 = this;\n        if (!opts)\n            opts = {};\n        ZipPassThrough.call(this, filename);\n        this.d = new Deflate(opts, function (dat, final) {\n            _this_1.ondata(null, dat, final);\n        });\n        this.compression = 8;\n        this.flag = dbf(opts.level);\n    }\n    ZipDeflate.prototype.process = function (chunk, final) {\n        try {\n            this.d.push(chunk, final);\n        }\n        catch (e) {\n            this.ondata(e, null, final);\n        }\n    };\n    /**\n     * Pushes a chunk to be deflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    ZipDeflate.prototype.push = function (chunk, final) {\n        ZipPassThrough.prototype.push.call(this, chunk, final);\n    };\n    return ZipDeflate;\n}());\nexport { ZipDeflate };\n/**\n * Asynchronous streaming DEFLATE compression for ZIP archives\n */\nvar AsyncZipDeflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates a DEFLATE stream that can be added to ZIP archives\n     * @param filename The filename to associate with this data stream\n     * @param opts The compression options\n     */\n    function AsyncZipDeflate(filename, opts) {\n        var _this_1 = this;\n        if (!opts)\n            opts = {};\n        ZipPassThrough.call(this, filename);\n        this.d = new AsyncDeflate(opts, function (err, dat, final) {\n            _this_1.ondata(err, dat, final);\n        });\n        this.compression = 8;\n        this.flag = dbf(opts.level);\n        this.terminate = this.d.terminate;\n    }\n    AsyncZipDeflate.prototype.process = function (chunk, final) {\n        this.d.push(chunk, final);\n    };\n    /**\n     * Pushes a chunk to be deflated\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    AsyncZipDeflate.prototype.push = function (chunk, final) {\n        ZipPassThrough.prototype.push.call(this, chunk, final);\n    };\n    return AsyncZipDeflate;\n}());\nexport { AsyncZipDeflate };\n// TODO: Better tree shaking\n/**\n * A zippable archive to which files can incrementally be added\n */\nvar Zip = /*#__PURE__*/ (function () {\n    /**\n     * Creates an empty ZIP archive to which files can be added\n     * @param cb The callback to call whenever data for the generated ZIP archive\n     *           is available\n     */\n    function Zip(cb) {\n        this.ondata = cb;\n        this.u = [];\n        this.d = 1;\n    }\n    /**\n     * Adds a file to the ZIP archive\n     * @param file The file stream to add\n     */\n    Zip.prototype.add = function (file) {\n        var _this_1 = this;\n        if (!this.ondata)\n            err(5);\n        // finishing or finished\n        if (this.d & 2)\n            this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, false);\n        else {\n            var f = strToU8(file.filename), fl_1 = f.length;\n            var com = file.comment, o = com && strToU8(com);\n            var u = fl_1 != file.filename.length || (o && (com.length != o.length));\n            var hl_1 = fl_1 + exfl(file.extra) + 30;\n            if (fl_1 > 65535)\n                this.ondata(err(11, 0, 1), null, false);\n            var header = new u8(hl_1);\n            wzh(header, 0, file, f, u);\n            var chks_1 = [header];\n            var pAll_1 = function () {\n                for (var _i = 0, chks_2 = chks_1; _i < chks_2.length; _i++) {\n                    var chk = chks_2[_i];\n                    _this_1.ondata(null, chk, false);\n                }\n                chks_1 = [];\n            };\n            var tr_1 = this.d;\n            this.d = 0;\n            var ind_1 = this.u.length;\n            var uf_1 = mrg(file, {\n                f: f,\n                u: u,\n                o: o,\n                t: function () {\n                    if (file.terminate)\n                        file.terminate();\n                },\n                r: function () {\n                    pAll_1();\n                    if (tr_1) {\n                        var nxt = _this_1.u[ind_1 + 1];\n                        if (nxt)\n                            nxt.r();\n                        else\n                            _this_1.d = 1;\n                    }\n                    tr_1 = 1;\n                }\n            });\n            var cl_1 = 0;\n            file.ondata = function (err, dat, final) {\n                if (err) {\n                    _this_1.ondata(err, dat, final);\n                    _this_1.terminate();\n                }\n                else {\n                    cl_1 += dat.length;\n                    chks_1.push(dat);\n                    if (final) {\n                        var dd = new u8(16);\n                        wbytes(dd, 0, 0x8074B50);\n                        wbytes(dd, 4, file.crc);\n                        wbytes(dd, 8, cl_1);\n                        wbytes(dd, 12, file.size);\n                        chks_1.push(dd);\n                        uf_1.c = cl_1, uf_1.b = hl_1 + cl_1 + 16, uf_1.crc = file.crc, uf_1.size = file.size;\n                        if (tr_1)\n                            uf_1.r();\n                        tr_1 = 1;\n                    }\n                    else if (tr_1)\n                        pAll_1();\n                }\n            };\n            this.u.push(uf_1);\n        }\n    };\n    /**\n     * Ends the process of adding files and prepares to emit the final chunks.\n     * This *must* be called after adding all desired files for the resulting\n     * ZIP file to work properly.\n     */\n    Zip.prototype.end = function () {\n        var _this_1 = this;\n        if (this.d & 2) {\n            this.ondata(err(4 + (this.d & 1) * 8, 0, 1), null, true);\n            return;\n        }\n        if (this.d)\n            this.e();\n        else\n            this.u.push({\n                r: function () {\n                    if (!(_this_1.d & 1))\n                        return;\n                    _this_1.u.splice(-1, 1);\n                    _this_1.e();\n                },\n                t: function () { }\n            });\n        this.d = 3;\n    };\n    Zip.prototype.e = function () {\n        var bt = 0, l = 0, tl = 0;\n        for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n            var f = _a[_i];\n            tl += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0);\n        }\n        var out = new u8(tl + 22);\n        for (var _b = 0, _c = this.u; _b < _c.length; _b++) {\n            var f = _c[_b];\n            wzh(out, bt, f, f.f, f.u, f.c, l, f.o);\n            bt += 46 + f.f.length + exfl(f.extra) + (f.o ? f.o.length : 0), l += f.b;\n        }\n        wzf(out, bt, this.u.length, tl, l);\n        this.ondata(null, out, true);\n        this.d = 2;\n    };\n    /**\n     * A method to terminate any internal workers used by the stream. Subsequent\n     * calls to add() will fail.\n     */\n    Zip.prototype.terminate = function () {\n        for (var _i = 0, _a = this.u; _i < _a.length; _i++) {\n            var f = _a[_i];\n            f.t();\n        }\n        this.d = 2;\n    };\n    return Zip;\n}());\nexport { Zip };\nexport function zip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    var r = {};\n    fltn(data, '', r, opts);\n    var k = Object.keys(r);\n    var lft = k.length, o = 0, tot = 0;\n    var slft = lft, files = new Array(lft);\n    var term = [];\n    var tAll = function () {\n        for (var i = 0; i < term.length; ++i)\n            term[i]();\n    };\n    var cbd = function (a, b) {\n        mt(function () { cb(a, b); });\n    };\n    mt(function () { cbd = cb; });\n    var cbf = function () {\n        var out = new u8(tot + 22), oe = o, cdl = tot - o;\n        tot = 0;\n        for (var i = 0; i < slft; ++i) {\n            var f = files[i];\n            try {\n                var l = f.c.length;\n                wzh(out, tot, f, f.f, f.u, l);\n                var badd = 30 + f.f.length + exfl(f.extra);\n                var loc = tot + badd;\n                out.set(f.c, loc);\n                wzh(out, o, f, f.f, f.u, l, tot, f.m), o += 16 + badd + (f.m ? f.m.length : 0), tot = loc + l;\n            }\n            catch (e) {\n                return cbd(e, null);\n            }\n        }\n        wzf(out, o, files.length, cdl, oe);\n        cbd(null, out);\n    };\n    if (!lft)\n        cbf();\n    var _loop_1 = function (i) {\n        var fn = k[i];\n        var _a = r[fn], file = _a[0], p = _a[1];\n        var c = crc(), size = file.length;\n        c.p(file);\n        var f = strToU8(fn), s = f.length;\n        var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n        var exl = exfl(p.extra);\n        var compression = p.level == 0 ? 0 : 8;\n        var cbl = function (e, d) {\n            if (e) {\n                tAll();\n                cbd(e, null);\n            }\n            else {\n                var l = d.length;\n                files[i] = mrg(p, {\n                    size: size,\n                    crc: c.d(),\n                    c: d,\n                    f: f,\n                    m: m,\n                    u: s != fn.length || (m && (com.length != ms)),\n                    compression: compression\n                });\n                o += 30 + s + exl + l;\n                tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n                if (!--lft)\n                    cbf();\n            }\n        };\n        if (s > 65535)\n            cbl(err(11, 0, 1), null);\n        if (!compression)\n            cbl(null, file);\n        else if (size < 160000) {\n            try {\n                cbl(null, deflateSync(file, p));\n            }\n            catch (e) {\n                cbl(e, null);\n            }\n        }\n        else\n            term.push(deflate(file, p, cbl));\n    };\n    // Cannot use lft because it can decrease\n    for (var i = 0; i < slft; ++i) {\n        _loop_1(i);\n    }\n    return tAll;\n}\n/**\n * Synchronously creates a ZIP file. Prefer using `zip` for better performance\n * with more than one file.\n * @param data The directory structure for the ZIP archive\n * @param opts The main options, merged with per-file options\n * @returns The generated ZIP archive\n */\nexport function zipSync(data, opts) {\n    if (!opts)\n        opts = {};\n    var r = {};\n    var files = [];\n    fltn(data, '', r, opts);\n    var o = 0;\n    var tot = 0;\n    for (var fn in r) {\n        var _a = r[fn], file = _a[0], p = _a[1];\n        var compression = p.level == 0 ? 0 : 8;\n        var f = strToU8(fn), s = f.length;\n        var com = p.comment, m = com && strToU8(com), ms = m && m.length;\n        var exl = exfl(p.extra);\n        if (s > 65535)\n            err(11);\n        var d = compression ? deflateSync(file, p) : file, l = d.length;\n        var c = crc();\n        c.p(file);\n        files.push(mrg(p, {\n            size: file.length,\n            crc: c.d(),\n            c: d,\n            f: f,\n            m: m,\n            u: s != fn.length || (m && (com.length != ms)),\n            o: o,\n            compression: compression\n        }));\n        o += 30 + s + exl + l;\n        tot += 76 + 2 * (s + exl) + (ms || 0) + l;\n    }\n    var out = new u8(tot + 22), oe = o, cdl = tot - o;\n    for (var i = 0; i < files.length; ++i) {\n        var f = files[i];\n        wzh(out, f.o, f, f.f, f.u, f.c.length);\n        var badd = 30 + f.f.length + exfl(f.extra);\n        out.set(f.c, f.o + badd);\n        wzh(out, o, f, f.f, f.u, f.c.length, f.o, f.m), o += 16 + badd + (f.m ? f.m.length : 0);\n    }\n    wzf(out, o, files.length, cdl, oe);\n    return out;\n}\n/**\n * Streaming pass-through decompression for ZIP archives\n */\nvar UnzipPassThrough = /*#__PURE__*/ (function () {\n    function UnzipPassThrough() {\n    }\n    UnzipPassThrough.prototype.push = function (data, final) {\n        this.ondata(null, data, final);\n    };\n    UnzipPassThrough.compression = 0;\n    return UnzipPassThrough;\n}());\nexport { UnzipPassThrough };\n/**\n * Streaming DEFLATE decompression for ZIP archives. Prefer AsyncZipInflate for\n * better performance.\n */\nvar UnzipInflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates a DEFLATE decompression that can be used in ZIP archives\n     */\n    function UnzipInflate() {\n        var _this_1 = this;\n        this.i = new Inflate(function (dat, final) {\n            _this_1.ondata(null, dat, final);\n        });\n    }\n    UnzipInflate.prototype.push = function (data, final) {\n        try {\n            this.i.push(data, final);\n        }\n        catch (e) {\n            this.ondata(e, null, final);\n        }\n    };\n    UnzipInflate.compression = 8;\n    return UnzipInflate;\n}());\nexport { UnzipInflate };\n/**\n * Asynchronous streaming DEFLATE decompression for ZIP archives\n */\nvar AsyncUnzipInflate = /*#__PURE__*/ (function () {\n    /**\n     * Creates a DEFLATE decompression that can be used in ZIP archives\n     */\n    function AsyncUnzipInflate(_, sz) {\n        var _this_1 = this;\n        if (sz < 320000) {\n            this.i = new Inflate(function (dat, final) {\n                _this_1.ondata(null, dat, final);\n            });\n        }\n        else {\n            this.i = new AsyncInflate(function (err, dat, final) {\n                _this_1.ondata(err, dat, final);\n            });\n            this.terminate = this.i.terminate;\n        }\n    }\n    AsyncUnzipInflate.prototype.push = function (data, final) {\n        if (this.i.terminate)\n            data = slc(data, 0);\n        this.i.push(data, final);\n    };\n    AsyncUnzipInflate.compression = 8;\n    return AsyncUnzipInflate;\n}());\nexport { AsyncUnzipInflate };\n/**\n * A ZIP archive decompression stream that emits files as they are discovered\n */\nvar Unzip = /*#__PURE__*/ (function () {\n    /**\n     * Creates a ZIP decompression stream\n     * @param cb The callback to call whenever a file in the ZIP archive is found\n     */\n    function Unzip(cb) {\n        this.onfile = cb;\n        this.k = [];\n        this.o = {\n            0: UnzipPassThrough\n        };\n        this.p = et;\n    }\n    /**\n     * Pushes a chunk to be unzipped\n     * @param chunk The chunk to push\n     * @param final Whether this is the last chunk\n     */\n    Unzip.prototype.push = function (chunk, final) {\n        var _this_1 = this;\n        if (!this.onfile)\n            err(5);\n        if (!this.p)\n            err(4);\n        if (this.c > 0) {\n            var len = Math.min(this.c, chunk.length);\n            var toAdd = chunk.subarray(0, len);\n            this.c -= len;\n            if (this.d)\n                this.d.push(toAdd, !this.c);\n            else\n                this.k[0].push(toAdd);\n            chunk = chunk.subarray(len);\n            if (chunk.length)\n                return this.push(chunk, final);\n        }\n        else {\n            var f = 0, i = 0, is = void 0, buf = void 0;\n            if (!this.p.length)\n                buf = chunk;\n            else if (!chunk.length)\n                buf = this.p;\n            else {\n                buf = new u8(this.p.length + chunk.length);\n                buf.set(this.p), buf.set(chunk, this.p.length);\n            }\n            var l = buf.length, oc = this.c, add = oc && this.d;\n            var _loop_2 = function () {\n                var _a;\n                var sig = b4(buf, i);\n                if (sig == 0x4034B50) {\n                    f = 1, is = i;\n                    this_1.d = null;\n                    this_1.c = 0;\n                    var bf = b2(buf, i + 6), cmp_1 = b2(buf, i + 8), u = bf & 2048, dd = bf & 8, fnl = b2(buf, i + 26), es = b2(buf, i + 28);\n                    if (l > i + 30 + fnl + es) {\n                        var chks_3 = [];\n                        this_1.k.unshift(chks_3);\n                        f = 2;\n                        var sc_1 = b4(buf, i + 18), su_1 = b4(buf, i + 22);\n                        var fn_1 = strFromU8(buf.subarray(i + 30, i += 30 + fnl), !u);\n                        if (sc_1 == 4294967295) {\n                            _a = dd ? [-2] : z64e(buf, i), sc_1 = _a[0], su_1 = _a[1];\n                        }\n                        else if (dd)\n                            sc_1 = -1;\n                        i += es;\n                        this_1.c = sc_1;\n                        var d_1;\n                        var file_1 = {\n                            name: fn_1,\n                            compression: cmp_1,\n                            start: function () {\n                                if (!file_1.ondata)\n                                    err(5);\n                                if (!sc_1)\n                                    file_1.ondata(null, et, true);\n                                else {\n                                    var ctr = _this_1.o[cmp_1];\n                                    if (!ctr)\n                                        file_1.ondata(err(14, 'unknown compression type ' + cmp_1, 1), null, false);\n                                    d_1 = sc_1 < 0 ? new ctr(fn_1) : new ctr(fn_1, sc_1, su_1);\n                                    d_1.ondata = function (err, dat, final) { file_1.ondata(err, dat, final); };\n                                    for (var _i = 0, chks_4 = chks_3; _i < chks_4.length; _i++) {\n                                        var dat = chks_4[_i];\n                                        d_1.push(dat, false);\n                                    }\n                                    if (_this_1.k[0] == chks_3 && _this_1.c)\n                                        _this_1.d = d_1;\n                                    else\n                                        d_1.push(et, true);\n                                }\n                            },\n                            terminate: function () {\n                                if (d_1 && d_1.terminate)\n                                    d_1.terminate();\n                            }\n                        };\n                        if (sc_1 >= 0)\n                            file_1.size = sc_1, file_1.originalSize = su_1;\n                        this_1.onfile(file_1);\n                    }\n                    return \"break\";\n                }\n                else if (oc) {\n                    if (sig == 0x8074B50) {\n                        is = i += 12 + (oc == -2 && 8), f = 3, this_1.c = 0;\n                        return \"break\";\n                    }\n                    else if (sig == 0x2014B50) {\n                        is = i -= 4, f = 3, this_1.c = 0;\n                        return \"break\";\n                    }\n                }\n            };\n            var this_1 = this;\n            for (; i < l - 4; ++i) {\n                var state_1 = _loop_2();\n                if (state_1 === \"break\")\n                    break;\n            }\n            this.p = et;\n            if (oc < 0) {\n                var dat = f ? buf.subarray(0, is - 12 - (oc == -2 && 8) - (b4(buf, is - 16) == 0x8074B50 && 4)) : buf.subarray(0, i);\n                if (add)\n                    add.push(dat, !!f);\n                else\n                    this.k[+(f == 2)].push(dat);\n            }\n            if (f & 2)\n                return this.push(buf.subarray(i), final);\n            this.p = buf.subarray(i);\n        }\n        if (final) {\n            if (this.c)\n                err(13);\n            this.p = null;\n        }\n    };\n    /**\n     * Registers a decoder with the stream, allowing for files compressed with\n     * the compression type provided to be expanded correctly\n     * @param decoder The decoder constructor\n     */\n    Unzip.prototype.register = function (decoder) {\n        this.o[decoder.compression] = decoder;\n    };\n    return Unzip;\n}());\nexport { Unzip };\nvar mt = typeof queueMicrotask == 'function' ? queueMicrotask : typeof setTimeout == 'function' ? setTimeout : function (fn) { fn(); };\nexport function unzip(data, opts, cb) {\n    if (!cb)\n        cb = opts, opts = {};\n    if (typeof cb != 'function')\n        err(7);\n    var term = [];\n    var tAll = function () {\n        for (var i = 0; i < term.length; ++i)\n            term[i]();\n    };\n    var files = {};\n    var cbd = function (a, b) {\n        mt(function () { cb(a, b); });\n    };\n    mt(function () { cbd = cb; });\n    var e = data.length - 22;\n    for (; b4(data, e) != 0x6054B50; --e) {\n        if (!e || data.length - e > 65558) {\n            cbd(err(13, 0, 1), null);\n            return tAll;\n        }\n    }\n    ;\n    var lft = b2(data, e + 8);\n    if (lft) {\n        var c = lft;\n        var o = b4(data, e + 16);\n        var z = o == 4294967295;\n        if (z) {\n            e = b4(data, e - 12);\n            if (b4(data, e) != 0x6064B50) {\n                cbd(err(13, 0, 1), null);\n                return tAll;\n            }\n            c = lft = b4(data, e + 32);\n            o = b4(data, e + 48);\n        }\n        var fltr = opts && opts.filter;\n        var _loop_3 = function (i) {\n            var _a = zh(data, o, z), c_1 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n            o = no;\n            var cbl = function (e, d) {\n                if (e) {\n                    tAll();\n                    cbd(e, null);\n                }\n                else {\n                    if (d)\n                        files[fn] = d;\n                    if (!--lft)\n                        cbd(null, files);\n                }\n            };\n            if (!fltr || fltr({\n                name: fn,\n                size: sc,\n                originalSize: su,\n                compression: c_1\n            })) {\n                if (!c_1)\n                    cbl(null, slc(data, b, b + sc));\n                else if (c_1 == 8) {\n                    var infl = data.subarray(b, b + sc);\n                    if (sc < 320000) {\n                        try {\n                            cbl(null, inflateSync(infl, new u8(su)));\n                        }\n                        catch (e) {\n                            cbl(e, null);\n                        }\n                    }\n                    else\n                        term.push(inflate(infl, { size: su }, cbl));\n                }\n                else\n                    cbl(err(14, 'unknown compression type ' + c_1, 1), null);\n            }\n            else\n                cbl(null, null);\n        };\n        for (var i = 0; i < c; ++i) {\n            _loop_3(i);\n        }\n    }\n    else\n        cbd(null, {});\n    return tAll;\n}\n/**\n * Synchronously decompresses a ZIP archive. Prefer using `unzip` for better\n * performance with more than one file.\n * @param data The raw compressed ZIP file\n * @param opts The ZIP extraction options\n * @returns The decompressed files\n */\nexport function unzipSync(data, opts) {\n    var files = {};\n    var e = data.length - 22;\n    for (; b4(data, e) != 0x6054B50; --e) {\n        if (!e || data.length - e > 65558)\n            err(13);\n    }\n    ;\n    var c = b2(data, e + 8);\n    if (!c)\n        return {};\n    var o = b4(data, e + 16);\n    var z = o == 4294967295;\n    if (z) {\n        e = b4(data, e - 12);\n        if (b4(data, e) != 0x6064B50)\n            err(13);\n        c = b4(data, e + 32);\n        o = b4(data, e + 48);\n    }\n    var fltr = opts && opts.filter;\n    for (var i = 0; i < c; ++i) {\n        var _a = zh(data, o, z), c_2 = _a[0], sc = _a[1], su = _a[2], fn = _a[3], no = _a[4], off = _a[5], b = slzh(data, off);\n        o = no;\n        if (!fltr || fltr({\n            name: fn,\n            size: sc,\n            originalSize: su,\n            compression: c_2\n        })) {\n            if (!c_2)\n                files[fn] = slc(data, b, b + sc);\n            else if (c_2 == 8)\n                files[fn] = inflateSync(data.subarray(b, b + sc), new u8(su));\n            else\n                err(14, 'unknown compression type ' + c_2);\n        }\n    }\n    return files;\n}\n","/* eslint-disable no-bitwise */\n// ----------------------------------------------------------------------------\n// Decoding infrastructure\n// ----------------------------------------------------------------------------\nvar REVERSE_LOOKUP = [];\nREVERSE_LOOKUP['-'.charCodeAt(0)] = 62;\nREVERSE_LOOKUP['_'.charCodeAt(0)] = 63;\nvar BASE64_CODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';\n\nfor (var i = 0; i < BASE64_CODE.length; i++) {\n  REVERSE_LOOKUP[BASE64_CODE.charCodeAt(i)] = i;\n} // ----------------------------------------------------------------------------\n// Base64 analysis\n// ----------------------------------------------------------------------------\n\n\nfunction isValidChar(c) {\n  return REVERSE_LOOKUP[c.charCodeAt(0)] !== undefined;\n}\n\nfunction extractChunks(b64Str) {\n  var strSize = b64Str.length;\n  var chunks = [];\n  var currentChunk = null;\n\n  for (var _i = 0; _i < strSize; _i++) {\n    if (isValidChar(b64Str[_i])) {\n      if (!currentChunk) {\n        currentChunk = {\n          start: _i,\n          count: 0\n        };\n      }\n\n      currentChunk.count++;\n      currentChunk.end = _i;\n    } else if (b64Str[_i] === '=' && currentChunk) {\n      // End of chunk (found padding char)\n      chunks.push(currentChunk);\n      currentChunk = null;\n    }\n  }\n\n  if (currentChunk) {\n    chunks.push(currentChunk);\n  }\n\n  return chunks;\n}\n\nfunction writeChunk(b64Str, chunk, dstOffset, uint8) {\n  var start = chunk.start,\n      count = chunk.count;\n  var remain = count % 4;\n  var fourCharProcessCount = Math.floor(count / 4);\n  var charIdx = start;\n  var tmp = null;\n  var offset = dstOffset; // Handle 4=>3\n\n  for (var _i2 = 0; _i2 < fourCharProcessCount; _i2++) {\n    while (!isValidChar(b64Str[charIdx])) {\n      charIdx++;\n    }\n\n    tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 18;\n\n    while (!isValidChar(b64Str[charIdx])) {\n      charIdx++;\n    }\n\n    tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 12;\n\n    while (!isValidChar(b64Str[charIdx])) {\n      charIdx++;\n    }\n\n    tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 6;\n\n    while (!isValidChar(b64Str[charIdx])) {\n      charIdx++;\n    }\n\n    tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)];\n    uint8[offset++] = tmp >> 16 & 0xff;\n    uint8[offset++] = tmp >> 8 & 0xff;\n    uint8[offset++] = tmp & 0xff;\n  } // Handle remain\n\n\n  switch (remain) {\n    case 3:\n      while (!isValidChar(b64Str[charIdx])) {\n        charIdx++;\n      }\n\n      tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 10;\n\n      while (!isValidChar(b64Str[charIdx])) {\n        charIdx++;\n      }\n\n      tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 4;\n\n      while (!isValidChar(b64Str[charIdx])) {\n        charIdx++;\n      }\n\n      tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] >> 2;\n      uint8[offset++] = tmp >> 8 & 0xff;\n      uint8[offset++] = tmp & 0xff;\n      break;\n\n    case 2:\n      while (!isValidChar(b64Str[charIdx])) {\n        charIdx++;\n      }\n\n      tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 2;\n\n      while (!isValidChar(b64Str[charIdx])) {\n        charIdx++;\n      }\n\n      tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] >> 4;\n      uint8[offset++] = tmp & 0xff;\n      break;\n\n    case 1:\n      throw new Error('BASE64: remain 1 should not happen');\n  }\n\n  return offset;\n}\n\nfunction toArrayBuffer(b64Str) {\n  var chunks = extractChunks(b64Str);\n  var totalEncodedLength = chunks[chunks.length - 1].end + 1;\n  var padding = (4 - totalEncodedLength % 4) % 4; // -length mod 4\n  // Any padding chars in the middle of b64Str is to be interpreted as \\x00,\n  // whereas the terminating padding chars are to be interpreted as literal padding.\n\n  var totalSize = (totalEncodedLength + padding) * 3 / 4 - padding;\n  var arrayBuffer = new ArrayBuffer(totalSize);\n  var view = new Uint8Array(arrayBuffer);\n  var dstOffset = 0;\n\n  for (var _i3 = 0; _i3 < chunks.length; _i3++) {\n    dstOffset += writeChunk(b64Str, chunks[_i3], dstOffset, view);\n    dstOffset += (4 - chunks[_i3].count % 4) % 4;\n  }\n\n  return arrayBuffer;\n}\n\nfunction encodeTriplet(v1, v2, v3) {\n  var triplet = (v1 << 16) + (v2 << 8) + v3;\n  return BASE64_CODE[triplet >> 18] + BASE64_CODE[triplet >> 12 & 0x3f] + BASE64_CODE[triplet >> 6 & 0x3f] + BASE64_CODE[triplet & 0x3f];\n}\n\nfunction fromArrayBuffer(ab) {\n  var uint8 = new Uint8Array(ab);\n  var leftoverLength = ab.byteLength % 3;\n  var maxTripletIndex = ab.byteLength - leftoverLength;\n  var segments = Array(maxTripletIndex / 3);\n\n  for (var _i4 = 0; _i4 < segments.length; _i4++) {\n    var bufOffset = _i4 * 3;\n    segments[_i4] = encodeTriplet(uint8[bufOffset], uint8[bufOffset + 1], uint8[bufOffset + 2]);\n  }\n\n  if (leftoverLength > 0) {\n    var segment = encodeTriplet(uint8[maxTripletIndex], uint8[maxTripletIndex + 1] || 0, uint8[maxTripletIndex + 2] || 0);\n\n    if (leftoverLength === 1) {\n      segments.push(\"\".concat(segment.substr(0, 2), \"==\"));\n    } else if (leftoverLength === 2) {\n      segments.push(\"\".concat(segment.substr(0, 3), \"=\"));\n    }\n  }\n\n  return segments.join('');\n}\nvar Base64 = {\n  toArrayBuffer: toArrayBuffer,\n  fromArrayBuffer: fromArrayBuffer\n};\n\nexport { Base64 as default, fromArrayBuffer, toArrayBuffer };\n","import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';\nimport { create } from 'xmlbuilder2';\nimport { decompressSync } from 'fflate';\nimport DataAccessHelper from '../Core/DataAccessHelper.js';\nimport Base64 from '../../Common/Core/Base64.js';\nimport macro from '../../macros.js';\nimport vtkDataArray from '../../Common/Core/DataArray.js';\nimport BinaryHelper from '../Core/BinaryHelper.js';\nimport '../Core/DataAccessHelper/LiteHttpDataAccessHelper.js';\n\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HttpDataAccessHelper'; // HTTP + zip\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/HtmlDataAccessHelper'; // html + base64 + zip\n// import 'vtk.js/Sources/IO/Core/DataAccessHelper/JSZipDataAccessHelper'; // zip\n// ----------------------------------------------------------------------------\n// Global methods\n// ----------------------------------------------------------------------------\n\nfunction findAllTags(node, tagName) {\n  return _toConsumableArray(node.getElementsByTagName(tagName));\n}\nfunction findFirstTag(node, tagName) {\n  return findAllTags(node, tagName)[0];\n}\n\nfunction parseXML(xmlStr) {\n  // see xmlbuilder2 docs on the object format\n  return create(xmlStr);\n}\n\nfunction extractAppendedData(buffer) {\n  // search for appended data tag\n  var prefixRegex = /^\\s*<AppendedData\\s+encoding=\"raw\">\\s*_/m;\n  var suffixRegex = /\\n\\s*<\\/AppendedData>/m;\n  return BinaryHelper.extractBinary(buffer, prefixRegex, suffixRegex);\n} // ----------------------------------------------------------------------------\n\n\nvar TYPED_ARRAY = {\n  Int8: Int8Array,\n  UInt8: Uint8Array,\n  Int16: Int16Array,\n  UInt16: Uint16Array,\n  Int32: Int32Array,\n  UInt32: Uint32Array,\n  Int64: Int32Array,\n  // Not supported with JavaScript will cause error in binary\n  UInt64: Uint32Array,\n  // Not supported with JavaScript will cause error in binary\n  Float32: Float32Array,\n  Float64: Float64Array\n}; // ----------------------------------------------------------------------------\n\nvar TYPED_ARRAY_BYTES = {\n  Int8: 1,\n  UInt8: 1,\n  Int16: 2,\n  UInt16: 2,\n  Int32: 4,\n  UInt32: 4,\n  Int64: 8,\n  // Not supported with JavaScript will cause error in binary\n  UInt64: 8,\n  // Not supported with JavaScript will cause error in binary\n  Float32: 4,\n  Float64: 8\n}; // ----------------------------------------------------------------------------\n\nfunction integer64to32(array) {\n  var maxIdx = array.length - 1; // Skip last\n\n  return array.filter(function (v, i) {\n    return i < maxIdx && i % 2 === 0;\n  });\n} // ----------------------------------------------------------------------------\n\n\nfunction readerHeader(uint8, headerType) {\n  // We do not handle endianness or if more than 32 bits are needed to encode the data\n  if (headerType === 'UInt64') {\n    var _offset = 8;\n\n    var _uint = new Uint32Array(uint8.buffer, 0, 6);\n\n    var _nbBlocks = _uint[0];\n    var _s = _uint[2];\n    var _s2 = _uint[4];\n    var _resultArray = [_offset, _nbBlocks, _s, _s2];\n    _uint = new Uint32Array(uint8.buffer, 3 * 8, _nbBlocks * 2);\n\n    for (var i = 0; i < _nbBlocks; i++) {\n      _resultArray.push(_uint[i * 2]);\n    }\n\n    return _resultArray;\n  } // UInt32\n\n\n  var uint32 = new Uint32Array(uint8.buffer, 0, 3);\n  var offset = 4;\n  var nbBlocks = uint32[0];\n  var s1 = uint32[1];\n  var s2 = uint32[2];\n  var resultArray = [offset, nbBlocks, s1, s2];\n  uint32 = new Uint32Array(uint8.buffer, 3 * 4, nbBlocks);\n\n  for (var _i = 0; _i < nbBlocks; _i++) {\n    resultArray.push(uint32[_i]);\n  }\n\n  return resultArray;\n} // ----------------------------------------------------------------------------\n\n\nfunction uncompressBlock(compressedUint8, output) {\n  var uncompressedBlock = decompressSync(compressedUint8);\n  output.uint8.set(uncompressedBlock, output.offset);\n  output.offset += uncompressedBlock.length;\n} // ----------------------------------------------------------------------------\n\n\nfunction processDataArray(size, dataArrayElem, compressor, byteOrder, headerType, binaryBuffer) {\n  var dataType = dataArrayElem.getAttribute('type');\n  var name = dataArrayElem.getAttribute('Name');\n  var format = dataArrayElem.getAttribute('format'); // binary, ascii, appended\n\n  var numberOfComponents = Number(dataArrayElem.getAttribute('NumberOfComponents') || '1');\n  var values = null;\n\n  if (format === 'ascii') {\n    values = new TYPED_ARRAY[dataType](size * numberOfComponents);\n    var offset = 0;\n    dataArrayElem.firstChild.nodeValue.split(/[\\\\t \\\\n]+/).forEach(function (token) {\n      if (token.trim().length) {\n        values[offset++] = Number(token);\n      }\n    });\n  } else if (format === 'binary') {\n    var uint8 = new Uint8Array(Base64.toArrayBuffer(dataArrayElem.firstChild.nodeValue.trim()));\n\n    if (compressor === 'vtkZLibDataCompressor') {\n      var buffer = new ArrayBuffer(TYPED_ARRAY_BYTES[dataType] * size * numberOfComponents);\n      values = new TYPED_ARRAY[dataType](buffer);\n      var output = {\n        offset: 0,\n        uint8: new Uint8Array(buffer)\n      }; // ----------------------------------------------------------------------\n      // Layout of the data\n      // header[N, s1, s1, blockSize1, ..., blockSizeN], [padding???], block[compressedData], ..., block[compressedData]\n      // [header] N, s1 and s2 are uint 32 or 64 (defined by header_type=\"UInt64\" attribute on the root node)\n      // [header] s1: uncompress size of each block except the last one\n      // [header] s2: uncompress size of the last blocks\n      // [header] blockSize: size of the block in compressed space that represent to bloc to inflate in zlib. (This also give the offset to the next block)\n      // ----------------------------------------------------------------------\n      // Header reading\n\n      var header = readerHeader(uint8, headerType);\n      var nbBlocks = header[1];\n\n      var _offset2 = uint8.length - (header.reduce(function (a, b) {\n        return a + b;\n      }, 0) - (header[0] + header[1] + header[2] + header[3]));\n\n      for (var i = 0; i < nbBlocks; i++) {\n        var blockSize = header[4 + i];\n        var compressedBlock = new Uint8Array(uint8.buffer, _offset2, blockSize);\n        uncompressBlock(compressedBlock, output);\n        _offset2 += blockSize;\n      } // Handle (u)int64 hoping for no overflow...\n\n\n      if (dataType.indexOf('Int64') !== -1) {\n        values = integer64to32(values);\n      }\n    } else {\n      values = new TYPED_ARRAY[dataType](uint8.buffer, TYPED_ARRAY_BYTES[headerType]); // Skip the count\n      // Handle (u)int64 hoping no overflow...\n\n      if (dataType.indexOf('Int64') !== -1) {\n        values = integer64to32(values);\n      }\n    }\n  } else if (format === 'appended') {\n    var _offset3 = Number(dataArrayElem.getAttribute('offset')); // read header\n    // NOTE: this will incorrectly read the size if headerType is (U)Int64 and\n    // the value requires (U)Int64.\n\n\n    var _header;\n\n    if (_offset3 % TYPED_ARRAY_BYTES[headerType] === 0) {\n      _header = new TYPED_ARRAY[headerType](binaryBuffer, _offset3, 1);\n    } else {\n      _header = new TYPED_ARRAY[headerType](binaryBuffer.slice(_offset3, _offset3 + TYPED_ARRAY_BYTES[headerType]));\n    }\n\n    var arraySize = _header[0] / TYPED_ARRAY_BYTES[dataType]; // if we are dealing with Uint64, we need to get double the values since\n    // TYPED_ARRAY[Uint64] is Uint32.\n\n    if (dataType.indexOf('Int64') !== -1) {\n      arraySize *= 2;\n    }\n\n    _offset3 += TYPED_ARRAY_BYTES[headerType]; // read values\n    // if offset is aligned to dataType, use view. Otherwise, slice due to misalignment.\n\n    if (_offset3 % TYPED_ARRAY_BYTES[dataType] === 0) {\n      values = new TYPED_ARRAY[dataType](binaryBuffer, _offset3, arraySize);\n    } else {\n      values = new TYPED_ARRAY[dataType](binaryBuffer.slice(_offset3, _offset3 + _header[0]));\n    } // remove higher order 32 bits assuming they're not used.\n\n\n    if (dataType.indexOf('Int64') !== -1) {\n      values = integer64to32(values);\n    }\n  } else {\n    console.error('Format not supported', format);\n  }\n\n  return {\n    name: name,\n    values: values,\n    numberOfComponents: numberOfComponents\n  };\n} // ----------------------------------------------------------------------------\n\n\nfunction processCells(size, containerElem, compressor, byteOrder, headerType, binaryBuffer) {\n  var arrayElems = {};\n  var dataArrayElems = containerElem.getElementsByTagName('DataArray');\n\n  for (var elIdx = 0; elIdx < dataArrayElems.length; elIdx++) {\n    var el = dataArrayElems[elIdx];\n    arrayElems[el.getAttribute('Name')] = el;\n  }\n\n  var offsets = processDataArray(size, arrayElems.offsets, compressor, byteOrder, headerType, binaryBuffer).values;\n  var connectivitySize = offsets[offsets.length - 1];\n  var connectivity = processDataArray(connectivitySize, arrayElems.connectivity, compressor, byteOrder, headerType, binaryBuffer).values;\n  var values = new Uint32Array(size + connectivitySize);\n  var writeOffset = 0;\n  var previousOffset = 0;\n  offsets.forEach(function (v) {\n    var cellSize = v - previousOffset;\n    values[writeOffset++] = cellSize;\n\n    for (var i = 0; i < cellSize; i++) {\n      values[writeOffset++] = connectivity[previousOffset + i];\n    } // save previous offset\n\n\n    previousOffset = v;\n  });\n  return values;\n} // ----------------------------------------------------------------------------\n\n\nfunction processFieldData(size, fieldElem, fieldContainer, compressor, byteOrder, headerType, binaryBuffer) {\n  if (fieldElem) {\n    var attributes = ['Scalars', 'Vectors', 'Normals', 'Tensors', 'TCoords'];\n    var nameBinding = {};\n    attributes.forEach(function (attrName) {\n      var arrayName = fieldElem.getAttribute(attrName);\n\n      if (arrayName) {\n        nameBinding[arrayName] = fieldContainer[\"set\".concat(attrName)];\n      }\n    });\n    var dataArrayElems = fieldElem.getElementsByTagName('DataArray');\n    var nbArrays = dataArrayElems.length;\n\n    for (var idx = 0; idx < nbArrays; idx++) {\n      var array = dataArrayElems[idx];\n      var dataArray = vtkDataArray.newInstance(processDataArray(size, array, compressor, byteOrder, headerType, binaryBuffer));\n      var name = dataArray.getName();\n      (nameBinding[name] || fieldContainer.addArray)(dataArray);\n    }\n  }\n} // ----------------------------------------------------------------------------\n\n\nfunction handleFieldDataArrays(fieldDataElem, compressor, byteOrder, headerType, binaryBuffer) {\n  return _toConsumableArray(fieldDataElem.getElementsByTagName('DataArray')).map(function (daElem) {\n    return vtkDataArray.newInstance(processDataArray(Number(daElem.getAttribute('NumberOfTuples')), daElem, compressor, byteOrder, headerType, binaryBuffer));\n  });\n} // ----------------------------------------------------------------------------\n// vtkXMLReader methods\n// ----------------------------------------------------------------------------\n\n\nfunction vtkXMLReader(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkXMLReader'); // Create default dataAccessHelper if not available\n\n  if (!model.dataAccessHelper) {\n    model.dataAccessHelper = DataAccessHelper.get('http');\n  } // Internal method to fetch Array\n\n\n  function fetchData(url) {\n    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    return model.dataAccessHelper.fetchBinary(url, option);\n  } // Set DataSet url\n\n\n  publicAPI.setUrl = function (url) {\n    var option = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};\n    model.url = url; // Remove the file in the URL\n\n    var path = url.split('/');\n    path.pop();\n    model.baseURL = path.join('/'); // Fetch metadata\n\n    return publicAPI.loadData(option);\n  }; // Fetch the actual data arrays\n\n\n  publicAPI.loadData = function () {\n    var option = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n    return fetchData(model.url, option).then(publicAPI.parseAsArrayBuffer);\n  };\n\n  publicAPI.parseAsArrayBuffer = function (arrayBuffer) {\n    if (!arrayBuffer) {\n      return false;\n    }\n\n    if (arrayBuffer !== model.rawDataBuffer) {\n      publicAPI.modified();\n    } else {\n      return true;\n    }\n\n    var _extractAppendedData = extractAppendedData(arrayBuffer),\n        content = _extractAppendedData.text,\n        binaryBuffer = _extractAppendedData.binaryBuffer;\n\n    model.rawDataBuffer = arrayBuffer;\n    model.binaryBuffer = binaryBuffer; // Parse data here...\n\n    var doc = parseXML(content);\n    var rootElem = doc.root().node;\n    var type = rootElem.getAttribute('type');\n    var compressor = rootElem.getAttribute('compressor');\n    var byteOrder = rootElem.getAttribute('byte_order'); // default to UInt32. I think version 0.1 vtp/vti files default to UInt32.\n\n    var headerType = rootElem.getAttribute('header_type') || 'UInt32';\n\n    if (compressor && compressor !== 'vtkZLibDataCompressor') {\n      console.error('Invalid compressor', compressor);\n      return false;\n    }\n\n    if (byteOrder && byteOrder !== 'LittleEndian') {\n      console.error('Only LittleEndian encoding is supported');\n      return false;\n    }\n\n    if (type !== model.dataType) {\n      console.error('Invalid data type', type, 'expecting', model.dataType);\n      return false;\n    } // appended format\n\n\n    if (findFirstTag(rootElem, 'AppendedData')) {\n      var appendedDataElem = findFirstTag(rootElem, 'AppendedData');\n      var encoding = appendedDataElem.getAttribute('encoding');\n      var arrayElems = findAllTags(rootElem, 'DataArray');\n      var appendedBuffer = model.binaryBuffer;\n\n      if (encoding === 'base64') {\n        // substr(1) is to remove the '_' prefix\n        appendedBuffer = appendedDataElem.textContent.trim().substr(1);\n      } // get data array chunks\n\n\n      var dataArrays = [];\n\n      for (var i = 0; i < arrayElems.length; ++i) {\n        var offset = Number(arrayElems[i].getAttribute('offset'));\n        var nextOffset = 0;\n\n        if (i === arrayElems.length - 1) {\n          nextOffset = appendedBuffer.length || appendedBuffer.byteLength;\n        } else {\n          nextOffset = Number(arrayElems[i + 1].getAttribute('offset'));\n        }\n\n        if (encoding === 'base64') {\n          dataArrays.push(new Uint8Array(Base64.toArrayBuffer(appendedBuffer.substring(offset, nextOffset))));\n        } else {\n          // encoding === 'raw'\n          // Need to slice the ArrayBuffer so readerHeader() works properly\n          dataArrays.push(new Uint8Array(appendedBuffer.slice(offset, nextOffset)));\n        }\n      }\n\n      if (compressor === 'vtkZLibDataCompressor') {\n        for (var arrayidx = 0; arrayidx < dataArrays.length; ++arrayidx) {\n          var dataArray = dataArrays[arrayidx]; // Header reading\n          // Refer to processDataArray() above for info on header fields\n\n          var header = readerHeader(dataArray, headerType);\n          var nbBlocks = header[1];\n          var compressedOffset = dataArray.length - (header.reduce(function (a, b) {\n            return a + b;\n          }, 0) - (header[0] + header[1] + header[2] + header[3]));\n          var _buffer = null;\n\n          if (nbBlocks > 0) {\n            // If the last block's size is labeled as 0, that means the last block\n            // really has size header[2].\n            if (header[3] === 0) {\n              _buffer = new ArrayBuffer(header[2] * nbBlocks);\n            } else {\n              _buffer = new ArrayBuffer(header[2] * (nbBlocks - 1) + header[3]);\n            }\n          } else {\n            // if there is no blocks, then default to a zero array of size 0.\n            _buffer = new ArrayBuffer(0);\n          } // uncompressed buffer\n\n\n          var uncompressed = new Uint8Array(_buffer);\n          var output = {\n            offset: 0,\n            uint8: uncompressed\n          };\n\n          for (var _i2 = 0; _i2 < nbBlocks; _i2++) {\n            var blockSize = header[4 + _i2];\n            var compressedBlock = new Uint8Array(dataArray.buffer, compressedOffset, blockSize);\n            uncompressBlock(compressedBlock, output);\n            compressedOffset += blockSize;\n          }\n\n          var data = new Uint8Array(uncompressed.length + TYPED_ARRAY_BYTES[headerType]); // set length header\n          // TODO this does not work for lengths that are greater than the max Uint32 value.\n\n          new TYPED_ARRAY[headerType](data.buffer, 0, 1)[0] = uncompressed.length;\n          data.set(uncompressed, TYPED_ARRAY_BYTES[headerType]);\n          dataArrays[arrayidx] = data;\n        }\n      }\n\n      var bufferLength = dataArrays.reduce(function (acc, arr) {\n        return acc + arr.length;\n      }, 0);\n      var buffer = new ArrayBuffer(bufferLength);\n      var view = new Uint8Array(buffer);\n\n      for (var _i3 = 0, _offset4 = 0; _i3 < dataArrays.length; ++_i3) {\n        // set correct offsets\n        arrayElems[_i3].setAttribute('offset', _offset4); // set final buffer data\n\n\n        view.set(dataArrays[_i3], _offset4);\n        _offset4 += dataArrays[_i3].length;\n      }\n\n      model.binaryBuffer = buffer;\n\n      if (!model.binaryBuffer) {\n        console.error('Processing appended data format: requires binaryBuffer to parse');\n        return false;\n      }\n    }\n\n    publicAPI.parseXML(rootElem, type, compressor, byteOrder, headerType);\n    var datasetElem = rootElem.getElementsByTagName(type)[0];\n    var fieldDataElem = datasetElem.getElementsByTagName('FieldData')[0];\n\n    if (fieldDataElem) {\n      var fieldDataArrays = handleFieldDataArrays(fieldDataElem, compressor, byteOrder, headerType, model.binaryBuffer);\n\n      for (var _i4 = 0; _i4 < model.output.length; _i4++) {\n        var fieldData = model.output[_i4].getFieldData();\n\n        for (var j = 0; j < fieldDataArrays.length; j++) {\n          fieldData.addArray(fieldDataArrays[j]);\n        }\n      }\n    }\n\n    return true;\n  };\n\n  publicAPI.requestData = function (inData, outData) {\n    publicAPI.parseAsArrayBuffer(model.rawDataBuffer);\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {// baseURL: null,\n  // dataAccessHelper: null,\n  // url: null,\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues); // Build VTK API\n\n  macro.obj(publicAPI, model);\n  macro.get(publicAPI, model, ['url', 'baseURL']);\n  macro.setGet(publicAPI, model, ['dataAccessHelper']);\n  macro.algo(publicAPI, model, 0, 1); // vtkXMLReader methods\n\n  vtkXMLReader(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar vtkXMLReader$1 = {\n  extend: extend,\n  processDataArray: processDataArray,\n  processFieldData: processFieldData,\n  processCells: processCells\n};\n\nexport { vtkXMLReader$1 as default, extend, findAllTags, findFirstTag };\n","import vtkXMLReader from './XMLReader.js';\nimport macro from '../../macros.js';\nimport vtkImageData from '../../Common/DataModel/ImageData.js';\n\n// vtkXMLImageDataReader methods\n// ----------------------------------------------------------------------------\n\nfunction vtkXMLImageDataReader(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkXMLImageDataReader');\n\n  publicAPI.parseXML = function (rootElem, type, compressor, byteOrder, headerType) {\n    var _imageDataElem$getAtt;\n\n    var imageDataElem = rootElem.getElementsByTagName(model.dataType)[0];\n    var origin = imageDataElem.getAttribute('Origin').split(' ').map(function (t) {\n      return Number(t);\n    });\n    var spacing = imageDataElem.getAttribute('Spacing').split(' ').map(function (t) {\n      return Number(t);\n    });\n    var direction = (_imageDataElem$getAtt = imageDataElem.getAttribute('Direction')) === null || _imageDataElem$getAtt === void 0 ? void 0 : _imageDataElem$getAtt.split(' ').map(function (t) {\n      return Number(t);\n    });\n    var pieces = imageDataElem.getElementsByTagName('Piece');\n    var nbPieces = pieces.length;\n\n    for (var outputIndex = 0; outputIndex < nbPieces; outputIndex++) {\n      // Create image data\n      var piece = pieces[outputIndex];\n      var extent = piece.getAttribute('Extent').split(' ').map(function (t) {\n        return Number(t);\n      });\n      var imageData = vtkImageData.newInstance({\n        origin: origin,\n        spacing: spacing,\n        direction: direction,\n        extent: extent\n      }); // Fill data\n\n      vtkXMLReader.processFieldData(imageData.getNumberOfPoints(), piece.getElementsByTagName('PointData')[0], imageData.getPointData(), compressor, byteOrder, headerType, model.binaryBuffer);\n      vtkXMLReader.processFieldData(imageData.getNumberOfCells(), piece.getElementsByTagName('CellData')[0], imageData.getCellData(), compressor, byteOrder, headerType, model.binaryBuffer); // Add new output\n\n      model.output[outputIndex] = imageData;\n    }\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  dataType: 'ImageData'\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  vtkXMLReader.extend(publicAPI, model, initialValues);\n  vtkXMLImageDataReader(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkXMLImageDataReader'); // ----------------------------------------------------------------------------\n\nvar vtkXMLImageDataReader$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { vtkXMLImageDataReader$1 as default, extend, newInstance };\n","import macro from '../../macros.js';\nimport vtkPolyData from '../../Common/DataModel/PolyData.js';\nimport vtkXMLReader from './XMLReader.js';\n\n// Global method\n// ----------------------------------------------------------------------------\n\nfunction handleArray(polydata, cellType, piece, compressor, byteOrder, headerType, binaryBuffer) {\n  var size = Number(piece.getAttribute(\"NumberOf\".concat(cellType)));\n\n  if (size > 0) {\n    var dataArrayElem = piece.getElementsByTagName(cellType)[0].getElementsByTagName('DataArray')[0];\n\n    var _vtkXMLReader$process = vtkXMLReader.processDataArray(size, dataArrayElem, compressor, byteOrder, headerType, binaryBuffer),\n        values = _vtkXMLReader$process.values,\n        numberOfComponents = _vtkXMLReader$process.numberOfComponents;\n\n    polydata[\"get\".concat(cellType)]().setData(values, numberOfComponents);\n  }\n\n  return size;\n} // ----------------------------------------------------------------------------\n\n\nfunction handleCells(polydata, cellType, piece, compressor, byteOrder, headerType, binaryBuffer) {\n  var size = Number(piece.getAttribute(\"NumberOf\".concat(cellType)));\n\n  if (size > 0) {\n    var values = vtkXMLReader.processCells(size, piece.getElementsByTagName(cellType)[0], compressor, byteOrder, headerType, binaryBuffer);\n    polydata[\"get\".concat(cellType)]().setData(values);\n  }\n\n  return size;\n} // ----------------------------------------------------------------------------\n// vtkXMLPolyDataReader methods\n// ----------------------------------------------------------------------------\n\n\nfunction vtkXMLPolyDataReader(publicAPI, model) {\n  // Set our className\n  model.classHierarchy.push('vtkXMLPolyDataReader');\n\n  publicAPI.parseXML = function (rootElem, type, compressor, byteOrder, headerType) {\n    var datasetElem = rootElem.getElementsByTagName(model.dataType)[0];\n    var pieces = datasetElem.getElementsByTagName('Piece');\n    var nbPieces = pieces.length;\n\n    var _loop = function _loop(outputIndex) {\n      // Create dataset\n      var polydata = vtkPolyData.newInstance();\n      var piece = pieces[outputIndex]; // Points\n\n      var nbPoints = handleArray(polydata, 'Points', piece, compressor, byteOrder, headerType, model.binaryBuffer); // Cells\n\n      var nbCells = 0;\n      ['Verts', 'Lines', 'Strips', 'Polys'].forEach(function (cellType) {\n        nbCells += handleCells(polydata, cellType, piece, compressor, byteOrder, headerType, model.binaryBuffer);\n      }); // Fill data\n\n      vtkXMLReader.processFieldData(nbPoints, piece.getElementsByTagName('PointData')[0], polydata.getPointData(), compressor, byteOrder, headerType, model.binaryBuffer);\n      vtkXMLReader.processFieldData(nbCells, piece.getElementsByTagName('CellData')[0], polydata.getCellData(), compressor, byteOrder, headerType, model.binaryBuffer); // Add new output\n\n      model.output[outputIndex] = polydata;\n    };\n\n    for (var outputIndex = 0; outputIndex < nbPieces; outputIndex++) {\n      _loop(outputIndex);\n    }\n  };\n} // ----------------------------------------------------------------------------\n// Object factory\n// ----------------------------------------------------------------------------\n\n\nvar DEFAULT_VALUES = {\n  dataType: 'PolyData'\n}; // ----------------------------------------------------------------------------\n\nfunction extend(publicAPI, model) {\n  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};\n  Object.assign(model, DEFAULT_VALUES, initialValues);\n  vtkXMLReader.extend(publicAPI, model, initialValues);\n  vtkXMLPolyDataReader(publicAPI, model);\n} // ----------------------------------------------------------------------------\n\nvar newInstance = macro.newInstance(extend, 'vtkXMLPolyDataReader'); // ----------------------------------------------------------------------------\n\nvar vtkXMLPolyDataReader$1 = {\n  newInstance: newInstance,\n  extend: extend\n};\n\nexport { vtkXMLPolyDataReader$1 as default, extend, newInstance };\n","import { extensionToImageIO } from 'itk-wasm';\nimport { extractFilesFromZip } from './zip';\nimport { FileEntry } from './types';\n\nexport const ARCHIVE_FILE_TYPES = new Set(['zip', 'application/zip']);\n\nexport const ITK_IMAGE_EXTENSIONS = Array.from(\n  new Set(Array.from(extensionToImageIO.keys()).map((ext) => ext.toLowerCase()))\n);\n\n// remove duplicates\nexport const FILE_TYPES = Array.from(\n  new Set(['vti', 'vtp', 'stl', 'dcm', 'zip', 'json', ...ITK_IMAGE_EXTENSIONS])\n);\n\n/**\n * file magic database\n * Used to handle certain cases where files have no extension\n */\nconst FILE_MAGIC_DB = [\n  {\n    type: 'dcm',\n    skip: 128,\n    header: Array.from('DICM').map((c) => c.charCodeAt(0)),\n  },\n];\n\n// How much data to read when extracting file magic.\n// This should be generous enough for most files.\nconst HEAD_CHUNK = 512;\n\nfunction prefixEquals(target: Uint8Array, prefix: number[] | Uint8Array) {\n  if (prefix.length > target.length) {\n    return false;\n  }\n  for (let i = 0; i < prefix.length; i += 1) {\n    if (prefix[i] !== target[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n\nasync function getFileTypeFromMagic(file: File): Promise<string | null> {\n  return new Promise((resolve) => {\n    const head = file.slice(0, HEAD_CHUNK);\n    const reader = new FileReader();\n    reader.onload = () => {\n      const chunk = new Uint8Array(reader.result! as ArrayBuffer);\n      for (let i = 0; i < FILE_MAGIC_DB.length; i += 1) {\n        const { type, header, skip = 0 } = FILE_MAGIC_DB[i];\n        if (prefixEquals(chunk.slice(skip), header)) {\n          resolve(type);\n          return;\n        }\n      }\n      resolve(null);\n    };\n    reader.readAsArrayBuffer(head);\n  });\n}\n\n/**\n * Retypes a given File.\n *\n * Handy for when a file object has no type given.\n * Type is inferred from extension or magic.\n *\n * If type is not supported, file.type will be \"\".\n * @param file\n */\nexport async function retypeFile(file: File): Promise<File> {\n  let type: string | null;\n\n  type =\n    FILE_TYPES.find((ext) => file.name.toLowerCase().endsWith(`.${ext}`)) ??\n    null;\n\n  if (!type) {\n    type = await getFileTypeFromMagic(file);\n  }\n\n  if (!type) {\n    type = '';\n  }\n\n  const retypedFile = new File([file], file.name, { type: type.toLowerCase() });\n  return retypedFile;\n}\n\nexport async function extractArchivesRecursively(\n  files: File[]\n): Promise<FileEntry[]> {\n  const results = await Promise.all(\n    files.map(async (file) => {\n      if (ARCHIVE_FILE_TYPES.has(file.type)) {\n        return extractFilesFromZip(file);\n      }\n\n      return [{ file, path: '' }];\n    })\n  );\n\n  const archivedEntries = await Promise.all(\n    results.flat().map(async (entry) => {\n      return { file: await retypeFile(entry.file), path: entry.path };\n    })\n  );\n\n  const archives = archivedEntries\n    .filter(({ file }) => ARCHIVE_FILE_TYPES.has(file.type))\n    .map(({ file }) => file);\n\n  if (archives.length > 0) {\n    const moreEntries = await extractArchivesRecursively(archives);\n    return [...archivedEntries, ...moreEntries];\n  }\n\n  return archivedEntries;\n}\n\nexport type ReadAsType = 'ArrayBuffer' | 'Text';\n\nasync function readFileAs<T extends ArrayBuffer | string>(\n  file: File,\n  type: ReadAsType\n): Promise<T> {\n  return new Promise((resolve) => {\n    const fio = new globalThis.FileReader();\n    fio.onload = () => resolve(fio.result as T);\n    if (type === 'ArrayBuffer') {\n      fio.readAsArrayBuffer(file);\n    } else if (type === 'Text') {\n      fio.readAsText(file);\n    } else {\n      throw new TypeError(`readAs${type} is not a function`);\n    }\n  });\n}\n\n/**\n * Reads a file and returns an ArrayBuffer\n * @async\n * @param {File} file\n */\nexport async function readFileAsArrayBuffer(file: File) {\n  return readFileAs<ArrayBuffer>(file, 'ArrayBuffer');\n}\n\n/**\n * Reads a file and returns UTF-8 text\n * @async\n * @param {File} file\n */\nexport async function readFileAsUTF8Text(file: File) {\n  return readFileAs<string>(file, 'Text');\n}\n","import { vtkObject } from '@kitware/vtk.js/interfaces';\n\nexport * from './io';\n\nexport type ReaderType = (file: File) => vtkObject | Promise<vtkObject>;\nexport type FileReaderMap = Map<string, ReaderType>;\n\n/**\n * A map of the currently registered file readers.\n */\nexport const FILE_READERS: FileReaderMap = new Map();\n","import { vtkReader, vtkWriter, vtkClass } from '@/src/types/vtk-types';\nimport { readFileAsArrayBuffer, readFileAsUTF8Text } from '@/src/io';\nimport vtkDataSet from '@kitware/vtk.js/Common/DataModel/DataSet';\n\nexport async function readFile(\n  file: File,\n  vtkReaderClass: vtkClass,\n  asBinary = true\n) {\n  const reader: vtkReader = vtkReaderClass.newInstance() as vtkReader;\n  if (asBinary) {\n    const buffer = await readFileAsArrayBuffer(file);\n    reader.parseAsArrayBuffer(buffer);\n  } else {\n    const buffer = await readFileAsUTF8Text(file);\n    reader.parseAsText(buffer);\n  }\n  return reader.getOutputData();\n}\n\nexport async function writeData(vtkWriterClass: vtkClass, data: vtkDataSet) {\n  const writer: vtkWriter = vtkWriterClass.newInstance() as vtkWriter;\n\n  return writer.write(data);\n}\n\nexport interface StateObject {\n  vtkClass: string;\n  [attrName: string]: unknown;\n}\n","import vtkSTLReader from '@kitware/vtk.js/IO/Geometry/STLReader';\nimport vtkXMLImageDataReader from '@kitware/vtk.js/IO/XML/XMLImageDataReader';\nimport vtkXMLPolyDataReader from '@kitware/vtk.js/IO/XML/XMLPolyDataReader';\n\nimport workerHandler from '@/src/utils/workerHandler';\nimport { readFile } from './common';\n\nconst Readers = {\n  stl: {\n    readerClass: vtkSTLReader,\n    asBinary: true,\n  },\n  vti: {\n    readerClass: vtkXMLImageDataReader,\n    asBinary: true,\n  },\n  vtp: {\n    readerClass: vtkXMLPolyDataReader,\n    asBinary: true,\n  },\n};\n\nexport interface ReaderWorkerInput {\n  file: File;\n  readerName: keyof typeof Readers;\n}\n\nworkerHandler.registerHandler(async (data: ReaderWorkerInput) => {\n  try {\n    const { file, readerName } = data;\n    if (!file) {\n      throw new Error('No file provided');\n    }\n    if (!(readerName in Readers)) {\n      throw new Error(`No reader found for ${file.name}`);\n    }\n\n    const { readerClass, asBinary } = Readers[readerName];\n    const ds = await readFile(file, readerClass, asBinary);\n    return {\n      status: 'success',\n      obj: ds.getState(),\n    };\n  } catch (error) {\n    return {\n      status: 'fail',\n      error: error as Error,\n    };\n  }\n});\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n// expose the modules object (__webpack_modules__)\n__webpack_require__.m = __webpack_modules__;\n\n// the startup function\n__webpack_require__.x = function() {\n\t// Load entry module and return exports\n\t// This entry module depends on other loaded chunks and execution need to be delayed\n\tvar __webpack_exports__ = __webpack_require__.O(undefined, [23], function() { return __webpack_require__(7385); })\n\t__webpack_exports__ = __webpack_require__.O(__webpack_exports__);\n\treturn __webpack_exports__;\n};\n\n","__webpack_require__.amdD = function () {\n\tthrow new Error('define cannot be used indirect');\n};","__webpack_require__.amdO = {};","var deferred = [];\n__webpack_require__.O = function(result, chunkIds, fn, priority) {\n\tif(chunkIds) {\n\t\tpriority = priority || 0;\n\t\tfor(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];\n\t\tdeferred[i] = [chunkIds, fn, priority];\n\t\treturn;\n\t}\n\tvar notFulfilled = Infinity;\n\tfor (var i = 0; i < deferred.length; i++) {\n\t\tvar chunkIds = deferred[i][0];\n\t\tvar fn = deferred[i][1];\n\t\tvar priority = deferred[i][2];\n\t\tvar fulfilled = true;\n\t\tfor (var j = 0; j < chunkIds.length; j++) {\n\t\t\tif ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every(function(key) { return __webpack_require__.O[key](chunkIds[j]); })) {\n\t\t\t\tchunkIds.splice(j--, 1);\n\t\t\t} else {\n\t\t\t\tfulfilled = false;\n\t\t\t\tif(priority < notFulfilled) notFulfilled = priority;\n\t\t\t}\n\t\t}\n\t\tif(fulfilled) {\n\t\t\tdeferred.splice(i--, 1)\n\t\t\tvar r = fn();\n\t\t\tif (r !== undefined) result = r;\n\t\t}\n\t}\n\treturn result;\n};","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\n};","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.f = {};\n// This file contains only the entry chunk.\n// The chunk loading function for additional chunks\n__webpack_require__.e = function(chunkId) {\n\treturn Promise.all(Object.keys(__webpack_require__.f).reduce(function(promises, key) {\n\t\t__webpack_require__.f[key](chunkId, promises);\n\t\treturn promises;\n\t}, []));\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.u = function(chunkId) {\n\t// return url for filenames based on template\n\treturn \"js/\" + chunkId + \".\" + \"be4d694e\" + \".js\";\n};","// This function allow to reference async chunks and sibling chunks for the entrypoint\n__webpack_require__.miniCssF = function(chunkId) {\n\t// return url for filenames based on template\n\treturn undefined;\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","__webpack_require__.nmd = function(module) {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","__webpack_require__.p = \"/\";","// no baseURI\n\n// object to store loaded chunks\n// \"1\" means \"already loaded\"\nvar installedChunks = {\n\t385: 1\n};\n\n// importScripts chunk loading\nvar installChunk = function(data) {\n\tvar chunkIds = data[0];\n\tvar moreModules = data[1];\n\tvar runtime = data[2];\n\tfor(var moduleId in moreModules) {\n\t\tif(__webpack_require__.o(moreModules, moduleId)) {\n\t\t\t__webpack_require__.m[moduleId] = moreModules[moduleId];\n\t\t}\n\t}\n\tif(runtime) runtime(__webpack_require__);\n\twhile(chunkIds.length)\n\t\tinstalledChunks[chunkIds.pop()] = 1;\n\tparentChunkLoadingFunction(data);\n};\n__webpack_require__.f.i = function(chunkId, promises) {\n\t// \"1\" is the signal for \"already loaded\"\n\tif(!installedChunks[chunkId]) {\n\t\tif(true) { // all chunks have JS\n\t\t\timportScripts(__webpack_require__.p + __webpack_require__.u(chunkId));\n\t\t}\n\t}\n};\n\nvar chunkLoadingGlobal = self[\"webpackChunkVolView\"] = self[\"webpackChunkVolView\"] || [];\nvar parentChunkLoadingFunction = chunkLoadingGlobal.push.bind(chunkLoadingGlobal);\nchunkLoadingGlobal.push = installChunk;\n\n// no HMR\n\n// no HMR manifest","var next = __webpack_require__.x;\n__webpack_require__.x = function() {\n\treturn __webpack_require__.e(23).then(next);\n};","// run startup\nvar __webpack_exports__ = __webpack_require__.x();\n"],"names":["DataTypeByteSize","Int8Array","Uint8Array","Uint8ClampedArray","Int16Array","Uint16Array","Int32Array","Uint32Array","Float32Array","Float64Array","VtkDataTypes","VOID","CHAR","SIGNED_CHAR","UNSIGNED_CHAR","SHORT","UNSIGNED_SHORT","INT","UNSIGNED_INT","FLOAT","DOUBLE","DefaultDataType","Constants","vtkErrorMacro","vtkWarningMacro","notImplemented","method","concat","createArray","size","arguments","length","undefined","res","Array","i","Math","round","floor","ceil","min","max","add","a","b","out","subtract","multiplyAccumulate","scalar","dot","x","y","cross","Zx","Zy","Zz","norm","n","abs","sqrt","sum","normalize","den","distance2BetweenPoints","determinant2x2","_len","args","_key","Number","NaN","areEquals","eps","isEqual","element","index","every","areMatricesEqual","roundNumber","num","digits","includes","arr","split","sig","roundVector","vector","luFactorLinearSystem","A","j","k","largest","temp1","temp2","maxI","scale","luSolveLinearSystem","ii","idx","solveLinearSystem","det","uninitializeBounds","bounds","computeBoundsFromPoints","point1","point2","clampValue","value","minValue","maxValue","clampVector","minVector","maxVector","isFinite","isNaN","EPSILON","ARRAY_TYPE","RANDOM","random","degree","PI","toRadian","hypot","copy","identity","invert","a00","a01","a02","a03","a10","a11","a12","a13","a20","a21","a22","a23","a30","a31","a32","a33","b00","b01","b02","b03","b04","b05","b06","b07","b08","b09","b10","b11","multiply","b0","b1","b2","b3","translate","v","z","rotate","rad","axis","s","c","t","b12","b20","b21","b22","len","sin","cos","rotateX","rotateY","rotateZ","fromTranslation","fromRotation","create","clone","fromValues","set","divide","scaleAndAdd","distance","squaredDistance","squaredLength","negate","inverse","ax","ay","az","bx","by","bz","lerp","hermite","d","factorTimes2","factor1","factor2","factor3","factor4","bezier","inverseFactor","inverseFactorTimesTwo","r","zScale","transformMat4","m","w","transformMat3","transformQuat","q","qx","qy","qz","qw","uvx","uvy","uvz","uuvx","uuvy","uuvz","w2","p","angle","mag1","mag2","mag","cosine","acos","zero","str","exactEquals","equals","a0","a1","a2","sub","mul","div","dist","sqrDist","sqrLen","forEach","vec","stride","offset","count","fn","arg","l","arrayBufferToString","arrayBuffer","decoder","TextDecoder","decode","extractBinary","prefixRegex","suffixRegex","prefixMatch","exec","text","dataStartIndex","strFirstHalf","substring","retVal","suffixMatch","strSecondHalf","substr","binaryBuffer","slice","BinaryHelper","TYPE_MAPPING","has","type","get","options","registerType","DataAccessHelper","NoOp","Transform","useDegree","this","matrix","mat4","tmp","angleConv","key","originDirection","targetDirection","src","dst","transf","vec3","cosAlpha","apply","sx","sy","sz","mat4x4","mat3x3","typedArray","nbIterations","buildFromDegree","buildFromRadian","vtkMatrixBuilder","ownKeys","object","enumerableOnly","keys","Object","getOwnPropertySymbols","symbols","filter","sym","getOwnPropertyDescriptor","enumerable","push","_objectSpread","target","source","getOwnPropertyDescriptors","defineProperties","defineProperty","extractCellSizes","cellArray","currentIdx","getNumberOfCells","cellId","cellArrayIndex","STATIC","vtkCellArray","publicAPI","model","classHierarchy","recompute","numberOfCells","cellSizes","getData","getCellSizes","superSetData","setData","getCell","loc","cellLoc","numberOfPoints","values","subarray","superInitialize","initialize","insertNextCell","cellPointIds","insertNextTuples","defaultValues","initialValues","empty","numberOfComponents","dataType","extend","newInstance","vtkCellArray$1","INVALID_BOUNDS","vtkPoints","getNumberOfPoints","getNumberOfTuples","setNumberOfPoints","nbPoints","dimension","setNumberOfComponents","modified","setPoint","xyz","setTuple","getPoint","getTuple","insertNextPoint","insertNextTuple","getBounds","getNumberOfComponents","_xRange","getRange","_yRange","zRange","xRange","yRange","computeBounds","DEFAULT_VALUES","assign","vtkPoints$1","vtkCell","points","pointIdsList","pointsIds","triangleData","getDataType","pointsData","pointId","pointOffset","trianglePointOffset","u","getLength2","diff","getParametricDistance","pcoords","pDist","pDistMax","deepCopy","cell","getCellDimension","intersectWithLine","p1","p2","tol","subId","evaluatePosition","closestPoint","dist2","weights","vtkCell$1","resize","newSize","array","ncells","cells","vtkCellLinks","buildLinks","data","numPts","getPoints","numCells","linkLoc","isA","_data$getCellPoints","getCellPoints","cellPointId","incrementLinkCount","allocateLinks","maxId","_loop","_cellId","_data$getCellPoints2","insertCellReference","_cellId2","getPointsIds","_loop2","_cellId3","allocate","numLinks","ext","fill","map","getLink","ptId","getNcells","getCells","insertNextCellReference","deletePoint","removeCellReference","addCellReference","resizeCellList","squeeze","reset","pos","vtkCellLinks$1","CellType","VTK_EMPTY_CELL","VTK_VERTEX","VTK_POLY_VERTEX","VTK_LINE","VTK_POLY_LINE","VTK_TRIANGLE","VTK_TRIANGLE_STRIP","VTK_POLYGON","VTK_PIXEL","VTK_QUAD","VTK_TETRA","VTK_VOXEL","VTK_HEXAHEDRON","VTK_WEDGE","VTK_PYRAMID","VTK_PENTAGONAL_PRISM","VTK_HEXAGONAL_PRISM","VTK_QUADRATIC_EDGE","VTK_QUADRATIC_TRIANGLE","VTK_QUADRATIC_QUAD","VTK_QUADRATIC_POLYGON","VTK_QUADRATIC_TETRA","VTK_QUADRATIC_HEXAHEDRON","VTK_QUADRATIC_WEDGE","VTK_QUADRATIC_PYRAMID","VTK_BIQUADRATIC_QUAD","VTK_TRIQUADRATIC_HEXAHEDRON","VTK_QUADRATIC_LINEAR_QUAD","VTK_QUADRATIC_LINEAR_WEDGE","VTK_BIQUADRATIC_QUADRATIC_WEDGE","VTK_BIQUADRATIC_QUADRATIC_HEXAHEDRON","VTK_BIQUADRATIC_TRIANGLE","VTK_CUBIC_LINE","VTK_CONVEX_POINT_SET","VTK_POLYHEDRON","VTK_PARAMETRIC_CURVE","VTK_PARAMETRIC_SURFACE","VTK_PARAMETRIC_TRI_SURFACE","VTK_PARAMETRIC_QUAD_SURFACE","VTK_PARAMETRIC_TETRA_REGION","VTK_PARAMETRIC_HEX_REGION","VTK_HIGHER_ORDER_EDGE","VTK_HIGHER_ORDER_TRIANGLE","VTK_HIGHER_ORDER_QUAD","VTK_HIGHER_ORDER_POLYGON","VTK_HIGHER_ORDER_TETRAHEDRON","VTK_HIGHER_ORDER_WEDGE","VTK_HIGHER_ORDER_PYRAMID","VTK_HIGHER_ORDER_HEXAHEDRON","VTK_LAGRANGE_CURVE","VTK_LAGRANGE_TRIANGLE","VTK_LAGRANGE_QUADRILATERAL","VTK_LAGRANGE_TETRAHEDRON","VTK_LAGRANGE_HEXAHEDRON","VTK_LAGRANGE_WEDGE","VTK_LAGRANGE_PYRAMID","VTK_NUMBER_OF_CELL_TYPES","CellTypesStrings","getClassNameFromTypeId","typeId","getTypeIdFromClassName","cellTypeString","findIndex","isLinear","hasSubCells","cellType","vtkCellTypes","typeArray","locationArray","insertCell","setCellTypes","cellTypes","cellLocations","getCellLocation","deleteCell","getNumberOfTypes","isType","numTypes","getCellType","insertNextType","getSize","getExtend","getTypeArray","getLocationArray","getMaxId","vtkCellTypes$1","IntersectionState","NO_INTERSECTION","YES_INTERSECTION","ON_LINE","distanceToLine","closest","outObj","MIN_VALUE","p21","denom","tolerance","intersection","b1a1","obj","minDist","MAX_VALUE","l1","l2","uv1","uv2","vtkLine","isBetweenPoints","intersect","betweenPoints","projXYZ","outDistance","evaluateLocation","vtkLine$1","vtkPointSet","vtk","superShallowCopy","shallowCopy","other","debug","vtkPointSet$1","computeNormalDirection","v1","v2","v3","computeNormal","intersectWithTriangle","q1","r1","q2","r2","coplanar","pt1","pt2","surfaceId","n1","n2","s1","s2","dist1","pts1","pts2","n1n2","tt1","tt2","index1","index2","t1","t2","ts1","ts2","id1","id2","val1","val2","t12","t22","t11","t21","vtkTriangle","tol2","pt3","plane","inside","evaluation","dist2Pt1Pt2","dist2Pt2Pt3","dist2Pt3Pt1","line","intersectLine","pt3Pt1","pt3Pt2","pt3X","fabsn","dist2Point","dist2Line1","dist2Line2","rhs","c1","c2","indices","closestPoint1","closestPoint2","cp","maxComponent","lineDistance","_lineDistance","_lineDistance2","p0","u3","pc","_CELL_FACTORY","vtkTriangle$1","POLYDATA_FIELDS","CELL_FACTORY","vtkPolyData","camelize","replace","letter","toUpperCase","reduce","getReferenceByName","buildCells","nVerts","getNumberOfVerts","nLines","getNumberOfLines","nPolys","getNumberOfPolys","nStrips","getNumberOfStrips","nCells","types","pTypes","locs","pLocs","nextCellPts","verts","numCellPts","_nextCellPts","lines","_nextCellPts2","polys","_nextCellPts3","strips","initialSize","links","getPointCells","getCellEdgeNeighbors","link1","link2","indexOf","cellHint","cellInfo","vtkPolyData$1","getEndianness","ArrayBuffer","ENDIANNESS","swapBytes","buffer","wordSize","bytes","tempBuffer","_j","pop","Endian","vtkDebugMacro","REJECT_COMPRESSION","Promise","reject","Error","requestCount","openAsyncXHR","url","xhr","XMLHttpRequest","open","headers","entries","_ref","_ref2","setRequestHeader","progressCallback","addEventListener","fetchBinary","resolve","onreadystatechange","e","readyState","status","response","responseType","send","fetchArray","instance","baseURL","compression","ref","pending","basepath","id","join","invokeBusy","encode","JSON","parse","name","fetchJSON","responseText","fetchText","fetchImage","img","Image","crossOrigin","onload","onerror","LiteHttpDataAccessHelper","parseHeader","headerString","headerSubStr","fieldValues","header","fieldValueStr","fieldValueSubStr","addValuesToArray","readTriangle","cellNormals","normalLine","nbVertex","nbConsumedLines","firstVertexIndex","normal","coords","vtkSTLReader","fetchData","option","binary","dataAccessHelper","setUrl","path","loadData","promise","then","content","parseAsText","parseAsArrayBuffer","parseData","isBinary","dview","DataView","numTriangles","getUint32","byteLength","headerData","headerStr","dataView","nbFaces","pointValues","normalValues","cellValues","cellDataValues","cellOffset","faceIdx","getFloat32","getUint16","orientationField","XYZ","setMatrix","polydata","getPolys","getCellData","setScalars","setNormals","output","from","requestData","inData","outData","vtkSTLReader$1","u8","u16","u32","fleb","fdeb","clim","freb","eb","start","_a","fl","revfl","_b","fd","rev","hMap","cd","mb","co","le","rvb","sv","r_1","flt","fdt","bits","o","bits16","shft","slc","BYTES_PER_ELEMENT","ec","err","ind","msg","nt","code","captureStackTrace","inflt","dat","buf","st","sl","f","noBuf","noSt","cbuf","bl","nbuf","final","bt","lm","dm","lbt","dbt","tbts","flrm","fdrm","hLit","hcLen","tl","ldt","clt","clb","clbmsk","clm","lt","dt","lms","dms","lpos","dsym","end","et","gzs","flg","zs","gzl","zlv","inflateSync","gunzipSync","unzlibSync","decompressSync","td","stream","queueMicrotask","setTimeout","REVERSE_LOOKUP","charCodeAt","BASE64_CODE","isValidChar","extractChunks","b64Str","strSize","chunks","currentChunk","_i","writeChunk","chunk","dstOffset","uint8","remain","fourCharProcessCount","charIdx","_i2","toArrayBuffer","totalEncodedLength","padding","totalSize","view","_i3","encodeTriplet","triplet","fromArrayBuffer","ab","leftoverLength","maxTripletIndex","segments","_i4","bufOffset","segment","Base64","findAllTags","node","tagName","getElementsByTagName","findFirstTag","parseXML","xmlStr","extractAppendedData","TYPED_ARRAY","Int8","UInt8","Int16","UInt16","Int32","UInt32","Int64","UInt64","Float32","Float64","TYPED_ARRAY_BYTES","integer64to32","maxIdx","readerHeader","headerType","_offset","_uint","_nbBlocks","_s","_s2","_resultArray","uint32","nbBlocks","resultArray","uncompressBlock","compressedUint8","uncompressedBlock","processDataArray","dataArrayElem","compressor","byteOrder","getAttribute","format","firstChild","nodeValue","token","trim","_offset2","blockSize","compressedBlock","_header","_offset3","arraySize","console","error","processCells","containerElem","arrayElems","dataArrayElems","elIdx","el","offsets","connectivitySize","connectivity","writeOffset","previousOffset","cellSize","processFieldData","fieldElem","fieldContainer","attributes","nameBinding","attrName","arrayName","nbArrays","dataArray","getName","addArray","handleFieldDataArrays","fieldDataElem","daElem","vtkXMLReader","rawDataBuffer","_extractAppendedData","doc","rootElem","root","appendedDataElem","encoding","appendedBuffer","textContent","dataArrays","nextOffset","arrayidx","compressedOffset","_buffer","uncompressed","bufferLength","acc","_offset4","setAttribute","datasetElem","fieldDataArrays","fieldData","getFieldData","vtkXMLReader$1","vtkXMLImageDataReader","_imageDataElem$getAtt","imageDataElem","origin","spacing","direction","pieces","nbPieces","outputIndex","piece","extent","imageData","getPointData","vtkXMLImageDataReader$1","handleArray","_vtkXMLReader$process","handleCells","vtkXMLPolyDataReader","nbCells","vtkXMLPolyDataReader$1","Set","ITK_IMAGE_EXTENSIONS","extensionToImageIO","toLowerCase","async","readFileAs","file","fio","globalThis","FileReader","result","readAsArrayBuffer","TypeError","readAsText","readFileAsArrayBuffer","readFileAsUTF8Text","Map","readFile","vtkReaderClass","asBinary","reader","getOutputData","Readers","stl","readerClass","vti","vtp","workerHandler","readerName","ds","getState","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","exports","module","loaded","__webpack_modules__","call","__webpack_exports__","O","amdD","amdO","deferred","chunkIds","priority","notFulfilled","Infinity","fulfilled","splice","getter","__esModule","definition","chunkId","all","promises","miniCssF","g","Function","window","prop","prototype","hasOwnProperty","Symbol","toStringTag","nmd","paths","children","installedChunks","installChunk","moreModules","runtime","parentChunkLoadingFunction","importScripts","chunkLoadingGlobal","self","bind","next"],"sourceRoot":""}