@kitware/vtk.js 28.10.2 → 28.11.1

package/Common/Core/Base64.js

@@ -1,188 +1,159 @@
 /* eslint-disable no-bitwise */
+
 // ----------------------------------------------------------------------------
 // Decoding infrastructure
 // ----------------------------------------------------------------------------
-var REVERSE_LOOKUP = [];
+
+const REVERSE_LOOKUP = [];
 REVERSE_LOOKUP['-'.charCodeAt(0)] = 62;
 REVERSE_LOOKUP['_'.charCodeAt(0)] = 63;
-var BASE64_CODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-
-for (var i = 0; i < BASE64_CODE.length; i++) {
+const BASE64_CODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+for (let i = 0; i < BASE64_CODE.length; i++) {
   REVERSE_LOOKUP[BASE64_CODE.charCodeAt(i)] = i;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Base64 analysis
 // ----------------------------------------------------------------------------
 
-
 function isValidChar(c) {
   return REVERSE_LOOKUP[c.charCodeAt(0)] !== undefined;
 }
-
 function extractChunks(b64Str) {
-  var strSize = b64Str.length;
-  var chunks = [];
-  var currentChunk = null;
-
-  for (var _i = 0; _i < strSize; _i++) {
-    if (isValidChar(b64Str[_i])) {
+  const strSize = b64Str.length;
+  const chunks = [];
+  let currentChunk = null;
+  for (let i = 0; i < strSize; i++) {
+    if (isValidChar(b64Str[i])) {
       if (!currentChunk) {
         currentChunk = {
-          start: _i,
+          start: i,
           count: 0
         };
       }
-
       currentChunk.count++;
-      currentChunk.end = _i;
-    } else if (b64Str[_i] === '=' && currentChunk) {
+      currentChunk.end = i;
+    } else if (b64Str[i] === '=' && currentChunk) {
       // End of chunk (found padding char)
       chunks.push(currentChunk);
       currentChunk = null;
     }
   }
-
   if (currentChunk) {
     chunks.push(currentChunk);
   }
-
   return chunks;
 }
-
 function writeChunk(b64Str, chunk, dstOffset, uint8) {
-  var start = chunk.start,
-      count = chunk.count;
-  var remain = count % 4;
-  var fourCharProcessCount = Math.floor(count / 4);
-  var charIdx = start;
-  var tmp = null;
-  var offset = dstOffset; // Handle 4=>3
-
-  for (var _i2 = 0; _i2 < fourCharProcessCount; _i2++) {
+  const {
+    start,
+    count
+  } = chunk;
+  const remain = count % 4;
+  const fourCharProcessCount = Math.floor(count / 4);
+  let charIdx = start;
+  let tmp = null;
+  let offset = dstOffset;
+
+  // Handle 4=>3
+  for (let i = 0; i < fourCharProcessCount; i++) {
     while (!isValidChar(b64Str[charIdx])) {
       charIdx++;
     }
-
     tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 18;
-
     while (!isValidChar(b64Str[charIdx])) {
       charIdx++;
     }
-
     tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 12;
-
     while (!isValidChar(b64Str[charIdx])) {
       charIdx++;
     }
-
     tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 6;
-
     while (!isValidChar(b64Str[charIdx])) {
       charIdx++;
     }
-
     tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)];
     uint8[offset++] = tmp >> 16 & 0xff;
     uint8[offset++] = tmp >> 8 & 0xff;
     uint8[offset++] = tmp & 0xff;
-  } // Handle remain
-
+  }
 
+  // Handle remain
   switch (remain) {
     case 3:
       while (!isValidChar(b64Str[charIdx])) {
         charIdx++;
       }
-
       tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 10;
-
       while (!isValidChar(b64Str[charIdx])) {
         charIdx++;
       }
-
       tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 4;
-
       while (!isValidChar(b64Str[charIdx])) {
         charIdx++;
       }
-
       tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] >> 2;
       uint8[offset++] = tmp >> 8 & 0xff;
       uint8[offset++] = tmp & 0xff;
       break;
-
     case 2:
       while (!isValidChar(b64Str[charIdx])) {
         charIdx++;
       }
-
       tmp = REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] << 2;
-
       while (!isValidChar(b64Str[charIdx])) {
         charIdx++;
       }
-
       tmp |= REVERSE_LOOKUP[b64Str.charCodeAt(charIdx++)] >> 4;
       uint8[offset++] = tmp & 0xff;
       break;
-
     case 1:
       throw new Error('BASE64: remain 1 should not happen');
   }
-
   return offset;
 }
