wonder-image 1.2.0

package/dist/lib/swiperjs/swiper-plugin.js.LICENSE.txt

@@ -0,0 +1,1113 @@
+/*
+ * A fast javascript implementation of simplex noise by Jonas Wagner
+
+Based on a speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
+Which is based on example code by Stefan Gustavson (stegu@itn.liu.se).
+With Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
+Better rank ordering method by Stefan Gustavson in 2012.
+
+ Copyright (c) 2022 Jonas Wagner
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.
+ */
+
+/* glsl */
+
+/* webpack/runtime/make namespace object */
+
+/*#__PURE__*/
+
+/**
+ * Adds two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+
+/**
+ * Builds a random permutation table.
+ * This is exported only for (internal) testing purposes.
+ * Do not rely on this export.
+ * @private
+ */
+
+/**
+ * Calculates a 3x3 matrix from the given quaternion
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {quat} q Quaternion to create matrix from
+ *
+ * @returns {mat3} out
+ */
+
+/**
+ * Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix
+ *
+ * @param {mat3} out mat3 receiving operation result
+ * @param {mat4} a Mat4 to derive the normal matrix from
+ *
+ * @returns {mat3} out
+ */
+
+/**
+ * Calculates a 4x4 matrix from the given quaternion
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat} q Quaternion to create matrix from
+ *
+ * @returns {mat4} out
+ */
+
+/**
+ * Calculates the conjugate of a quat
+ * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a quat to calculate conjugate of
+ * @returns {quat} out
+ */
+
+/**
+ * Calculates the determinant of a mat4
+ *
+ * @param {mat4} a the source matrix
+ * @returns {Number} determinant of a
+ */
+
+/**
+ * Calculates the dot product of two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+
+/**
+ * Calculates the dot product of two vec4's
+ *
+ * @param {vec4} a the first operand
+ * @param {vec4} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+
+/**
+ * Calculates the euclidian distance between two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} distance between a and b
+ */
+
+/**
+ * Calculates the inverse of a quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a quat to calculate inverse of
+ * @returns {quat} out
+ */
+
+/**
+ * Calculates the length of a vec3
+ *
+ * @param {vec3} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+
+/**
+ * Calculates the squared euclidian distance between two vec3's
+ *
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {Number} squared distance between a and b
+ */
+
+/**
+ * Calculates the squared length of a vec3
+ *
+ * @param {vec3} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ */
+
+/**
+ * Computes the cross product of two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+
+/**
+ * Copies the upper-left 3x3 values into the given mat3.
+ *
+ * @param {mat3} out the receiving 3x3 matrix
+ * @param {mat4} a   the source 4x4 matrix
+ * @returns {mat3} out
+ */
+
+/**
+ * Copy the values from one mat3 to another
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the source matrix
+ * @returns {mat3} out
+ */
+
+/**
+ * Copy the values from one mat4 to another
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the source matrix
+ * @returns {mat4} out
+ */
+
+/**
+ * Copy the values from one quat to another
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a the source quaternion
+ * @returns {quat} out
+ * @function
+ */
+
+/**
+ * Copy the values from one vec3 to another
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the source vector
+ * @returns {vec3} out
+ */
+
+/**
+ * Copy the values from one vec4 to another
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the source vector
+ * @returns {vec4} out
+ */
+
+/**
+ * Creates a 2D noise function
+ * @param random the random function that will be used to build the permutation table
+ * @returns {NoiseFunction2D}
+ */
+
+/**
+ * Creates a matrix from a quaternion rotation, vector translation and vector scale
+ * This is equivalent to (but much faster than):
+ *
+ *     mat4.identity(dest);
+ *     mat4.translate(dest, vec);
+ *     let quatMat = mat4.create();
+ *     quat4.toMat4(quat, quatMat);
+ *     mat4.multiply(dest, quatMat);
+ *     mat4.scale(dest, scale)
+ *
+ * @param {mat4} out mat4 receiving operation result
+ * @param {quat4} q Rotation quaternion
+ * @param {vec3} v Translation vector
+ * @param {vec3} s Scaling vector
+ * @returns {mat4} out
+ */
+
+/**
+ * Creates a quaternion from the given 3x3 rotation matrix.
+ *
+ * NOTE: The resultant quaternion is not normalized, so you should be sure
+ * to renormalize the quaternion yourself where necessary.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {mat3} m rotation matrix
+ * @returns {quat} out
+ * @function
+ */
+
+/**
+ * Creates a quaternion from the given euler angle x, y, z.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {vec3} euler Angles to rotate around each axis in degrees.
+ * @param {String} order detailing order of operations. Default 'XYZ'.
+ * @returns {quat} out
+ * @function
+ */
+
+/**
+ * Divides two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+
+/**
+ * Generates a matrix that makes something look at something else.
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {vec3} eye Position of the viewer
+ * @param {vec3} target Point the viewer is looking at
+ * @param {vec3} up vec3 pointing up
+ * @returns {mat4} out
+ */
+
+/**
+ * Generates a orthogonal projection matrix with the given bounds
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {number} left Left bound of the frustum
+ * @param {number} right Right bound of the frustum
+ * @param {number} bottom Bottom bound of the frustum
+ * @param {number} top Top bound of the frustum
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+
+/**
+ * Generates a perspective projection matrix with the given bounds
+ *
+ * @param {mat4} out mat4 frustum matrix will be written into
+ * @param {number} fovy Vertical field of view in radians
+ * @param {number} aspect Aspect ratio. typically viewport width/height
+ * @param {number} near Near bound of the frustum
+ * @param {number} far Far bound of the frustum
+ * @returns {mat4} out
+ */
+
+/**
+ * Get the angle between two 3D vectors
+ * @param {vec3} a The first operand
+ * @param {vec3} b The second operand
+ * @returns {Number} The angle in radians
+ */
+
+/**
+ * Inverts a mat3
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the source matrix
+ * @returns {mat3} out
+ */
+
+/**
+ * Inverts a mat4
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the source matrix
+ * @returns {mat4} out
+ */
+
+/**
+ * Multiplies two mat3's
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the first operand
+ * @param {mat3} b the second operand
+ * @returns {mat3} out
+ */
+
+/**
+ * Multiplies two mat4s
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the first operand
+ * @param {mat4} b the second operand
+ * @returns {mat4} out
+ */
+
+/**
+ * Multiplies two quats
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a the first operand
+ * @param {quat} b the second operand
+ * @returns {quat} out
+ */
+
+/**
+ * Multiplies two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+
+/**
+ * Negates the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to negate
+ * @returns {vec3} out
+ */
+
+/**
+ * Normalize a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to normalize
+ * @returns {vec3} out
+ */
+
+/**
+ * Normalize a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a vector to normalize
+ * @returns {vec4} out
+ */
+
+/**
+ * Performs a linear interpolation between two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @param {Number} t interpolation amount between the two inputs
+ * @returns {vec3} out
+ */
+
+/**
+ * Performs a spherical linear interpolation between two quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {quat} a the first operand
+ * @param {quat} b the second operand
+ * @param {Number} t interpolation amount between the two inputs
+ * @returns {quat} out
+ */
+
+/**
+ * Returns a quaternion representing the rotational component
+ *  of a transformation matrix. If a matrix is built with
+ *  fromRotationTranslation, the returned quaternion will be the
+ *  same as the quaternion originally supplied.
+ * @param {quat} out Quaternion to receive the rotation component
+ * @param {mat4} mat Matrix to be decomposed (input)
+ * @return {quat} out
+ */
+
+/**
+ * Returns the inverse of the components of a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a vector to invert
+ * @returns {vec3} out
+ */
+
+/**
+ * Returns the scaling factor component of a transformation
+ *  matrix. If a matrix is built with fromRotationTranslationScale
+ *  with a normalized Quaternion paramter, the returned vector will be
+ *  the same as the scaling vector
+ *  originally supplied.
+ * @param  {vec3} out Vector to receive scaling factor component
+ * @param  {mat4} mat Matrix to be decomposed (input)
+ * @return {vec3} out
+ */
+
+/**
+ * Returns the translation vector component of a transformation
+ *  matrix. If a matrix is built with fromRotationTranslation,
+ *  the returned vector will be the same as the translation vector
+ *  originally supplied.
+ * @param  {vec3} out Vector to receive translation component
+ * @param  {mat4} mat Matrix to be decomposed (input)
+ * @return {vec3} out
+ */
+
+/**
+ * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)
+ *
+ * @param {vec3} a The first vector.
+ * @param {vec3} b The second vector.
+ * @returns {Boolean} True if the vectors are equal, false otherwise.
+ */
+
+/**
+ * Rotates a mat3 by the given angle
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @returns {mat3} out
+ */
+
+/**
+ * Rotates a mat4 by the given angle around the given axis
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to rotate
+ * @param {Number} rad the angle to rotate the matrix by
+ * @param {vec3} axis the axis to rotate around
+ * @returns {mat4} out
+ */
+
+/**
+ * Rotates a quaternion by the given angle about the X axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {quat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+
+/**
+ * Rotates a quaternion by the given angle about the Y axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {quat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+
+/**
+ * Rotates a quaternion by the given angle about the Z axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {quat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+
+/**
+ * Same as above but doesn't apply translation.
+ * Useful for rays.
+ */
+
+/**
+ * Scales a vec3 by a scalar number
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec3} out
+ */
+
+/**
+ * Scales a vec4 by a scalar number
+ *
+ * @param {vec4} out the receiving vector
+ * @param {vec4} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec4} out
+ */
+
+/**
+ * Scales the mat3 by the dimensions in the given vec2
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the matrix to rotate
+ * @param {vec2} v the vec2 to scale the matrix by
+ * @returns {mat3} out
+ **/
+
+/**
+ * Scales the mat4 by the dimensions in the given vec3 not using vectorization
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to scale
+ * @param {vec3} v the vec3 to scale the matrix by
+ * @returns {mat4} out
+ **/
+
+/**
+ * Set a mat3 to the identity matrix
+ *
+ * @param {mat3} out the receiving matrix
+ * @returns {mat3} out
+ */
+
+/**
+ * Set a mat4 to the identity matrix
+ *
+ * @param {mat4} out the receiving matrix
+ * @returns {mat4} out
+ */
+
+/**
+ * Set a quat to the identity quaternion
+ *
+ * @param {quat} out the receiving quaternion
+ * @returns {quat} out
+ */
+
+/**
+ * Set the components of a mat3 to the given values
+ *
+ * @param {mat3} out the receiving matrix
+ * @returns {mat3} out
+ */
+
+/**
+ * Set the components of a mat4 to the given values
+ *
+ * @param {mat4} out the receiving matrix
+ * @returns {mat4} out
+ */
+
+/**
+ * Set the components of a quat to the given values
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {quat} out
+ * @function
+ */
+
+/**
+ * Set the components of a vec3 to the given values
+ *
+ * @param {vec3} out the receiving vector
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @returns {vec3} out
+ */
+
+/**
+ * Set the components of a vec4 to the given values
+ *
+ * @param {vec4} out the receiving vector
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @param {Number} w W component
+ * @returns {vec4} out
+ */
+
+/**
+ * Sets a quat from the given angle and rotation axis,
+ * then returns it.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {vec3} axis the axis around which to rotate
+ * @param {Number} rad the angle in radians
+ * @returns {quat} out
+ **/
+
+/**
+ * Subtracts vector b from vector a
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the first operand
+ * @param {vec3} b the second operand
+ * @returns {vec3} out
+ */
+
+/**
+ * Transforms the vec3 with a mat3.
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {mat3} m the 3x3 matrix to transform with
+ * @returns {vec3} out
+ */
+
+/**
+ * Transforms the vec3 with a mat4.
+ * 4th vector component is implicitly '1'
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {mat4} m matrix to transform with
+ * @returns {vec3} out
+ */
+
+/**
+ * Transforms the vec3 with a quat
+ *
+ * @param {vec3} out the receiving vector
+ * @param {vec3} a the vector to transform
+ * @param {quat} q quaternion to transform with
+ * @returns {vec3} out
+ */
+
+/**
+ * Translate a mat3 by the given vector
+ *
+ * @param {mat3} out the receiving matrix
+ * @param {mat3} a the matrix to translate
+ * @param {vec2} v vector to translate by
+ * @returns {mat3} out
+ */
+
+/**
+ * Translate a mat4 by the given vector
+ *
+ * @param {mat4} out the receiving matrix
+ * @param {mat4} a the matrix to translate
+ * @param {vec3} v vector to translate by
+ * @returns {mat4} out
+ */
+
+/**
+ * UI Initiative Carousel Slider
+ *
+ * Infinite 3D carousel slider
+ *
+ * https://uiinitiative.com
+ *
+ * Copyright 2023 UI Initiative
+ *
+ * Released under the UI Initiative Regular License
+ *
+ * December 27, 2023
+ */
+
+/**
+ * UI Initiative Shutters Slider
+ *
+ * Infinite 3D carousel slider
+ *
+ * https://uiinitiative.com
+ *
+ * Copyright 2023 UI Initiative
+ *
+ * Released under the UI Initiative Regular License
+ *
+ * October 25, 2023
+ */
+
+/**
+ * UI Initiative Slicer Slider
+ *
+ * Images slicer slider
+ *
+ * https://uiinitiative.com
+ *
+ * Copyright 2023 UI Initiative
+ *
+ * Released under the UI Initiative Regular License
+ *
+ * October 25, 2023
+ *
+ */
+
+/**
+ * UI Initiative Swiper GL
+ *
+ * Stunning WebGL image transitions
+ *
+ * https://uiinitiative.com
+ *
+ * Copyright 2024 UI Initiative
+ *
+ * Released under the UI Initiative Regular License
+ *
+ * April 25, 2024
+ */
+
+/************************************************************************/
+
+/******/
+
+// 
+
+//    http://jsperf.com/quaternion-slerp-implementations
+
+//  ... so we can do a linear interpolation
+
+// "from" and "to" quaternions are very close
+
+// +x
+
+// +y
+
+// +z (far)
+
+// -x
+
+// -y
+
+// -z (near)
+
+// 1/(4w)
+
+// 2w
+
+// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
+
+// Add contributions from each corner to get the final noise value.
+
+// Add empty matrix uniforms to program if unset
+
+// Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+
+// Alias for state store to avoid redundant calls for global state
+
+// Already bound to active texture unit
+
+// Attach renderer to gl so that all classes have access to internal state functions
+
+// Attempt WebGL2 unless forced to 1, if not supported fallback to WebGL1
+
+// Avoid gl call if program already in use
+
+// Avoid redundant uniform commands
+
+// BOOL
+
+// BOOL_VEC2
+
+// BOOL_VEC3
+
+// BOOL_VEC4
+
+// Bind indices if geometry indexed
+
+// CONCATENATED MODULE: ./src/build/lib/swiperjs/effect-carousel.esm.js
+
+// CONCATENATED MODULE: ./src/build/lib/swiperjs/effect-shutters.esm.js
+
+// CONCATENATED MODULE: ./src/build/lib/swiperjs/effect-slicer.esm.js
+
+// CONCATENATED MODULE: ./src/build/lib/swiperjs/swiper-gl.esm.js
+
+// CONCATENATED MODULE: ./src/export/lib/swiperjs/swiper-plugin.js
+
+// Calculate the contribution from the three corners
+
+// Calculate the determinant
+
+// Callback for when data is pushed to GPU
+
+// Can't use 'length' as Array.prototype uses it
+
+// Check if any attributes need updating
+
+// Check if texture needs to be updated
+
+// Compressed texture
+
+// Construct the elements of the rotation matrix
+
+// Create method aliases using extension (WebGL1) or native if available (WebGL2)
+
+// Data texture
+
+// Determine which simplex we are in.
+
+// ESM COMPAT FLAG
+
+// Ensure depth buffer writing is enabled so it can be cleared
+
+// FLOAT
+
+// FLOAT_MAT2
+
+// FLOAT_MAT3
+
+// FLOAT_MAT4
+
+// FLOAT_VEC2
+
+// FLOAT_VEC3
+
+// FLOAT_VEC4
+
+// For WebGL1, if not a power of 2, turn off mips, set wrapping to clamp to edge and minFilter to linear
+
+// For cube maps
+
+// For firefox, need to set back to 0 if non-instanced drawn after instanced. Else won't render
+
+// For instanced attributes, divisor needs to be set.
+
+// For matrix attributes, buffer needs to be defined per column
+
+// For structs, get the specific property instead of the entire object
+
+// For texture arrays, set uniform as an array of texture units instead of just one
+
+// For the 2D case, the simplex shape is an equilateral triangle.
+
+// Get active attribute locations
+
+// Get active uniform locations
+
+// Get visible
+
+// Hairy factor for 2D
+
+// INT
+
+// INT_VEC2
+
+// INT_VEC3
+
+// INT_VEC4
+
+// If geometry missing a required shader attribute
+
+// If no position attribute, treat as frustumCulled false
+
+// If the source and destination differ, copy the unchanged last row
+
+// Ignore special built-in inputs. eg gl_VertexID, gl_InstanceID
+
+// Initialise extra format types
+
+// Link all attributes to program using gl.vertexAttribPointer
+
+// Make sure that texture is bound to its texture unit
+
+// Noise contributions from the three corners
+
+// Not automatic - devs to use these methods manually
+
+// Offsets for middle corner in (x,y) unskewed coords
+
+// Offsets for second (middle) corner of simplex in (i,j) coords
+
+// Only calculate z-depth if renderOrder unset and depthTest is true
+
+// Override sorting to force an order
+
+// Perform rotation-specific matrix multiplication
+
+// Project 3D coordinate to 2D point
+
+// Push data to buffer
+
+// Quaternion math
+
+// Regular texture
+
+// Remove shader once linked
+
+// Return null if extension not supported
+
+// Return true in callback to stop traversing children
+
+// SAMPLER_2D
+
+// SAMPLER_CUBE
+
+// Set only the active uniforms found in the shader
+
+// Set options
+
+// Set the matrix uniforms
+
+// Skew the input space to determine which simplex cell we're in
+
+// Split into the 3 render groups
+
+// State store to avoid redundant calls for per-texture state
+
+// Store device parameters
+
+// Store one VAO per program attribute locations order
+
+// Store program state
+
+// Swiper JS Plugin
+
+// TODO: Handle context loss https://www.khronos.org/webgl/wiki/HandlingContextLost
+
+// TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
+
+// TODO: check size of position (eg triangle with Vec2)
+
+// TODO: currently unused, remove?
+
+// TODO: delete texture
+
+// TODO: need? encoding = linearEncoding
+
+// TODO: sampler Cube
+
+// TODO: support non-compressed mipmaps uploads
+
+// TODO: upload empty texture if null ? maybe not
+
+// TODO: upload identity matrix if null ?
+
+// TODO: use texSubImage2D for updates (video or when loaded)
+
+// The require scope
+
+// The result is scaled to return values in the interval [-1,1].
+
+// Uint32Array
+
+// Unbind current VAO so that new buffers don't get added to active mesh
+
+// Unproject 2D point to 3D coordinate
+
+// Update cached array values
+
+// Update camera separately, in case not in scene graph
+
+// Update geometry counts. If indexed, ignore regular attributes
+
+// Upload empty pixel for each side while no image to avoid errors while image or video loading
+
+// Upload empty pixel if no image to avoid errors while image or video loading
+
+// Use orthographic if left/right set, else default to perspective camera
+
+// Use position buffer, or min/max if available
+
+// Used to skip frustum culling
+
+// [ https://uiinitiative.com/catalog/carousel-slider ]
+
+// [ https://uiinitiative.com/catalog/shaders-slider ]
+
+// [ https://uiinitiative.com/catalog/shutters-slider ]
+
+// [ https://uiinitiative.com/catalog/slicer-slider ]
+
+// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
+
+// adjust signs (if necessary)
+
+// article "Quaternion Calculus and Fast Animation".
+
+// assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+
+// attribute params
+
+// benchmarks:
+
+// benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed
+
+// bind supplied render target and update viewport
+
+// c = (3-sqrt(3))/6
+
+// cache of typed arrays used to flatten uniform arrays
+
+// calc cosine
+
+// calculate coefficients
+
+// calculate final values
+
+// clone array to store as cache
+
+// compile fragment shader and log errors
+
+// compile program and log errors
+
+// compile vertex shader and log errors
+
+// create the buffers
+
+// define __esModule on exports
+
+// depthTest false
+
+// determine if faces need to be flipped - when mesh scaled negatively
+
+// eslint-disable-next-line
+
+// eye and target are in the same position
+
+// fetch extension once only
+
+// first triangle
+
+// get supplied uniform
+
+// gl state stores to avoid redundant calls on methods used internally
+
+// gl.clearColor( r, g, b, a );
+
+// gl.clearStencil( stencil );
+
+// gl.colorMask( colorMask, colorMask, colorMask, colorMask );
+
+// gl.stencilFunc( stencilFunc, stencilRef, stencilMask );
+
+// gl.stencilMask( stencilMask );
+
+// gl.stencilOp( stencilFail, stencilZFail, stencilZPass );
+
+// if (attr.min) return [...attr.min, ...attr.max];
+
+// if webgl2 function supported, return func bound to gl context
+
+// if(!isFinite(x) || !isFinite(y)) return 0;
+
+// image intentionally left null for RenderTarget
+
+// initialise size values
+
+// make sure no render target bound so draws to canvas
+
+// mat2
+
+// mat3
+
+// mat4
+
+// n0 = t0 * t0 * (grad2[gi0] * x0 + grad2[gi0 + 1] * y0); // (x,y) of grad3 used for 2D gradient
+
+// n1 = t1 * t1 * (grad2[gi1] * x1 + grad2[gi1 + 1] * y1);
+
+// n2 = t2 * t2 * (grad2[gi2] * x2 + grad2[gi2 + 1] * y2);
+
+// precalculating this yields a little ~3% performance improvement.
+
+// return extension if no function requested
+
+// second triangle
+
+// set active texture unit to perform texture functions
+
+// set default blendFunc if transparent flagged
+
+// side: DoubleSide,
+
+// sign =1
+
+// split uniforms' names to separate array and struct declarations
+
+// standard case (slerp)
+
+// store requested extensions
+
+// up and z are parallel
+
+// update z-depth
+
+// updates all scene graph matrices
+
+// upper triangle, YX order: (0,0)->(0,1)->(1,1)
+
+// used for RenderTargets or Data Textures
+
+// used for sorting
+
+// webpackBootstrap
+
+// |w| <= 1/2
+
+// |w| > 1/2, may as well choose w > 1/2
+
+//TODO: evaluate use of glm_invsqrt here?