New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
js3dlook - npm Package Compare versions
Comparing version 1.0.5 to 1.0.6
| (function (global, factory) { | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : | ||
| typeof define === 'function' && define.amd ? define(factory) : | ||
| typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('whatwg-fetch')) : | ||
| typeof define === 'function' && define.amd ? define(['whatwg-fetch'], factory) : | ||
| (global.js3dlook = factory()); | ||
| }(this, (function () { 'use strict'; | ||
| (function(self) { | ||
| 'use strict'; | ||
| if (self.fetch) { | ||
| return | ||
| } | ||
| var support = { | ||
| searchParams: 'URLSearchParams' in self, | ||
| iterable: 'Symbol' in self && 'iterator' in Symbol, | ||
| blob: 'FileReader' in self && 'Blob' in self && (function() { | ||
| try { | ||
| new Blob(); | ||
| return true | ||
| } catch(e) { | ||
| return false | ||
| } | ||
| })(), | ||
| formData: 'FormData' in self, | ||
| arrayBuffer: 'ArrayBuffer' in self | ||
| }; | ||
| if (support.arrayBuffer) { | ||
| var viewClasses = [ | ||
| '[object Int8Array]', | ||
| '[object Uint8Array]', | ||
| '[object Uint8ClampedArray]', | ||
| '[object Int16Array]', | ||
| '[object Uint16Array]', | ||
| '[object Int32Array]', | ||
| '[object Uint32Array]', | ||
| '[object Float32Array]', | ||
| '[object Float64Array]' | ||
| ]; | ||
| var isDataView = function(obj) { | ||
| return obj && DataView.prototype.isPrototypeOf(obj) | ||
| }; | ||
| var isArrayBufferView = ArrayBuffer.isView || function(obj) { | ||
| return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1 | ||
| }; | ||
| } | ||
| function normalizeName(name) { | ||
| if (typeof name !== 'string') { | ||
| name = String(name); | ||
| } | ||
| if (/[^a-z0-9\-#$%&'*+.\^_`|~]/i.test(name)) { | ||
| throw new TypeError('Invalid character in header field name') | ||
| } | ||
| return name.toLowerCase() | ||
| } | ||
| function normalizeValue(value) { | ||
| if (typeof value !== 'string') { | ||
| value = String(value); | ||
| } | ||
| return value | ||
| } | ||
| // Build a destructive iterator for the value list | ||
| function iteratorFor(items) { | ||
| var iterator = { | ||
| next: function() { | ||
| var value = items.shift(); | ||
| return {done: value === undefined, value: value} | ||
| } | ||
| }; | ||
| if (support.iterable) { | ||
| iterator[Symbol.iterator] = function() { | ||
| return iterator | ||
| }; | ||
| } | ||
| return iterator | ||
| } | ||
| function Headers(headers) { | ||
| this.map = {}; | ||
| if (headers instanceof Headers) { | ||
| headers.forEach(function(value, name) { | ||
| this.append(name, value); | ||
| }, this); | ||
| } else if (Array.isArray(headers)) { | ||
| headers.forEach(function(header) { | ||
| this.append(header[0], header[1]); | ||
| }, this); | ||
| } else if (headers) { | ||
| Object.getOwnPropertyNames(headers).forEach(function(name) { | ||
| this.append(name, headers[name]); | ||
| }, this); | ||
| } | ||
| } | ||
| Headers.prototype.append = function(name, value) { | ||
| name = normalizeName(name); | ||
| value = normalizeValue(value); | ||
| var oldValue = this.map[name]; | ||
| this.map[name] = oldValue ? oldValue+','+value : value; | ||
| }; | ||
| Headers.prototype['delete'] = function(name) { | ||
| delete this.map[normalizeName(name)]; | ||
| }; | ||
| Headers.prototype.get = function(name) { | ||
| name = normalizeName(name); | ||
| return this.has(name) ? this.map[name] : null | ||
| }; | ||
| Headers.prototype.has = function(name) { | ||
| return this.map.hasOwnProperty(normalizeName(name)) | ||
| }; | ||
| Headers.prototype.set = function(name, value) { | ||
| this.map[normalizeName(name)] = normalizeValue(value); | ||
| }; | ||
| Headers.prototype.forEach = function(callback, thisArg) { | ||
| for (var name in this.map) { | ||
| if (this.map.hasOwnProperty(name)) { | ||
| callback.call(thisArg, this.map[name], name, this); | ||
| } | ||
| } | ||
| }; | ||
| Headers.prototype.keys = function() { | ||
| var items = []; | ||
| this.forEach(function(value, name) { items.push(name); }); | ||
| return iteratorFor(items) | ||
| }; | ||
| Headers.prototype.values = function() { | ||
| var items = []; | ||
| this.forEach(function(value) { items.push(value); }); | ||
| return iteratorFor(items) | ||
| }; | ||
| Headers.prototype.entries = function() { | ||
| var items = []; | ||
| this.forEach(function(value, name) { items.push([name, value]); }); | ||
| return iteratorFor(items) | ||
| }; | ||
| if (support.iterable) { | ||
| Headers.prototype[Symbol.iterator] = Headers.prototype.entries; | ||
| } | ||
| function consumed(body) { | ||
| if (body.bodyUsed) { | ||
| return Promise.reject(new TypeError('Already read')) | ||
| } | ||
| body.bodyUsed = true; | ||
| } | ||
| function fileReaderReady(reader) { | ||
| return new Promise(function(resolve, reject) { | ||
| reader.onload = function() { | ||
| resolve(reader.result); | ||
| }; | ||
| reader.onerror = function() { | ||
| reject(reader.error); | ||
| }; | ||
| }) | ||
| } | ||
| function readBlobAsArrayBuffer(blob) { | ||
| var reader = new FileReader(); | ||
| var promise = fileReaderReady(reader); | ||
| reader.readAsArrayBuffer(blob); | ||
| return promise | ||
| } | ||
| function readBlobAsText(blob) { | ||
| var reader = new FileReader(); | ||
| var promise = fileReaderReady(reader); | ||
| reader.readAsText(blob); | ||
| return promise | ||
| } | ||
| function readArrayBufferAsText(buf) { | ||
| var view = new Uint8Array(buf); | ||
| var chars = new Array(view.length); | ||
| for (var i = 0; i < view.length; i++) { | ||
| chars[i] = String.fromCharCode(view[i]); | ||
| } | ||
| return chars.join('') | ||
| } | ||
| function bufferClone(buf) { | ||
| if (buf.slice) { | ||
| return buf.slice(0) | ||
| } else { | ||
| var view = new Uint8Array(buf.byteLength); | ||
| view.set(new Uint8Array(buf)); | ||
| return view.buffer | ||
| } | ||
| } | ||
| function Body() { | ||
| this.bodyUsed = false; | ||
| this._initBody = function(body) { | ||
| this._bodyInit = body; | ||
| if (!body) { | ||
| this._bodyText = ''; | ||
| } else if (typeof body === 'string') { | ||
| this._bodyText = body; | ||
| } else if (support.blob && Blob.prototype.isPrototypeOf(body)) { | ||
| this._bodyBlob = body; | ||
| } else if (support.formData && FormData.prototype.isPrototypeOf(body)) { | ||
| this._bodyFormData = body; | ||
| } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { | ||
| this._bodyText = body.toString(); | ||
| } else if (support.arrayBuffer && support.blob && isDataView(body)) { | ||
| this._bodyArrayBuffer = bufferClone(body.buffer); | ||
| // IE 10-11 can't handle a DataView body. | ||
| this._bodyInit = new Blob([this._bodyArrayBuffer]); | ||
| } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) { | ||
| this._bodyArrayBuffer = bufferClone(body); | ||
| } else { | ||
| throw new Error('unsupported BodyInit type') | ||
| } | ||
| if (!this.headers.get('content-type')) { | ||
| if (typeof body === 'string') { | ||
| this.headers.set('content-type', 'text/plain;charset=UTF-8'); | ||
| } else if (this._bodyBlob && this._bodyBlob.type) { | ||
| this.headers.set('content-type', this._bodyBlob.type); | ||
| } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) { | ||
| this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8'); | ||
| } | ||
| } | ||
| }; | ||
| if (support.blob) { | ||
| this.blob = function() { | ||
| var rejected = consumed(this); | ||
| if (rejected) { | ||
| return rejected | ||
| } | ||
| if (this._bodyBlob) { | ||
| return Promise.resolve(this._bodyBlob) | ||
| } else if (this._bodyArrayBuffer) { | ||
| return Promise.resolve(new Blob([this._bodyArrayBuffer])) | ||
| } else if (this._bodyFormData) { | ||
| throw new Error('could not read FormData body as blob') | ||
| } else { | ||
| return Promise.resolve(new Blob([this._bodyText])) | ||
| } | ||
| }; | ||
| this.arrayBuffer = function() { | ||
| if (this._bodyArrayBuffer) { | ||
| return consumed(this) || Promise.resolve(this._bodyArrayBuffer) | ||
| } else { | ||
| return this.blob().then(readBlobAsArrayBuffer) | ||
| } | ||
| }; | ||
| } | ||
| this.text = function() { | ||
| var rejected = consumed(this); | ||
| if (rejected) { | ||
| return rejected | ||
| } | ||
| if (this._bodyBlob) { | ||
| return readBlobAsText(this._bodyBlob) | ||
| } else if (this._bodyArrayBuffer) { | ||
| return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer)) | ||
| } else if (this._bodyFormData) { | ||
| throw new Error('could not read FormData body as text') | ||
| } else { | ||
| return Promise.resolve(this._bodyText) | ||
| } | ||
| }; | ||
| if (support.formData) { | ||
| this.formData = function() { | ||
| return this.text().then(decode) | ||
| }; | ||
| } | ||
| this.json = function() { | ||
| return this.text().then(JSON.parse) | ||
| }; | ||
| return this | ||
| } | ||
| // HTTP methods whose capitalization should be normalized | ||
| var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT']; | ||
| function normalizeMethod(method) { | ||
| var upcased = method.toUpperCase(); | ||
| return (methods.indexOf(upcased) > -1) ? upcased : method | ||
| } | ||
| function Request(input, options) { | ||
| options = options || {}; | ||
| var body = options.body; | ||
| if (input instanceof Request) { | ||
| if (input.bodyUsed) { | ||
| throw new TypeError('Already read') | ||
| } | ||
| this.url = input.url; | ||
| this.credentials = input.credentials; | ||
| if (!options.headers) { | ||
| this.headers = new Headers(input.headers); | ||
| } | ||
| this.method = input.method; | ||
| this.mode = input.mode; | ||
| if (!body && input._bodyInit != null) { | ||
| body = input._bodyInit; | ||
| input.bodyUsed = true; | ||
| } | ||
| } else { | ||
| this.url = String(input); | ||
| } | ||
| this.credentials = options.credentials || this.credentials || 'omit'; | ||
| if (options.headers || !this.headers) { | ||
| this.headers = new Headers(options.headers); | ||
| } | ||
| this.method = normalizeMethod(options.method || this.method || 'GET'); | ||
| this.mode = options.mode || this.mode || null; | ||
| this.referrer = null; | ||
| if ((this.method === 'GET' || this.method === 'HEAD') && body) { | ||
| throw new TypeError('Body not allowed for GET or HEAD requests') | ||
| } | ||
| this._initBody(body); | ||
| } | ||
| Request.prototype.clone = function() { | ||
| return new Request(this, { body: this._bodyInit }) | ||
| }; | ||
| function decode(body) { | ||
| var form = new FormData(); | ||
| body.trim().split('&').forEach(function(bytes) { | ||
| if (bytes) { | ||
| var split = bytes.split('='); | ||
| var name = split.shift().replace(/\+/g, ' '); | ||
| var value = split.join('=').replace(/\+/g, ' '); | ||
| form.append(decodeURIComponent(name), decodeURIComponent(value)); | ||
| } | ||
| }); | ||
| return form | ||
| } | ||
| function parseHeaders(rawHeaders) { | ||
| var headers = new Headers(); | ||
| // Replace instances of \r\n and \n followed by at least one space or horizontal tab with a space | ||
| // https://tools.ietf.org/html/rfc7230#section-3.2 | ||
| var preProcessedHeaders = rawHeaders.replace(/\r?\n[\t ]+/g, ' '); | ||
| preProcessedHeaders.split(/\r?\n/).forEach(function(line) { | ||
| var parts = line.split(':'); | ||
| var key = parts.shift().trim(); | ||
| if (key) { | ||
| var value = parts.join(':').trim(); | ||
| headers.append(key, value); | ||
| } | ||
| }); | ||
| return headers | ||
| } | ||
| Body.call(Request.prototype); | ||
| function Response(bodyInit, options) { | ||
| if (!options) { | ||
| options = {}; | ||
| } | ||
| this.type = 'default'; | ||
| this.status = options.status === undefined ? 200 : options.status; | ||
| this.ok = this.status >= 200 && this.status < 300; | ||
| this.statusText = 'statusText' in options ? options.statusText : 'OK'; | ||
| this.headers = new Headers(options.headers); | ||
| this.url = options.url || ''; | ||
| this._initBody(bodyInit); | ||
| } | ||
| Body.call(Response.prototype); | ||
| Response.prototype.clone = function() { | ||
| return new Response(this._bodyInit, { | ||
| status: this.status, | ||
| statusText: this.statusText, | ||
| headers: new Headers(this.headers), | ||
| url: this.url | ||
| }) | ||
| }; | ||
| Response.error = function() { | ||
| var response = new Response(null, {status: 0, statusText: ''}); | ||
| response.type = 'error'; | ||
| return response | ||
| }; | ||
| var redirectStatuses = [301, 302, 303, 307, 308]; | ||
| Response.redirect = function(url, status) { | ||
| if (redirectStatuses.indexOf(status) === -1) { | ||
| throw new RangeError('Invalid status code') | ||
| } | ||
| return new Response(null, {status: status, headers: {location: url}}) | ||
| }; | ||
| self.Headers = Headers; | ||
| self.Request = Request; | ||
| self.Response = Response; | ||
| self.fetch = function(input, init) { | ||
| return new Promise(function(resolve, reject) { | ||
| var request = new Request(input, init); | ||
| var xhr = new XMLHttpRequest(); | ||
| xhr.onload = function() { | ||
| var options = { | ||
| status: xhr.status, | ||
| statusText: xhr.statusText, | ||
| headers: parseHeaders(xhr.getAllResponseHeaders() || '') | ||
| }; | ||
| options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL'); | ||
| var body = 'response' in xhr ? xhr.response : xhr.responseText; | ||
| resolve(new Response(body, options)); | ||
| }; | ||
| xhr.onerror = function() { | ||
| reject(new TypeError('Network request failed')); | ||
| }; | ||
| xhr.ontimeout = function() { | ||
| reject(new TypeError('Network request failed')); | ||
| }; | ||
| xhr.open(request.method, request.url, true); | ||
| if (request.credentials === 'include') { | ||
| xhr.withCredentials = true; | ||
| } else if (request.credentials === 'omit') { | ||
| xhr.withCredentials = false; | ||
| } | ||
| if ('responseType' in xhr && support.blob) { | ||
| xhr.responseType = 'blob'; | ||
| } | ||
| request.headers.forEach(function(value, name) { | ||
| xhr.setRequestHeader(name, value); | ||
| }); | ||
| xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit); | ||
| }) | ||
| }; | ||
| self.fetch.polyfill = true; | ||
| })(typeof self !== 'undefined' ? self : undefined); | ||
| function js3dlook(key) { | ||
@@ -475,0 +8,0 @@ function upload(file) { |
@@ -5,3 +5,3 @@ { | ||
| "author": "Ross Waycaster <rosswaycaster@me.com> (http://rosswaycaster.com/)", | ||
| "version": "1.0.5", | ||
| "version": "1.0.6", | ||
| "main": "dist/js3dlook.cjs.js", | ||
@@ -34,11 +34,5 @@ "module": "dist/js3dlook.esm.js", | ||
| }, | ||
| "keywords": [ | ||
| "3DLOOK", | ||
| "3D", | ||
| "LOOK" | ||
| ], | ||
| "keywords": ["3DLOOK", "3D", "LOOK"], | ||
| "license": "ISC", | ||
| "files": [ | ||
| "dist" | ||
| ] | ||
| "files": ["dist"] | ||
| } |
Fixed alerts
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
Improved metrics
- Number of medium supply chain risk alerts
- decreased by-10%
9
Worsened metrics
- Total package byte prevSize
- decreased by-55.79%
10422
- Lines of code
- decreased by-62.97%
234
No dependency changes