-
 function toArrayBuffer(b64Str) {
-  var chunks = extractChunks(b64Str);
-  var totalEncodedLength = chunks[chunks.length - 1].end + 1;
-  var padding = (4 - totalEncodedLength % 4) % 4; // -length mod 4
+  const chunks = extractChunks(b64Str);
+  const totalEncodedLength = chunks[chunks.length - 1].end + 1;
+  const padding = (4 - totalEncodedLength % 4) % 4; // -length mod 4
   // Any padding chars in the middle of b64Str is to be interpreted as \x00,
   // whereas the terminating padding chars are to be interpreted as literal padding.
-
-  var totalSize = (totalEncodedLength + padding) * 3 / 4 - padding;
-  var arrayBuffer = new ArrayBuffer(totalSize);
-  var view = new Uint8Array(arrayBuffer);
-  var dstOffset = 0;
-
-  for (var _i3 = 0; _i3 < chunks.length; _i3++) {
-    dstOffset += writeChunk(b64Str, chunks[_i3], dstOffset, view);
-    dstOffset += (4 - chunks[_i3].count % 4) % 4;
+  const totalSize = (totalEncodedLength + padding) * 3 / 4 - padding;
+  const arrayBuffer = new ArrayBuffer(totalSize);
+  const view = new Uint8Array(arrayBuffer);
+  let dstOffset = 0;
+  for (let i = 0; i < chunks.length; i++) {
+    dstOffset += writeChunk(b64Str, chunks[i], dstOffset, view);
+    dstOffset += (4 - chunks[i].count % 4) % 4;
   }
-
   return arrayBuffer;
 }
-
 function encodeTriplet(v1, v2, v3) {
-  var triplet = (v1 << 16) + (v2 << 8) + v3;
+  const triplet = (v1 << 16) + (v2 << 8) + v3;
   return BASE64_CODE[triplet >> 18] + BASE64_CODE[triplet >> 12 & 0x3f] + BASE64_CODE[triplet >> 6 & 0x3f] + BASE64_CODE[triplet & 0x3f];
 }
-
 function fromArrayBuffer(ab) {
-  var uint8 = new Uint8Array(ab);
-  var leftoverLength = ab.byteLength % 3;
-  var maxTripletIndex = ab.byteLength - leftoverLength;
-  var segments = Array(maxTripletIndex / 3);
-
-  for (var _i4 = 0; _i4 < segments.length; _i4++) {
-    var bufOffset = _i4 * 3;
-    segments[_i4] = encodeTriplet(uint8[bufOffset], uint8[bufOffset + 1], uint8[bufOffset + 2]);
+  const uint8 = new Uint8Array(ab);
+  const leftoverLength = ab.byteLength % 3;
+  const maxTripletIndex = ab.byteLength - leftoverLength;
+  const segments = Array(maxTripletIndex / 3);
+  for (let i = 0; i < segments.length; i++) {
+    const bufOffset = i * 3;
+    segments[i] = encodeTriplet(uint8[bufOffset], uint8[bufOffset + 1], uint8[bufOffset + 2]);
   }
-
   if (leftoverLength > 0) {
-    var segment = encodeTriplet(uint8[maxTripletIndex], uint8[maxTripletIndex + 1] || 0, uint8[maxTripletIndex + 2] || 0);
-
+    const segment = encodeTriplet(uint8[maxTripletIndex], uint8[maxTripletIndex + 1] || 0, uint8[maxTripletIndex + 2] || 0);
     if (leftoverLength === 1) {
-      segments.push("".concat(segment.substr(0, 2), "=="));
+      segments.push(`${segment.substr(0, 2)}==`);
     } else if (leftoverLength === 2) {
-      segments.push("".concat(segment.substr(0, 3), "="));
+      segments.push(`${segment.substr(0, 3)}=`);
     }
   }
-
   return segments.join('');
 }
 var Base64 = {
-  toArrayBuffer: toArrayBuffer,
-  fromArrayBuffer: fromArrayBuffer
+  toArrayBuffer,
+  fromArrayBuffer
 };
 
 export { Base64 as default, fromArrayBuffer, toArrayBuffer };

package/Common/Core/CellArray.js

@@ -1,86 +1,75 @@
-import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
-import _defineProperty from '@babel/runtime/helpers/defineProperty';
-import macro from '../../macros.js';
+import { m as macro } from '../../macros2.js';
 import vtkDataArray from './DataArray.js';
 import { VtkDataTypes } from './DataArray/Constants.js';
 
-function 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; }
-
-function _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; }
+// ----------------------------------------------------------------------------
 // Global methods
 // ----------------------------------------------------------------------------
 
 function extractCellSizes(cellArray) {
-  var currentIdx = 0;
-  return cellArray.filter(function (value, index) {
+  let currentIdx = 0;
+  return cellArray.filter((value, index) => {
     if (index === currentIdx) {
       currentIdx += value + 1;
       return true;
     }
-
     return false;
   });
 }
-
 function getNumberOfCells(cellArray) {
-  var cellId = 0;
-
-  for (var cellArrayIndex = 0; cellArrayIndex < cellArray.length;) {
+  let cellId = 0;
+  for (let cellArrayIndex = 0; cellArrayIndex < cellArray.length;) {
     cellArrayIndex += cellArray[cellArrayIndex] + 1;
     cellId++;
   }
-
   return cellId;
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Static API
 // ----------------------------------------------------------------------------
 
+const STATIC = {
+  extractCellSizes,
+  getNumberOfCells
+};
 
-var STATIC = {
-  extractCellSizes: extractCellSizes,
-  getNumberOfCells: getNumberOfCells
-}; // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
 // vtkCellArray methods
 // ----------------------------------------------------------------------------
 
 function vtkCellArray(publicAPI, model) {
   // Set our className
   model.classHierarchy.push('vtkCellArray');
-
-  var superClass = _objectSpread({}, publicAPI);
-
-  publicAPI.getNumberOfCells = function (recompute) {
+  const superClass = {
+    ...publicAPI
+  };
+  publicAPI.getNumberOfCells = recompute => {
     if (model.numberOfCells !== undefined && !recompute) {
       return model.numberOfCells;
     }
-
     if (model.cellSizes) {
       model.numberOfCells = model.cellSizes.length;
     } else {
       model.numberOfCells = getNumberOfCells(publicAPI.getData());
     }
-
     return model.numberOfCells;
   };
-
-  publicAPI.getCellSizes = function (recompute) {
+  publicAPI.getCellSizes = recompute => {
     if (model.cellSizes !== undefined && !recompute) {
       return model.cellSizes;
     }
-
     model.cellSizes = extractCellSizes(publicAPI.getData());
     return model.cellSizes;
   };
+
   /**
    * When `resize()` is being used, you then MUST use `insertNextCell()`.
    */
-
-
-  publicAPI.resize = function (requestedNumTuples) {
-    var oldNumTuples = publicAPI.getNumberOfTuples();
+  publicAPI.resize = requestedNumTuples => {
+    const oldNumTuples = publicAPI.getNumberOfTuples();
     superClass.resize(requestedNumTuples);
-    var newNumTuples = publicAPI.getNumberOfTuples();
-
+    const newNumTuples = publicAPI.getNumberOfTuples();
     if (newNumTuples < oldNumTuples) {
       if (newNumTuples === 0) {
         model.numberOfCells = 0;
@@ -93,56 +82,59 @@ function vtkCellArray(publicAPI, model) {
       }
     }
   };
-
-  publicAPI.setData = function (typedArray) {
+  publicAPI.setData = typedArray => {
     superClass.setData(typedArray, 1);
     model.numberOfCells = undefined;
     model.cellSizes = undefined;
   };
-
-  publicAPI.getCell = function (loc) {
-    var cellLoc = loc;
-    var numberOfPoints = model.values[cellLoc++];
+  publicAPI.getCell = loc => {
+    let cellLoc = loc;
+    const numberOfPoints = model.values[cellLoc++];
     return model.values.subarray(cellLoc, cellLoc + numberOfPoints);
   };
-
-  publicAPI.insertNextCell = function (cellPointIds) {
-    var cellId = publicAPI.getNumberOfCells();
-    publicAPI.insertNextTuples([cellPointIds.length].concat(_toConsumableArray(cellPointIds))); // By computing the number of cells earlier, we made sure that numberOfCells is defined
-
+  publicAPI.insertNextCell = cellPointIds => {
+    const cellId = publicAPI.getNumberOfCells();
+    publicAPI.insertNextTuples([cellPointIds.length, ...cellPointIds]);
+    // By computing the number of cells earlier, we made sure that numberOfCells is defined
     ++model.numberOfCells;
-
     if (model.cellSizes != null) {
       model.cellSizes.push(cellPointIds.length);
     }
-
     return cellId;
   };
-} // ----------------------------------------------------------------------------
+}
+
+// ----------------------------------------------------------------------------
 // Object factory
 // ----------------------------------------------------------------------------
 
-
 function defaultValues(initialValues) {
-  return _objectSpread({
+  return {
     empty: true,
     numberOfComponents: 1,
-    dataType: VtkDataTypes.UNSIGNED_INT
-  }, initialValues);
-} // ----------------------------------------------------------------------------
+    dataType: VtkDataTypes.UNSIGNED_INT,
+    ...initialValues
+  };
+}
 
+// ----------------------------------------------------------------------------
 
 function extend(publicAPI, model) {
-  var initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  let initialValues = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   vtkDataArray.extend(publicAPI, model, defaultValues(initialValues));
   vtkCellArray(publicAPI, model);
-} // ----------------------------------------------------------------------------
+}
 
-var newInstance = macro.newInstance(extend, 'vtkCellArray'); // ----------------------------------------------------------------------------
+// ----------------------------------------------------------------------------
+
+const newInstance = macro.newInstance(extend, 'vtkCellArray');
+
+// ----------------------------------------------------------------------------
 
-var vtkCellArray$1 = _objectSpread({
-  newInstance: newInstance,
-  extend: extend
-}, STATIC);
+var vtkCellArray$1 = {
+  newInstance,
+  extend,
+  ...STATIC
+};
 
 export { STATIC, vtkCellArray$1 as default, extend, newInstance };

package/Common/Core/ClassHierarchy.js

@@ -1,41 +1,13 @@
-import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
-import _createClass from '@babel/runtime/helpers/createClass';
-import _get from '@babel/runtime/helpers/get';
-import _inherits from '@babel/runtime/helpers/inherits';
-import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
-import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
-import _wrapNativeSuper from '@babel/runtime/helpers/wrapNativeSuper';
-
-function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
-
-function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
-
 /* eslint-disable prefer-rest-params */
-var ClassHierarchy = /*#__PURE__*/function (_Array) {
-  _inherits(ClassHierarchy, _Array);
-
-  var _super = _createSuper(ClassHierarchy);
-
-  function ClassHierarchy() {
-    _classCallCheck(this, ClassHierarchy);
-
-    return _super.apply(this, arguments);
-  }
-
-  _createClass(ClassHierarchy, [{
-    key: "push",
-    value: function push() {
-      for (var i = 0; i < arguments.length; i++) {
-        if (!this.includes(arguments[i])) {
-          _get(_getPrototypeOf(ClassHierarchy.prototype), "push", this).call(this, arguments[i]);
-        }
+class ClassHierarchy extends Array {
+  push() {
+    for (let i = 0; i < arguments.length; i++) {
+      if (!this.includes(arguments[i])) {
+        super.push(arguments[i]);
       }
-
-      return this.length;
     }
-  }]);
-
-  return ClassHierarchy;
-}( /*#__PURE__*/_wrapNativeSuper(Array));
+    return this.length;
+  }
+}
 
 export { ClassHierarchy as default };

package/Common/Core/DataArray/Constants.js

@@ -1,4 +1,4 @@
-var DataTypeByteSize = {
+const DataTypeByteSize = {
   Int8Array: 1,
   Uint8Array: 1,
   Uint8ClampedArray: 1,
@@ -9,7 +9,7 @@ var DataTypeByteSize = {
   Float32Array: 4,
   Float64Array: 8
 };
-var VtkDataTypes = {
+const VtkDataTypes = {
   VOID: '',
   // not sure to know what that should be
   CHAR: 'Int8Array',
@@ -22,11 +22,11 @@ var VtkDataTypes = {
   FLOAT: 'Float32Array',
   DOUBLE: 'Float64Array'
 };
-var DefaultDataType = VtkDataTypes.FLOAT;
+const DefaultDataType = VtkDataTypes.FLOAT;
 var Constants = {
-  DefaultDataType: DefaultDataType,
-  DataTypeByteSize: DataTypeByteSize,
-  VtkDataTypes: VtkDataTypes
+  DefaultDataType,
+  DataTypeByteSize,
+  VtkDataTypes
 };
 
 export { DataTypeByteSize, DefaultDataType, VtkDataTypes, Constants as default };