opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/loaders/PCDLoader.js

@@ -0,0 +1,322 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.PCDLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PCDLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  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; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var PCDLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(PCDLoader, _Loader);
+
+    var _super = _createSuper(PCDLoader);
+
+    function PCDLoader(manager) {
+      var _this;
+
+      _classCallCheck(this, PCDLoader);
+
+      _this = _super.call(this, manager);
+      _this.littleEndian = true;
+      return _this;
+    }
+
+    _createClass(PCDLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setResponseType('arraybuffer');
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (data) {
+          try {
+            onLoad(scope.parse(data, url));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      }
+    }, {
+      key: "parse",
+      value: function parse(data, url) {
+        // from https://gitlab.com/taketwo/three-pcd-loader/blob/master/decompress-lzf.js
+        function decompressLZF(inData, outLength) {
+          var inLength = inData.length;
+          var outData = new Uint8Array(outLength);
+          var inPtr = 0;
+          var outPtr = 0;
+          var ctrl;
+          var len;
+          var ref;
+
+          do {
+            ctrl = inData[inPtr++];
+
+            if (ctrl < 1 << 5) {
+              ctrl++;
+              if (outPtr + ctrl > outLength) throw new Error('Output buffer is not large enough');
+              if (inPtr + ctrl > inLength) throw new Error('Invalid compressed data');
+
+              do {
+                outData[outPtr++] = inData[inPtr++];
+              } while (--ctrl);
+            } else {
+              len = ctrl >> 5;
+              ref = outPtr - ((ctrl & 0x1f) << 8) - 1;
+              if (inPtr >= inLength) throw new Error('Invalid compressed data');
+
+              if (len === 7) {
+                len += inData[inPtr++];
+                if (inPtr >= inLength) throw new Error('Invalid compressed data');
+              }
+
+              ref -= inData[inPtr++];
+              if (outPtr + len + 2 > outLength) throw new Error('Output buffer is not large enough');
+              if (ref < 0) throw new Error('Invalid compressed data');
+              if (ref >= outPtr) throw new Error('Invalid compressed data');
+
+              do {
+                outData[outPtr++] = outData[ref++];
+              } while (--len + 2);
+            }
+          } while (inPtr < inLength);
+
+          return outData;
+        }
+
+        function parseHeader(data) {
+          var PCDheader = {};
+          var result1 = data.search(/[\r\n]DATA\s(\S*)\s/i);
+          var result2 = /[\r\n]DATA\s(\S*)\s/i.exec(data.substr(result1 - 1));
+          PCDheader.data = result2[1];
+          PCDheader.headerLen = result2[0].length + result1;
+          PCDheader.str = data.substr(0, PCDheader.headerLen); // remove comments
+
+          PCDheader.str = PCDheader.str.replace(/\#.*/gi, ''); // parse
+
+          PCDheader.version = /VERSION (.*)/i.exec(PCDheader.str);
+          PCDheader.fields = /FIELDS (.*)/i.exec(PCDheader.str);
+          PCDheader.size = /SIZE (.*)/i.exec(PCDheader.str);
+          PCDheader.type = /TYPE (.*)/i.exec(PCDheader.str);
+          PCDheader.count = /COUNT (.*)/i.exec(PCDheader.str);
+          PCDheader.width = /WIDTH (.*)/i.exec(PCDheader.str);
+          PCDheader.height = /HEIGHT (.*)/i.exec(PCDheader.str);
+          PCDheader.viewpoint = /VIEWPOINT (.*)/i.exec(PCDheader.str);
+          PCDheader.points = /POINTS (.*)/i.exec(PCDheader.str); // evaluate
+
+          if (PCDheader.version !== null) PCDheader.version = parseFloat(PCDheader.version[1]);
+          if (PCDheader.fields !== null) PCDheader.fields = PCDheader.fields[1].split(' ');
+          if (PCDheader.type !== null) PCDheader.type = PCDheader.type[1].split(' ');
+          if (PCDheader.width !== null) PCDheader.width = parseInt(PCDheader.width[1]);
+          if (PCDheader.height !== null) PCDheader.height = parseInt(PCDheader.height[1]);
+          if (PCDheader.viewpoint !== null) PCDheader.viewpoint = PCDheader.viewpoint[1];
+          if (PCDheader.points !== null) PCDheader.points = parseInt(PCDheader.points[1], 10);
+          if (PCDheader.points === null) PCDheader.points = PCDheader.width * PCDheader.height;
+
+          if (PCDheader.size !== null) {
+            PCDheader.size = PCDheader.size[1].split(' ').map(function (x) {
+              return parseInt(x, 10);
+            });
+          }
+
+          if (PCDheader.count !== null) {
+            PCDheader.count = PCDheader.count[1].split(' ').map(function (x) {
+              return parseInt(x, 10);
+            });
+          } else {
+            PCDheader.count = [];
+
+            for (var i = 0, l = PCDheader.fields.length; i < l; i++) {
+              PCDheader.count.push(1);
+            }
+          }
+
+          PCDheader.offset = {};
+          var sizeSum = 0;
+
+          for (var _i = 0, _l = PCDheader.fields.length; _i < _l; _i++) {
+            if (PCDheader.data === 'ascii') {
+              PCDheader.offset[PCDheader.fields[_i]] = _i;
+            } else {
+              PCDheader.offset[PCDheader.fields[_i]] = sizeSum;
+              sizeSum += PCDheader.size[_i] * PCDheader.count[_i];
+            }
+          } // for binary only
+
+
+          PCDheader.rowSize = sizeSum;
+          return PCDheader;
+        }
+
+        var textData = _three.LoaderUtils.decodeText(new Uint8Array(data)); // parse header (always ascii format)
+
+
+        var PCDheader = parseHeader(textData); // parse data
+
+        var position = [];
+        var normal = [];
+        var color = []; // ascii
+
+        if (PCDheader.data === 'ascii') {
+          var offset = PCDheader.offset;
+          var pcdData = textData.substr(PCDheader.headerLen);
+          var lines = pcdData.split('\n');
+
+          for (var i = 0, l = lines.length; i < l; i++) {
+            if (lines[i] === '') continue;
+            var line = lines[i].split(' ');
+
+            if (offset.x !== undefined) {
+              position.push(parseFloat(line[offset.x]));
+              position.push(parseFloat(line[offset.y]));
+              position.push(parseFloat(line[offset.z]));
+            }
+
+            if (offset.rgb !== undefined) {
+              var rgb = parseFloat(line[offset.rgb]);
+              var r = rgb >> 16 & 0x0000ff;
+              var g = rgb >> 8 & 0x0000ff;
+              var b = rgb >> 0 & 0x0000ff;
+              color.push(r / 255, g / 255, b / 255);
+            }
+
+            if (offset.normal_x !== undefined) {
+              normal.push(parseFloat(line[offset.normal_x]));
+              normal.push(parseFloat(line[offset.normal_y]));
+              normal.push(parseFloat(line[offset.normal_z]));
+            }
+          }
+        } // binary-compressed
+        // normally data in PCD files are organized as array of structures: XYZRGBXYZRGB
+        // binary compressed PCD files organize their data as structure of arrays: XXYYZZRGBRGB
+        // that requires a totally different parsing approach compared to non-compressed data
+
+
+        if (PCDheader.data === 'binary_compressed') {
+          var sizes = new Uint32Array(data.slice(PCDheader.headerLen, PCDheader.headerLen + 8));
+          var compressedSize = sizes[0];
+          var decompressedSize = sizes[1];
+          var decompressed = decompressLZF(new Uint8Array(data, PCDheader.headerLen + 8, compressedSize), decompressedSize);
+          var dataview = new DataView(decompressed.buffer);
+          var _offset = PCDheader.offset;
+
+          for (var _i2 = 0; _i2 < PCDheader.points; _i2++) {
+            if (_offset.x !== undefined) {
+              position.push(dataview.getFloat32(PCDheader.points * _offset.x + PCDheader.size[0] * _i2, this.littleEndian));
+              position.push(dataview.getFloat32(PCDheader.points * _offset.y + PCDheader.size[1] * _i2, this.littleEndian));
+              position.push(dataview.getFloat32(PCDheader.points * _offset.z + PCDheader.size[2] * _i2, this.littleEndian));
+            }
+
+            if (_offset.rgb !== undefined) {
+              color.push(dataview.getUint8(PCDheader.points * _offset.rgb + PCDheader.size[3] * _i2 + 0) / 255.0);
+              color.push(dataview.getUint8(PCDheader.points * _offset.rgb + PCDheader.size[3] * _i2 + 1) / 255.0);
+              color.push(dataview.getUint8(PCDheader.points * _offset.rgb + PCDheader.size[3] * _i2 + 2) / 255.0);
+            }
+
+            if (_offset.normal_x !== undefined) {
+              normal.push(dataview.getFloat32(PCDheader.points * _offset.normal_x + PCDheader.size[4] * _i2, this.littleEndian));
+              normal.push(dataview.getFloat32(PCDheader.points * _offset.normal_y + PCDheader.size[5] * _i2, this.littleEndian));
+              normal.push(dataview.getFloat32(PCDheader.points * _offset.normal_z + PCDheader.size[6] * _i2, this.littleEndian));
+            }
+          }
+        } // binary
+
+
+        if (PCDheader.data === 'binary') {
+          var _dataview = new DataView(data, PCDheader.headerLen);
+
+          var _offset2 = PCDheader.offset;
+
+          for (var _i3 = 0, row = 0; _i3 < PCDheader.points; _i3++, row += PCDheader.rowSize) {
+            if (_offset2.x !== undefined) {
+              position.push(_dataview.getFloat32(row + _offset2.x, this.littleEndian));
+              position.push(_dataview.getFloat32(row + _offset2.y, this.littleEndian));
+              position.push(_dataview.getFloat32(row + _offset2.z, this.littleEndian));
+            }
+
+            if (_offset2.rgb !== undefined) {
+              color.push(_dataview.getUint8(row + _offset2.rgb + 2) / 255.0);
+              color.push(_dataview.getUint8(row + _offset2.rgb + 1) / 255.0);
+              color.push(_dataview.getUint8(row + _offset2.rgb + 0) / 255.0);
+            }
+
+            if (_offset2.normal_x !== undefined) {
+              normal.push(_dataview.getFloat32(row + _offset2.normal_x, this.littleEndian));
+              normal.push(_dataview.getFloat32(row + _offset2.normal_y, this.littleEndian));
+              normal.push(_dataview.getFloat32(row + _offset2.normal_z, this.littleEndian));
+            }
+          }
+        } // build geometry
+
+
+        var geometry = new _three.BufferGeometry();
+        if (position.length > 0) geometry.setAttribute('position', new _three.Float32BufferAttribute(position, 3));
+        if (normal.length > 0) geometry.setAttribute('normal', new _three.Float32BufferAttribute(normal, 3));
+        if (color.length > 0) geometry.setAttribute('color', new _three.Float32BufferAttribute(color, 3));
+        geometry.computeBoundingSphere(); // build material
+
+        var material = new _three.PointsMaterial({
+          size: 0.005
+        });
+
+        if (color.length > 0) {
+          material.vertexColors = true;
+        } else {
+          material.color.setHex(Math.random() * 0xffffff);
+        } // build point cloud
+
+
+        var mesh = new _three.Points(geometry, material);
+        var name = url.split('').reverse().join('');
+        name = /([^\/]*)/.exec(name);
+        name = name[1].split('').reverse().join('');
+        mesh.name = name;
+        return mesh;
+      }
+    }]);
+
+    return PCDLoader;
+  }(_three.Loader);
+
+  _exports.PCDLoader = PCDLoader;
+});

data/lib-opal/js_wrap/three/loaders/PDBLoader.js

@@ -0,0 +1,318 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three);
+    global.PDBLoader = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.PDBLoader = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  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 _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  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; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var PDBLoader = /*#__PURE__*/function (_Loader) {
+    _inherits(PDBLoader, _Loader);
+
+    var _super = _createSuper(PDBLoader);
+
+    function PDBLoader(manager) {
+      _classCallCheck(this, PDBLoader);
+
+      return _super.call(this, manager);
+    }
+
+    _createClass(PDBLoader, [{
+      key: "load",
+      value: function load(url, onLoad, onProgress, onError) {
+        var scope = this;
+        var loader = new _three.FileLoader(scope.manager);
+        loader.setPath(scope.path);
+        loader.setRequestHeader(scope.requestHeader);
+        loader.setWithCredentials(scope.withCredentials);
+        loader.load(url, function (text) {
+          try {
+            onLoad(scope.parse(text));
+          } catch (e) {
+            if (onError) {
+              onError(e);
+            } else {
+              console.error(e);
+            }
+
+            scope.manager.itemError(url);
+          }
+        }, onProgress, onError);
+      } // Based on CanvasMol PDB parser
+
+    }, {
+      key: "parse",
+      value: function parse(text) {
+        function trim(text) {
+          return text.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+        }
+
+        function capitalize(text) {
+          return text.charAt(0).toUpperCase() + text.substr(1).toLowerCase();
+        }
+
+        function hash(s, e) {
+          return 's' + Math.min(s, e) + 'e' + Math.max(s, e);
+        }
+
+        function parseBond(start, length, satom, i) {
+          var eatom = parseInt(lines[i].substr(start, length));
+
+          if (eatom) {
+            var h = hash(satom, eatom);
+
+            if (_bhash[h] === undefined) {
+              _bonds.push([satom - 1, eatom - 1, 1]);
+
+              _bhash[h] = _bonds.length - 1;
+            } else {// doesn't really work as almost all PDBs
+              // have just normal bonds appearing multiple
+              // times instead of being double/triple bonds
+              // bonds[bhash[h]][2] += 1;
+            }
+          }
+        }
+
+        function buildGeometry() {
+          var build = {
+            geometryAtoms: new _three.BufferGeometry(),
+            geometryBonds: new _three.BufferGeometry(),
+            json: {
+              atoms: atoms
+            }
+          };
+          var geometryAtoms = build.geometryAtoms;
+          var geometryBonds = build.geometryBonds;
+          var verticesAtoms = [];
+          var colorsAtoms = [];
+          var verticesBonds = []; // atoms
+
+          for (var i = 0, l = atoms.length; i < l; i++) {
+            var atom = atoms[i];
+            var x = atom[0];
+            var y = atom[1];
+            var z = atom[2];
+            verticesAtoms.push(x, y, z);
+            var r = atom[3][0] / 255;
+            var g = atom[3][1] / 255;
+            var b = atom[3][2] / 255;
+            colorsAtoms.push(r, g, b);
+          } // bonds
+
+
+          for (var _i = 0, _l = _bonds.length; _i < _l; _i++) {
+            var bond = _bonds[_i];
+            var start = bond[0];
+            var end = bond[1];
+            var startAtom = _atomMap[start];
+            var endAtom = _atomMap[end];
+            var _x = startAtom[0];
+            var _y = startAtom[1];
+            var _z = startAtom[2];
+            verticesBonds.push(_x, _y, _z);
+            _x = endAtom[0];
+            _y = endAtom[1];
+            _z = endAtom[2];
+            verticesBonds.push(_x, _y, _z);
+          } // build geometry
+
+
+          geometryAtoms.setAttribute('position', new _three.Float32BufferAttribute(verticesAtoms, 3));
+          geometryAtoms.setAttribute('color', new _three.Float32BufferAttribute(colorsAtoms, 3));
+          geometryBonds.setAttribute('position', new _three.Float32BufferAttribute(verticesBonds, 3));
+          return build;
+        }
+
+        var CPK = {
+          h: [255, 255, 255],
+          he: [217, 255, 255],
+          li: [204, 128, 255],
+          be: [194, 255, 0],
+          b: [255, 181, 181],
+          c: [144, 144, 144],
+          n: [48, 80, 248],
+          o: [255, 13, 13],
+          f: [144, 224, 80],
+          ne: [179, 227, 245],
+          na: [171, 92, 242],
+          mg: [138, 255, 0],
+          al: [191, 166, 166],
+          si: [240, 200, 160],
+          p: [255, 128, 0],
+          s: [255, 255, 48],
+          cl: [31, 240, 31],
+          ar: [128, 209, 227],
+          k: [143, 64, 212],
+          ca: [61, 255, 0],
+          sc: [230, 230, 230],
+          ti: [191, 194, 199],
+          v: [166, 166, 171],
+          cr: [138, 153, 199],
+          mn: [156, 122, 199],
+          fe: [224, 102, 51],
+          co: [240, 144, 160],
+          ni: [80, 208, 80],
+          cu: [200, 128, 51],
+          zn: [125, 128, 176],
+          ga: [194, 143, 143],
+          ge: [102, 143, 143],
+          as: [189, 128, 227],
+          se: [255, 161, 0],
+          br: [166, 41, 41],
+          kr: [92, 184, 209],
+          rb: [112, 46, 176],
+          sr: [0, 255, 0],
+          y: [148, 255, 255],
+          zr: [148, 224, 224],
+          nb: [115, 194, 201],
+          mo: [84, 181, 181],
+          tc: [59, 158, 158],
+          ru: [36, 143, 143],
+          rh: [10, 125, 140],
+          pd: [0, 105, 133],
+          ag: [192, 192, 192],
+          cd: [255, 217, 143],
+          in: [166, 117, 115],
+          sn: [102, 128, 128],
+          sb: [158, 99, 181],
+          te: [212, 122, 0],
+          i: [148, 0, 148],
+          xe: [66, 158, 176],
+          cs: [87, 23, 143],
+          ba: [0, 201, 0],
+          la: [112, 212, 255],
+          ce: [255, 255, 199],
+          pr: [217, 255, 199],
+          nd: [199, 255, 199],
+          pm: [163, 255, 199],
+          sm: [143, 255, 199],
+          eu: [97, 255, 199],
+          gd: [69, 255, 199],
+          tb: [48, 255, 199],
+          dy: [31, 255, 199],
+          ho: [0, 255, 156],
+          er: [0, 230, 117],
+          tm: [0, 212, 82],
+          yb: [0, 191, 56],
+          lu: [0, 171, 36],
+          hf: [77, 194, 255],
+          ta: [77, 166, 255],
+          w: [33, 148, 214],
+          re: [38, 125, 171],
+          os: [38, 102, 150],
+          ir: [23, 84, 135],
+          pt: [208, 208, 224],
+          au: [255, 209, 35],
+          hg: [184, 184, 208],
+          tl: [166, 84, 77],
+          pb: [87, 89, 97],
+          bi: [158, 79, 181],
+          po: [171, 92, 0],
+          at: [117, 79, 69],
+          rn: [66, 130, 150],
+          fr: [66, 0, 102],
+          ra: [0, 125, 0],
+          ac: [112, 171, 250],
+          th: [0, 186, 255],
+          pa: [0, 161, 255],
+          u: [0, 143, 255],
+          np: [0, 128, 255],
+          pu: [0, 107, 255],
+          am: [84, 92, 242],
+          cm: [120, 92, 227],
+          bk: [138, 79, 227],
+          cf: [161, 54, 212],
+          es: [179, 31, 212],
+          fm: [179, 31, 186],
+          md: [179, 13, 166],
+          no: [189, 13, 135],
+          lr: [199, 0, 102],
+          rf: [204, 0, 89],
+          db: [209, 0, 79],
+          sg: [217, 0, 69],
+          bh: [224, 0, 56],
+          hs: [230, 0, 46],
+          mt: [235, 0, 38],
+          ds: [235, 0, 38],
+          rg: [235, 0, 38],
+          cn: [235, 0, 38],
+          uut: [235, 0, 38],
+          uuq: [235, 0, 38],
+          uup: [235, 0, 38],
+          uuh: [235, 0, 38],
+          uus: [235, 0, 38],
+          uuo: [235, 0, 38]
+        };
+        var atoms = [];
+        var _bonds = [];
+        var _bhash = {};
+        var _atomMap = {}; // parse
+
+        var lines = text.split('\n');
+
+        for (var i = 0, l = lines.length; i < l; i++) {
+          if (lines[i].substr(0, 4) === 'ATOM' || lines[i].substr(0, 6) === 'HETATM') {
+            var x = parseFloat(lines[i].substr(30, 7));
+            var y = parseFloat(lines[i].substr(38, 7));
+            var z = parseFloat(lines[i].substr(46, 7));
+            var index = parseInt(lines[i].substr(6, 5)) - 1;
+            var e = trim(lines[i].substr(76, 2)).toLowerCase();
+
+            if (e === '') {
+              e = trim(lines[i].substr(12, 2)).toLowerCase();
+            }
+
+            var atomData = [x, y, z, CPK[e], capitalize(e)];
+            atoms.push(atomData);
+            _atomMap[index] = atomData;
+          } else if (lines[i].substr(0, 6) === 'CONECT') {
+            var satom = parseInt(lines[i].substr(6, 5));
+            parseBond(11, 5, satom, i);
+            parseBond(16, 5, satom, i);
+            parseBond(21, 5, satom, i);
+            parseBond(26, 5, satom, i);
+          }
+        } // build and return geometry
+
+
+        return buildGeometry();
+      }
+    }]);
+
+    return PDBLoader;
+  }(_three.Loader);
+
+  _exports.PDBLoader = PDBLoader;
+});