{"version":3,"file":"powerups.cjs","sources":["../powerups/WebGLText.tsx","../powerups/WebGLImage.tsx","../powerups/ParallaxScrollScene.tsx","../../node_modules/vecn/src/index.js","../powerups/StickyScrollScene.tsx","../../node_modules/@14islands/lerp/index.js","../../node_modules/lerp/index.js"],"sourcesContent":["import React, { useMemo, useEffect, ReactNode, MutableRefObject } from 'react'\nimport { Color, Material } from 'three'\nimport { useThree } from '@react-three/fiber'\nimport { Text } from '@react-three/drei'\n\nimport { useScrollRig } from '@14islands/r3f-scroll-rig'\n\n/**\n * Returns a WebGL Troika text mesh styled as the source DOM element\n */\n\ninterface WebGLTextProps {\n el: MutableRefObject\n children?: ReactNode\n material?: Material\n scale?: any\n font?: string\n fontOffsetY?: number\n fontOffsetX?: number\n overrideEmissive?: boolean\n color?: string\n}\n\nexport const WebGLText = ({\n el,\n children,\n material,\n scale,\n font,\n fontOffsetY = 0,\n fontOffsetX = 0,\n overrideEmissive = false,\n color,\n ...props\n}: WebGLTextProps) => {\n const { size } = useThree()\n const { scaleMultiplier } = useScrollRig()\n\n const { textColor, fontSize, textAlign, lineHeight, letterSpacing } = useMemo(() => {\n if (!el.current) return {}\n const cs = window.getComputedStyle(el.current)\n\n // get color from parent if set to transparent\n let textColor = color || cs.color\n if (!color && cs.color === 'rgba(0, 0, 0, 0)' && el.current.parentElement) {\n textColor = window.getComputedStyle(el.current.parentElement).color\n }\n\n // font size relative letter spacing\n const letterSpacing = (parseFloat(cs.letterSpacing) || 0) / parseFloat(cs.fontSize)\n const lineHeight = (parseFloat(cs.lineHeight) || 0) / parseFloat(cs.fontSize)\n\n return {\n letterSpacing,\n lineHeight,\n textColor,\n fontSize: parseFloat(cs.fontSize) * scaleMultiplier,\n textAlign: cs.textAlign,\n }\n // eslint-disable-next-line react-hooks/exhaustive-deps\n }, [el, size, scale, color, scaleMultiplier]) // recalc on resize\n\n useEffect(() => {\n if (material && overrideEmissive) {\n // @ts-ignore\n material.emissive = color\n }\n }, [material, color, overrideEmissive])\n\n let xOffset = 0\n if (textAlign === 'left' || textAlign === 'start') {\n xOffset = scale[0] * -0.5\n } else if (textAlign === 'right' || textAlign === 'end') {\n xOffset = scale[0] * 0.5\n }\n\n const yOffset = scale ? scale[1] * 0.5 : size.height * 0.5\n\n return (\n \n {children}\n \n )\n}\n","import React, {\n useRef,\n useMemo,\n useEffect,\n forwardRef,\n MutableRefObject,\n ForwardedRef,\n useImperativeHandle,\n} from 'react'\nimport { Color, Vector2, ShaderMaterial, Mesh, ShaderMaterialParameters } from 'three'\nimport { useFrame, useThree } from '@react-three/fiber'\n\nimport { useScrollRig, useImageAsTexture, useScrollbar } from '@14islands/r3f-scroll-rig'\n\ninterface WebGLImageProps {\n el: MutableRefObject\n scale?: any\n scrollState?: any\n vertexShader?: string\n fragmentShader?: string\n invalidateFrameLoop: boolean\n widthSegments?: number\n heightSegments?: number\n}\n\nexport const WebGLImage = forwardRef(\n (\n {\n el,\n scale,\n scrollState,\n vertexShader,\n fragmentShader,\n invalidateFrameLoop = false,\n widthSegments = 128,\n heightSegments = 128,\n ...props\n }: WebGLImageProps,\n ref: ForwardedRef\n ) => {\n const material = useRef(null!)\n const mesh = useRef(null!)\n useImperativeHandle(ref, () => mesh.current)\n\n const { invalidate, gl, size } = useThree()\n const pixelRatio = useThree((s) => s.viewport.dpr)\n const { scroll } = useScrollbar()\n const { scaleMultiplier } = useScrollRig()\n\n const texture = useImageAsTexture(el)\n\n const uniforms = useMemo(() => {\n return {\n u_color: { value: new Color('black') },\n u_time: { value: 0 },\n u_pixelRatio: { value: pixelRatio },\n u_progress: { value: 0 },\n u_visibility: { value: 0 },\n u_viewport: { value: 0 },\n u_velocity: { value: 0 }, // scroll speed\n u_res: { value: new Vector2() }, // screen dimensions\n u_rect: { value: new Vector2() }, // DOM el dimensions\n u_size: { value: new Vector2() }, // Texture dimensions\n u_texture: { value: null },\n u_loaded: { value: false },\n u_scaleMultiplier: { value: scaleMultiplier },\n }\n }, [pixelRatio])\n\n // Fade in when texture loaded\n useEffect(() => {\n if (!texture) return\n if (!material.current) return\n material.current.uniforms.u_texture.value = texture\n material.current.uniforms.u_size.value.set(texture.image.width, texture.image.height)\n material.current.uniforms.u_loaded.value = true\n }, [texture, gl])\n\n useEffect(() => {\n if (!material.current) return\n material.current.uniforms.u_res.value.set(size.width, size.height)\n material.current.uniforms.u_rect.value.set(scale?.[0], scale?.[1])\n }, [size, scale])\n\n useFrame((_, delta) => {\n if (!scrollState.inViewport || !mesh.current || !material.current) return\n\n if (!material.current.uniforms.u_loaded.value) return\n\n material.current.uniforms.u_time.value += delta\n\n // update scale while animating too\n material.current.uniforms.u_rect.value.set(mesh.current.scale.x, mesh.current.scale.y)\n\n // px velocity\n material.current.uniforms.u_velocity.value = scroll.velocity\n\n // percent of total visible distance that was scrolled (0 = just outside bottom of screen, 1 = just outside top of screen)\n material.current.uniforms.u_progress.value = scrollState.progress\n\n // percent of item height in view\n material.current.uniforms.u_visibility.value = scrollState.visibility\n // percent of window height scrolled since visible\n material.current.uniforms.u_viewport.value = scrollState.viewport\n\n if (invalidateFrameLoop) invalidate()\n })\n\n const args = useMemo(\n () => [\n {\n vertexShader,\n fragmentShader,\n },\n ],\n [vertexShader, fragmentShader]\n )\n\n return (\n <>\n \n \n \n \n \n )\n }\n)\n","import React, { useRef } from 'react'\nimport { useFrame, useThree } from '@react-three/fiber'\nimport { Mesh } from 'three'\n\nimport { ScrollScene, useScrollRig } from '@14islands/r3f-scroll-rig'\n\n// Parallax group inside ScrollScene\nconst ParallaxGroup = ({ children, scrollState, parallax }: any) => {\n const mesh = useRef(null!)\n const size = useThree((s) => s.size)\n const { scaleMultiplier } = useScrollRig()\n\n useFrame(() => {\n if (!scrollState.inViewport) return\n const parallaxProgress = scrollState.progress * 2 - 1\n mesh.current.position.y = parallax * parallaxProgress * scaleMultiplier * size.height\n })\n\n return {children}\n}\n\n/* Speed=1 is no parallax */\nexport const ParallaxScrollScene = ({ children, speed = 1, ...props }: any) => {\n const extraMargin = 50 // add 50vh extra margin to avoid aggressive clipping\n const parallaxAmount = speed - 1\n return (\n // @ts-ignore\n \n {(props) => (\n \n {children(props)}\n \n )}\n \n )\n}\n","/**\n * An object for memoizing vecType functions.\n * @type {Object}\n * @private\n */\nlet vecTypes = (function () {\n const handler = {\n get: function (obj, prop) {\n if (!obj.hasOwnProperty(prop)) {\n obj[prop] = getVecType(prop)\n }\n return obj[prop]\n }\n }\n\n return new Proxy({}, handler)\n})()\n\n/**\n * A class for fixed-size vectors of numbers.\n * @extends Array\n */\nclass vecn extends Array {\n /**\n * Creates a vecn of the specified dimension. This should never be called\n * by the user (as if this were an abstract class).\n * @param {number} dimension The dimension of this vector.\n * @param {number[]} [args=[]] The numbers to be put in the vector.\n */\n constructor (dimension, args) {\n args = flattenOuter(args)\n\n if (!args.every((x) => type(x) === 'Number')) {\n throw new TypeError('All arguments must be numbers.')\n }\n if (args.length > 1 && args.length !== dimension) {\n throw new Error('Argument list must be empty, have a single number, or have a length equal to the dimension.')\n }\n\n if (args.length === 0) {\n args = [0]\n }\n if (args.length === 1 && type(args[0]) === 'Number') {\n args = Array(dimension).fill(args[0])\n }\n\n if (dimension > 1) {\n super(...args)\n } else {\n super(1)\n this[0] = args[0]\n }\n\n Reflect.defineProperty(this, 'pop', {\n value: undefined,\n enumerable: false\n })\n Reflect.defineProperty(this, 'push', {\n value: undefined,\n enumerable: false\n })\n Reflect.defineProperty(this, 'shift', {\n value: undefined,\n enumerable: false\n })\n Reflect.defineProperty(this, 'unshift', {\n value: undefined,\n enumerable: false\n })\n }\n\n /**\n * The L2 norm (Euclidian norm) of the vector.\n * @type {number}\n */\n get magnitude () {\n return this.pnorm(2)\n }\n\n // --------------------------------------------------------------------------\n // Arithmetic\n\n /**\n * Returns a vector where this is divided by v componentwise. If v is\n * a single number, the vector is scaled by 1/v.\n * @param {number|number[]} v The value to multiply with.\n *\n * @returns {vecn} A new vector with the divided components.\n */\n div (v) {\n checkCompatibility(v, this.dim, true)\n if (type(v) === 'Number') {\n v = (new Array(this.dim)).fill(v)\n }\n\n let result = []\n for (let i = 0; i < this.length; ++i) {\n result[i] = this[i] / v[i]\n }\n return vecTypes[this.dim](result)\n }\n\n /**\n * Returns a vector where v is subtracted from the components of this\n * vector. If v is a single number, it is subtracted to each component. If v\n * is a vector, the vectors are combined componentwise.\n * @param {number|number[]} v The value to subtract from this vector.\n *\n * @returns {vecn} A new vector with the combined components.\n */\n minus (v) {\n checkCompatibility(v, this.dim, true)\n if (type(v) === 'Number') {\n v = (new Array(this.dim)).fill(v)\n }\n\n let result = []\n for (let i = 0; i < this.dim; ++i) {\n result[i] = this[i] - v[i]\n }\n return vecTypes[this.dim](result)\n }\n\n /**\n * Negates each element in this vector.\n * @returns {vecn} A new vector where all elements are negated.\n */\n neg () {\n return vecTypes[this.dim](this.times(-1))\n }\n\n /**\n * Returns a vector where v is added to the components of this vector. If v\n * is a single number, it is added to each component. If v is a vector, the\n * vectors are added componentwise.\n * @param {number|number[]} v The value to add to this vector.\n *\n * @returns {vecn} A new vector with the summed components.\n */\n plus (v) {\n checkCompatibility(v, this.dim, true)\n if (type(v) === 'Number') {\n v = (new Array(this.dim)).fill(v)\n }\n\n let result = []\n for (let i = 0; i < this.dim; ++i) {\n result[i] = this[i] + v[i]\n }\n return vecTypes[this.dim](result)\n }\n\n /**\n * Returns a vector where each component of this was raised to a power p.\n * @param {number} p The power to raise each component by.\n *\n * @returns {vecn} A new vector with the exponentiated components.\n */\n pow (p) {\n let result = []\n for (let i = 0; i < this.dim; ++i) {\n result[i] = Math.pow(this[i], p)\n }\n return vecTypes[this.dim](result)\n }\n\n /**\n * Returns a vector where v and this are multiplied componentwise. If v is\n * a single number, the vector is scaled by v.\n * @param {number|number[]} v The value to multiply with.\n *\n * @returns {vecn} A new vector with the multiplied components.\n */\n times (v) {\n checkCompatibility(v, this.dim, true)\n if (type(v) === 'Number') {\n v = (new Array(this.dim)).fill(v)\n }\n\n let result = []\n for (let i = 0; i < this.dim; ++i) {\n result[i] = this[i] * v[i]\n }\n return vecTypes[this.dim](result)\n }\n\n // --------------------------------------------------------------------------\n // Vector Operations\n\n /**\n * Dot product of two vectors.\n * @param {number[]} v The vector to dot with this one.\n *\n * @returns {number} The dot product between this and v.\n */\n dot (v) {\n checkCompatibility(v, this.dim)\n\n let result = 0\n for (let i = 0; i < this.dim; ++i) {\n result += this[i] * v[i]\n }\n return result\n }\n\n /**\n * Scales this vector to a magnitude of 1.\n *\n * @returns {vecn} A new vector with scaled components.\n */\n normalize () {\n return this.div(this.magnitude)\n }\n\n /**\n * Evaluates the p-norm (or lp-norm) of this vector.\n * @param {number} p The p-value to evaluate.\n *\n * @returns {number} The norm of this vector.\n */\n pnorm (p) {\n let result = 0\n for (let i = 0; i < this.dim; ++i) {\n result += Math.pow(Math.abs(this[i]), p)\n }\n return Math.pow(result, 1 / p)\n }\n\n /**\n * Reflects this vector across the provided vector. The normal can be imagined\n * as a surface normal or as describing a hyperpalane.\n * @param {number[]} normal A vector describing the hyperplane to reflect off of.\n *\n * @returns {vecn} The reflected vector.\n */\n reflect (normal) {\n const n = normal.normalize()\n return this.minus(n.times(2 * this.dot(n)))\n }\n\n // --------------------------------------------------------------------------\n // Extras\n\n /**\n * Finds the indices of the max value in this vector.\n *\n * @returns {number[]} An array of indices corresponding to the max values.\n */\n argmax () {\n const maxVal = this.max()\n return this.reduce((acc, x, i) => x === maxVal ? acc.concat([i]) : acc, [])\n }\n\n /**\n * Finds the indices of the min value in this vector.\n *\n * @returns {number[]} An array of indices corresponding to the min values.\n */\n argmin () {\n const minVal = this.min()\n return this.reduce((acc, x, i) => x === minVal ? acc.concat([i]) : acc, [])\n }\n\n /**\n * Creates a new vector from the provided indices of this one. Basically\n * equivalent to swizzling.\n * @param {number[]} indices The indices to select into a new vector.\n *\n * @returns {vecn} A new vector from the provided indices.\n */\n choose (indices) {\n if (!Array.isArray(indices)) {\n throw new TypeError('Argument must be a list of indices.')\n }\n if (!indices.every((i) => i < this.dim && isIndex(i.toString()))) {\n throw new RangeError('All elements of argument must be valid indices.')\n }\n\n let v = []\n indices.forEach((i) => v.push(this[i]))\n return vecTypes[v.length](v)\n }\n\n /**\n * Creates a duplicate of this vector. Same as passing this vector through\n * the factory that created it.\n *\n * @returns {vecn} A deep copy of this vector.\n */\n copy () {\n return vecTypes[this.dim](this)\n }\n\n /**\n * Returns whether every element in each vector is equal.\n * @param {number[]} v A vector to test against.\n *\n * @returns {boolean} True if both vectors have the same dimension and values.\n */\n equals (v) {\n return v.length === this.dim && v.every((x, i) => this[i] === x)\n }\n\n /**\n * Returns whether every element in each vector is approximately equal.\n * @param {number[]} v A vector to test against.\n * @param {number} epsilon The largest meaningful difference between two values.\n *\n * @returns {boolean} True if both vectors have the same dimension and the\n * distance between each number is less than epsilon.\n */\n approximatelyEquals (v, epsilon = 0.00000001) {\n return v.length === this.dim && v.every((x, i) => Math.abs(this[i] - x) < epsilon)\n }\n\n /**\n * Returns the max value of this vector.\n *\n * @returns {number} The max value of this vector.\n */\n max () {\n return Math.max(...this)\n }\n\n /**\n * Returns the min value of this vector.\n *\n * @returns {number} The min value of this vector.\n */\n min () {\n return Math.min(...this)\n }\n\n /**\n * Sums the components of this vector.\n *\n * @returns {number} The sum of the components of this vector.\n */\n sum () {\n return this.reduce((acc, x) => acc + x, 0)\n }\n\n /**\n * Converts this vector into an Array.\n *\n * @returns {number[]} An array of the contents of this vector.\n */\n toArray () {\n return Array.from(this)\n }\n\n // --------------------------------------------------------------------------\n // Array Overrides\n\n /**\n * Same as Array.prototype.concat, but return value is of a new vecType.\n *\n * @returns {vecn}\n */\n concat (...args) {\n const result = super.concat.apply(this.toArray(), args)\n return vecTypes[result.length](result)\n }\n\n /**\n * Same as Array.prototype.filter, but returns an Array if the result has 0\n * entries.\n *\n * @returns {vecn|number[]}\n */\n filter (...args) {\n const result = super.filter.apply(this.toArray(), args)\n if (result.length > 0) {\n return vecTypes[result.length](result)\n }\n return result\n }\n\n /**\n * Same as Array.prototype.map, but returns an Array if the result contains\n * non-numbers.\n *\n * @returns {vecn|Array}\n */\n map (...args) {\n const result = super.map(...args)\n if (result.every((x) => type(x) === 'Number')) {\n return result\n }\n return result.toArray()\n }\n\n /**\n * Same as Array.prototype.slice, but returns an Array if the result has 0\n * entries.\n */\n slice (...args) {\n const result = super.slice.apply(this.toArray(), args)\n if (result.length > 0) {\n return vecTypes[result.length](result)\n }\n return result\n }\n\n /**\n * A restrictive version of the Array.prototype.splice that requires all\n * removed elements to be replaced.\n */\n splice (...args) {\n let test = this.toArray()\n test.splice(...args)\n\n if (test.length !== this.dim) {\n throw new Error('All removed elements must be replaced.')\n }\n if (!test.every((x) => type(x) === 'Number')) {\n throw new TypeError('All elements must be numbers.')\n }\n\n test.forEach((x, i) => { this[i] = x })\n }\n\n toString () {\n return this.reduce((s, x, i) => {\n return s + x + (i === this.dim - 1 ? ' ' : ', ')\n }, '[ ') + ']'\n }\n}\n\n// --------------------------------------------------------------------------\n// General Tools\n\n/**\n * Adds an arbitrary number of vectors together. All vectors must be of the same\n * dimension.\n * @param {...vecn} vecs Vectors to add together.\n *\n * @returns {vecn} The sum of all the provided vectors.\n */\nfunction add (...vecs) {\n const dim = vecs[0].dim\n if (!vecs.every((v) => v.dim === dim)) {\n throw new TypeError('All vectors must have the same dimension.')\n }\n return vecs.reduce((acc, v) => acc.plus(v), vecTypes[dim]())\n}\n\n/**\n * The validator to be used in the proxy for all vec objects. Catches swizzling\n * properties, makes sure assignment only works for indices, and disallows\n * non-numerical assignments. Used in getVecType.\n * @constant\n * @type {Object}\n * @private\n */\nconst validator = {\n set: function (obj, prop, value) {\n if (prop === 'length') {\n return false\n }\n if (isIndex(prop)) {\n if (Number(prop) >= obj.dim) {\n throw new RangeError('Vector may not have more elements than dimension.')\n } else if (type(value) !== 'Number') {\n throw new TypeError('Vectors may only contain numbers.')\n } else {\n obj[prop] = value\n return true\n }\n }\n\n const swizzleSymbolMap = getSwizzleSymbolMap(prop.toString())\n if (obj.dim <= 4 && swizzleSymbolMap) {\n swizzleSet(obj, prop.toString(), swizzleSymbolMap, value)\n return true\n }\n\n return false\n },\n get: function (obj, prop) {\n const swizzleSymbolMap = getSwizzleSymbolMap(prop.toString())\n if (obj.dim <= 4 && swizzleSymbolMap) {\n return swizzleGet(obj, prop, swizzleSymbolMap)\n }\n\n return obj[prop]\n }\n}\n\n/**\n * Returns a factory function for vectors of the specified dimension.\n * @param {number} dim The dimension of the new vector type.\n *\n * @returns {Function} A factory (not a constructor) for creating new vecs.\n */\nfunction getVecType (dim) {\n dim = Number(dim)\n\n if (!(dim in vecTypes)) {\n if (isNaN(dim)) throw new TypeError('Dimension must be coercible to a number.')\n if (dim <= 0) throw new RangeError('Dimension must be positive.')\n if (!Number.isInteger(dim)) throw new RangeError('Dimension must be positive.')\n\n // Doing a little bit of exploiting ES6 to dynamically name the class\n let classname = 'vec' + dim\n let VecType = ({[classname]: class extends vecn {\n constructor (...args) {\n if (args.length === 1 && args[0] instanceof vecn) {\n if (args[0].dim > dim) {\n throw new TypeError('Cannot demote vectors.')\n }\n args = promoteArrayDimension(args[0].toArray(), dim)\n }\n super(dim, args)\n Reflect.defineProperty(this, 'dim', {\n value: dim,\n writable: false,\n enumerable: false\n })\n }\n }})[classname]\n\n let factory = function factory (...args) {\n let target = new VecType(...args)\n Object.preventExtensions(target)\n return new Proxy(target, validator)\n }\n vecTypes[dim] = factory\n }\n\n return vecTypes[dim]\n}\n\n/**\n * The correct function for determining whether an object is a vecn.\n * @param {*} v The object in question.\n *\n * @returns {boolean} True if the object is an instance of vecn.\n */\nfunction isVec (v) {\n return v instanceof vecn\n}\n\n/**\n * Linearly interpolates between two vectors.\n * @param {vecn} v1 The starting vector.\n * @param {vecn} v2 The ending vector.\n * @param {number} t The interpolant, which is clamped to the inteval [0, 1].\n *\n * @returns {vecn} The interpolated vector.\n */\nfunction lerp (v1, v2, t) {\n if (v1.dim !== v2.dim) throw new TypeError('Vectors must have the same dimension.')\n t = t < 0 ? 0 : (t > 1 ? 1 : t)\n return v1.plus(v2.minus(v1).times(t))\n}\n\n/**\n * Multiplies an arbitrary number of vectors together. All vectors must be of the same\n * dimension.\n * @param {...vecn} vecs Vectors to multiply together.\n *\n * @returns {vecn} The product of all the provided vectors.\n */\nfunction multiply (...vecs) {\n const dim = vecs[0].dim\n if (!vecs.every((v) => v.dim === dim)) throw new TypeError('All vectors must have the same dimension.')\n return vecs.reduce((acc, v) => acc.times(v), vecTypes[dim](1))\n}\n\n/**\n * Spherically interpolates between two vectors.\n * @param {vecn} v1 The starting vector.\n * @param {vecn} v2 The ending vector.\n * @param {number} t The interpolant, which is clamped to the inteval [0, 1].\n *\n * @returns {vecn} The interpolated vector.\n */\nfunction slerp (v1, v2, t) {\n if (v1.dim !== v2.dim) throw new TypeError('Vectors must have the same dimension.')\n\n t = t < 0 ? 0 : (t > 1 ? 1 : t)\n let dot = v1.normalize().dot(v2.normalize())\n dot = dot < -1 ? -1 : (dot > 1 ? 1 : dot)\n const theta = Math.acos(dot) * t\n const relative = v2.minus(v1.times(dot)).normalize()\n const magnitude = v1.magnitude + ((v2.magnitude - v1.magnitude) * t)\n return v1.times(Math.cos(theta)).plus(relative.times(Math.sin(theta)))\n .normalize().times(magnitude)\n}\n\n// --------------------------------------------------------------------------\n// Swizzling\n\n/**\n * The index corresponding to common names for indexing vectors.\n * @constant\n * @type {Object}\n * @private\n */\nconst namedIndices = [\n {x: 0, y: 1, z: 2, w: 3},\n {r: 0, g: 1, b: 2, a: 3},\n {s: 0, t: 1, p: 2, q: 3}\n]\n\n/**\n * Gets the set of symbols corresponding to indices used for swizzling.\n * @private\n * @param {string} s The string used as a property to swizzle.\n *\n * @returns {Object} A map from characters to indices.\n */\nfunction getSwizzleSymbolMap (s) {\n return namedIndices.find((map) => {\n return s.split('').every((c) => c in map)\n })\n}\n\n/**\n * Creates a new vector from the named indices given by swizzling.\n * @private\n * @param {vecn} v The vector to pull data from. The dimension is assumed to be\n * 2, 3, or 4, but this isn't enforced here.\n * @param {string} s The property being used to swizzle (e.g. 'xxy' or 'z').\n * @param {Object} set A map from characters to indices (assumed to be valid).\n *\n * @returns {undefined|number|vecn} Either undefined (if s isn't a valid swizzle\n * string), a number (if s has a length of 1), or a vecn where the values have\n * been rearranged according to the order given in s.\n */\nfunction swizzleGet (v, s, set) {\n const newDim = s.length\n\n if (newDim === 1) {\n return v[set[s]]\n }\n\n let values = s.split('').reduce((acc, x) => {\n let i = set[x]\n return acc && i < v.dim ? acc.concat([v[i]]) : undefined\n }, [])\n return values ? new vecTypes[newDim](...values) : undefined\n}\n\n/**\n * Assigns the indexed values in v to the values in newVals in the order they\n * are described in in s.\n * @private\n * @param {vecn} v The starting vector.\n * @param {string} s The property being used to swizzle (e.g. 'xyz' or 'xz').\n * @param {Object} map A map from characters to indices (assumed to be valid).\n * @param {number|number[]} newVals The right hand side of the assignment\n *\n * @returns {vecn} A copy of v with the correct elements replaced.\n */\nfunction swizzleSet (v, s, map, newVals) {\n if (s.length === 1) {\n if (type(newVals) !== 'Number') {\n throw new TypeError('Must set to a number')\n }\n v[map[s]] = newVals\n return\n }\n\n if (!Array.isArray(newVals)) throw new TypeError('Right-hand side must be an array.')\n if (s.length !== newVals.length) throw new TypeError('Right-hand side must have matching length.')\n if (!newVals.every((item) => type(item) === 'Number')) throw new TypeError('All new values must be numbers.')\n\n if (s.split('').some((c) => map[c] >= v.dim)) {\n return\n }\n\n let valid = true\n for (let i = 0, unique = {}; i < s.length; ++i) {\n if (unique.hasOwnProperty(s[i])) {\n valid = false\n break\n }\n unique[s[i]] = true\n }\n if (!valid) throw new SyntaxError('Swizzle assignment does not allow symbols to be repeated.')\n\n s.split('').map((c) => map[c]).forEach((index, i) => { v[index] = newVals[i] })\n}\n\n// --------------------------------------------------------------------------\n// Helpers\n\n/**\n * Checks whether something is valid to do vector operations with and throws\n * a TypeError if not.\n * @private\n * @param {*} o An object to check.\n * @param {number} dim The dimension to check against.\n * @param {boolean} [numberValid=false] Whether scalars are compatible for the operation.\n */\nfunction checkCompatibility (o, dim, numberValid = false) {\n if (numberValid && type(o) === 'Number') {\n return\n } else if (o.length && o.length === dim) {\n return\n }\n throw new TypeError(`Invalid argument. Input must have matching dimension${numberValid ? 'or be a scalar' : ''}.`)\n}\n\n/**\n * Removes outer arrays and returns a reference to the innermost array. For\n * example, [[1, 2]] becomes [1, 2]. [[[['a'], true]]] becomes [['a'], true].\n * @private\n * @param {Array} arr The array to flatten.\n *\n * @returns {Array} A reference to the innermost array in arr.\n */\nfunction flattenOuter (arr) {\n if (!(arr instanceof Array) || arr.length !== 1) {\n return arr\n }\n if (arr[0] instanceof Array) {\n return flattenOuter(arr[0])\n }\n return arr\n}\n\n/**\n * Checks whether a provided string can be used as a valid index into an array.\n * @private\n * @param {string} n A string representation of the number in question.\n *\n * @returns {boolean} True if n can be used to index an array.\n */\nfunction isIndex (n) {\n return !isNaN(n) &&\n Number(n).toString() === n &&\n Number.isInteger(Number(n)) &&\n Number(n) >= 0\n}\n\n/**\n * Lengthens an exsting array and fills new entries with 0 (does not mutate).\n * @private\n * @param {Array} arr The source array.\n * @param {number} dim The dimension of the new array.\n *\n * @returns {Array} A new array with length dim and arr as a prefix.\n */\nfunction promoteArrayDimension (arr, dim) {\n return [...Array(dim)].map((_, i) => i < arr.length ? arr[i] : 0)\n}\n\n/**\n * Returns a string representing the type of an object. Similar to typeof, but\n * better with wrapped primitives, null, Array, etc...\n * @private\n * @param {*} obj The object to check the type of.\n *\n * @returns {string} A capitalized string describing the perceived type (i.e. 'Number', 'Array', etc...)\n */\nfunction type (obj) {\n return Object.prototype.toString.call(obj).slice(8, -1)\n}\n\nmodule.exports = {\n getVecType,\n isVec,\n vec2: vecTypes[2],\n vec3: vecTypes[3],\n vec4: vecTypes[4],\n\n add,\n multiply,\n lerp,\n slerp\n}\n","import React, { useRef, useMemo } from 'react'\nimport { useFrame, useThree } from '@react-three/fiber'\nimport { Group } from 'three'\nimport vecn from 'vecn'\n// @ts-ignore\nimport lerp from '@14islands/lerp'\n\nimport { ScrollScene, useScrollRig } from '@14islands/r3f-scroll-rig'\n\n// Sticky mesh that covers full viewport size\nconst StickyChild = ({\n children,\n childTop,\n childBottom,\n scrollState,\n parentScale,\n childScale,\n scaleMultiplier,\n priority,\n stickyLerp = 1.0,\n offsetTop = 0,\n}: any) => {\n const group = useRef(null!)\n const size = useThree((s) => s.size)\n\n useFrame((_, delta) => {\n if (!scrollState.inViewport) return\n\n const topOffset = (childTop - offsetTop) / size.height\n const bottomOffset = (childBottom / parentScale[1]) * scaleMultiplier\n\n // move to top of sticky area\n const yTop = parentScale[1] * 0.5 - childScale[1] * 0.5 - offsetTop * scaleMultiplier\n const yBottom = -parentScale[1] * 0.5 + childScale[1] * 0.5\n const ySticky =\n -childTop * scaleMultiplier +\n yTop -\n (scrollState.viewport - 1) * size.height * scaleMultiplier +\n offsetTop * scaleMultiplier\n\n let y = group.current.position.y\n\n // enter\n if (scrollState.viewport + topOffset < 1) {\n y = yTop\n }\n // sticky\n else if (scrollState.visibility - bottomOffset < 1) {\n y = ySticky\n }\n // exit\n else {\n y = yBottom\n }\n\n group.current.position.y = lerp(group.current.position.y, y, stickyLerp, delta)\n }, priority) // must happen after ScrollScene's useFrame to be buttery\n\n return {children}\n}\n\nconst renderAsSticky = (\n children: any,\n size: any,\n childStyle: any,\n parentStyle: any,\n scaleMultiplier: number,\n { stickyLerp, fillViewport }: any\n) => {\n return ({ scale, ...props }: any) => {\n let childScale = vecn.vec3(parseFloat(childStyle.width), parseFloat(childStyle.height), 1)\n let childTop = parseFloat(childStyle.top)\n let childBottom = size.height - childTop - childScale[1]\n\n if (fillViewport) {\n childScale = vecn.vec3(size.width, size.height, 1)\n childTop = 0\n childBottom = 0\n }\n\n const offsetTop = parseFloat(parentStyle.top)\n\n return (\n // @ts-ignore\n \n {children({\n scale: childScale.times(scaleMultiplier),\n parentScale: scale,\n ...props,\n })}\n \n )\n }\n}\n\nexport const StickyScrollScene = ({ children, track, stickyLerp, fillViewport, ...props }: any) => {\n const size = useThree((s) => s.size)\n const { scaleMultiplier } = useScrollRig()\n\n const internalRef = useRef(track.current)\n\n // if tracked element is position:sticky, track the parent instead\n // we want to track the progress of the entire sticky area\n const [childStyle, parentStyle] = useMemo(() => {\n const style = getComputedStyle(track.current)\n\n let parentStyle\n if (style.position === 'sticky') {\n internalRef.current = track.current.parentElement\n\n // make sure parent is relative/absolute so we get accurante offsetTop\n parentStyle = getComputedStyle(internalRef.current)\n if (parentStyle.position === 'static') {\n console.error(\n 'StickyScrollScene: parent of position:sticky needs to be position:relative or position:absolute (currently set to position:static)'\n )\n }\n } else {\n console.error('StickyScrollScene: tracked element is not position:sticky')\n }\n return [style, parentStyle]\n }, [track, size])\n\n return (\n \n {renderAsSticky(children, size, childStyle, parentStyle, scaleMultiplier, {\n stickyLerp,\n fillViewport,\n })}\n \n )\n}\n","const _lerp = require('lerp')\n\n/**\n * Drop-in replacement of standard lerp with optional frame delta and target fps\n * to maintain constant animation speed at various fps\n * \n * Based on http://www.rorydriscoll.com/2016/03/07/frame-rate-independent-damping-using-lerp/\n * \n * @param {number} source Current value\n * @param {number} target Value to lerp towards\n * @param {number} rate Interpolation rate\n * @param {number} frameDelta Optional frame delta time in seconds. Should be 1/60 for a steady 60fps.\n * @param {number} targetFps Optional, target is 60 by default\n * @returns {number} interpolated value\n */\n\nfunction lerp(source, target, rate, frameDelta, targetFps = 60){\n \n // return normal lerp if no delta was passed\n if (typeof frameDelta === 'undefined') {\n return _lerp(source, target, rate)\n }\n\n const relativeDelta = frameDelta / (1 / targetFps)\n const smoothing = 1 - rate\n return _lerp(source, target, 1 - Math.pow(smoothing, relativeDelta));\n}\n\nmodule.exports = lerp","function lerp(v0, v1, t) {\n return v0*(1-t)+v1*t\n}\nmodule.exports = lerp"],"names":["_excluded","WebGLImage","forwardRef","_ref","ref","el","scale","scrollState","vertexShader","fragmentShader","_ref$invalidateFrameL","invalidateFrameLoop","_ref$widthSegments","widthSegments","_ref$heightSegments","heightSegments","props","_objectWithoutPropertiesLoose","material","useRef","mesh","useImperativeHandle","current","_useThree","useThree","invalidate","gl","size","pixelRatio","s","viewport","dpr","scroll","useScrollbar","scaleMultiplier","useScrollRig","texture","useImageAsTexture","uniforms","useMemo","u_color","value","Color","u_time","u_pixelRatio","u_progress","u_visibility","u_viewport","u_velocity","u_res","Vector2","u_rect","u_size","u_texture","u_loaded","u_scaleMultiplier","useEffect","set","image","width","height","useFrame","_","delta","inViewport","x","y","velocity","progress","visibility","args","React","createElement","Fragment","_extends","attach","transparent","ParallaxGroup","children","parallax","position","vecTypes","Proxy","get","obj","prop","hasOwnProperty","getVecType","vecn","Array","constructor","dimension","flattenOuter","every","type","TypeError","length","Error","fill","super","this","Reflect","defineProperty","undefined","enumerable","magnitude","pnorm","div","v","checkCompatibility","dim","result","i","minus","neg","times","plus","pow","p","Math","dot","normalize","abs","reflect","normal","n","argmax","maxVal","max","reduce","acc","concat","argmin","minVal","min","choose","indices","isArray","isIndex","toString","RangeError","forEach","push","copy","equals","approximatelyEquals","epsilon","sum","toArray","from","apply","filter","map","slice","splice","test","validator","Number","swizzleSymbolMap","getSwizzleSymbolMap","newVals","item","split","some","c","valid","unique","SyntaxError","index","swizzleSet","newDim","values","swizzleGet","isNaN","isInteger","classname","VecType","arr","promoteArrayDimension","writable","target","Object","preventExtensions","namedIndices","z","w","r","g","b","a","t","q","find","o","numberValid","prototype","call","src","isVec","vec2","vec3","vec4","add","vecs","multiply","lerp","v1","v2","slerp","theta","acos","relative","cos","sin","StickyChild","childTop","childBottom","parentScale","childScale","priority","_ref$stickyLerp","stickyLerp","_ref$offsetTop","offsetTop","group","yTop","source","rate","frameDelta","targetFps","_ref2","_ref2$speed","speed","parallaxAmount","ScrollScene","scissor","inViewportMargin","_ref4","track","fillViewport","_excluded2","internalRef","_useMemo","parentStyle","style","getComputedStyle","parentElement","console","error","childStyle","_ref3","parseFloat","top","renderAsSticky","font","_ref$fontOffsetY","fontOffsetY","_ref$fontOffsetX","fontOffsetX","_ref$overrideEmissive","overrideEmissive","color","cs","window","textColor","letterSpacing","fontSize","lineHeight","textAlign","emissive","xOffset","Text","maxWidth","overflowWrap","anchorX","anchorY"],"mappings":"wlBAAA,IAAAA,EAAA,CAAA,KAAA,WAAA,WAAA,QAAA,OAAA,cAAA,cAAA,mBAAA,SCAAA,EAAA,CAAA,KAAA,QAAA,cAAA,eAAA,iBAAA,sBAAA,gBAAA,kBAyBaC,EAAaC,EAAAA,WACxB,SAAAC,EAYEC,OAVEC,EAAEF,EAAFE,GACAC,EAAKH,EAALG,MACAC,EAAWJ,EAAXI,YACAC,EAAYL,EAAZK,aACAC,EAAcN,EAAdM,eAAcC,EAAAP,EACdQ,oBAAAA,OAAmB,IAAAD,GAAQA,EAAAE,EAAAT,EAC3BU,cAAAA,OAAa,IAAAD,EAAG,IAAGA,EAAAE,EAAAX,EACnBY,eAAAA,OAAiB,IAAHD,EAAG,IAAGA,EACjBE,EAAKC,EAAAd,EAAAH,GAIJkB,EAAWC,EAAMA,OAAiB,MAClCC,EAAOD,SAAa,MAC1BE,EAAAA,oBAAoBjB,EAAK,kBAAMgB,EAAKE,OAAO,GAE3C,IAAAC,EAAiCC,aAAzBC,EAAUF,EAAVE,WAAYC,EAAEH,EAAFG,GAAIC,EAAIJ,EAAJI,KAClBC,EAAaJ,WAAS,SAACK,GAAM,OAAAA,EAAEC,SAASC,GAAG,GACzCC,EAAWC,EAAYA,eAAvBD,OACAE,EAAoBC,EAAYA,eAAhCD,gBAEFE,EAAUC,EAAiBA,kBAAChC,GAE5BiC,EAAWC,UAAQ,WACvB,MAAO,CACLC,QAAS,CAAEC,MAAO,IAAIC,EAAKA,MAAC,UAC5BC,OAAQ,CAAEF,MAAO,GACjBG,aAAc,CAAEH,MAAOb,GACvBiB,WAAY,CAAEJ,MAAO,GACrBK,aAAc,CAAEL,MAAO,GACvBM,WAAY,CAAEN,MAAO,GACrBO,WAAY,CAAEP,MAAO,GACrBQ,MAAO,CAAER,MAAO,IAAIS,EAAAA,SACpBC,OAAQ,CAAEV,MAAO,IAAIS,EAAAA,SACrBE,OAAQ,CAAEX,MAAO,IAAIS,EAAAA,SACrBG,UAAW,CAAEZ,MAAO,MACpBa,SAAU,CAAEb,OAAO,GACnBc,kBAAmB,CAAEd,MAAOP,GAEhC,EAAG,CAACN,IAGJ4B,YAAU,WACHpB,GACAlB,EAASI,UACdJ,EAASI,QAAQgB,SAASe,UAAUZ,MAAQL,EAC5ClB,EAASI,QAAQgB,SAASc,OAAOX,MAAMgB,IAAIrB,EAAQsB,MAAMC,MAAOvB,EAAQsB,MAAME,QAC9E1C,EAASI,QAAQgB,SAASgB,SAASb,OAAQ,EAC7C,EAAG,CAACL,EAASV,IAEb8B,YAAU,WACHtC,EAASI,UACdJ,EAASI,QAAQgB,SAASW,MAAMR,MAAMgB,IAAI9B,EAAKgC,MAAOhC,EAAKiC,QAC3D1C,EAASI,QAAQgB,SAASa,OAAOV,MAAMgB,UAAInD,SAAAA,EAAQ,GAAIA,MAAAA,OAAAA,EAAAA,EAAQ,IACjE,EAAG,CAACqB,EAAMrB,IAEVuD,WAAS,SAACC,EAAGC,GACNxD,EAAYyD,YAAe5C,EAAKE,SAAYJ,EAASI,SAErDJ,EAASI,QAAQgB,SAASgB,SAASb,QAExCvB,EAASI,QAAQgB,SAASK,OAAOF,OAASsB,EAG1C7C,EAASI,QAAQgB,SAASa,OAAOV,MAAMgB,IAAIrC,EAAKE,QAAQhB,MAAM2D,EAAG7C,EAAKE,QAAQhB,MAAM4D,GAGpFhD,EAASI,QAAQgB,SAASU,WAAWP,MAAQT,EAAOmC,SAGpDjD,EAASI,QAAQgB,SAASO,WAAWJ,MAAQlC,EAAY6D,SAGzDlD,EAASI,QAAQgB,SAASQ,aAAaL,MAAQlC,EAAY8D,WAE3DnD,EAASI,QAAQgB,SAASS,WAAWN,MAAQlC,EAAYuB,SAErDnB,GAAqBc,IAC3B,GAEA,IAAM6C,EAAO/B,EAAOA,QAClB,WAAM,MAAA,CACJ,CACE/B,aAAAA,EACAC,eAAAA,GAEH,EACD,CAACD,EAAcC,IAGjB,OACE8D,EAAA,QAAAC,cAAAD,EAAAA,QAAAE,SAAA,KACEF,EAAAA,QAAAC,cAAA,OAAAE,EAAA,CAAMtE,IAAKgB,GAAUJ,GACnBuD,EAAA,QAAAC,cAAA,gBAAA,CAAeG,OAAO,WAAWL,KAAM,CAAC,EAAG,EAAGzD,EAAeE,KAC7DwD,EAAAA,QAAAC,cAAA,iBAAA,CACEpE,IAAKc,EACLoD,KAAMA,EACNM,aAAa,EACbtC,SAAUA,KAKpB,GCnIFtC,EAAA,CAAA,WAAA,SAOM6E,EAAgB,SAAH1E,GAAM,IAAA2E,EAAQ3E,EAAR2E,SAAUvE,EAAWJ,EAAXI,YAAawE,EAAQ5E,EAAR4E,SACxC3D,EAAOD,EAAMA,OAAO,MACpBQ,EAAOH,EAAQA,SAAC,SAACK,GAAM,OAAAA,EAAEF,IAAI,GAC3BO,EAAoBC,EAAYA,eAAhCD,gBAQR,OANA2B,EAAAA,SAAS,WACFtD,EAAYyD,aAEjB5C,EAAKE,QAAQ0D,SAASd,EAAIa,GADsB,EAAvBxE,EAAY6D,SAAe,GACIlC,EAAkBP,EAAKiC,OACjF,GAEOW,gCAAMnE,IAAKgB,GAAO0D,EAC3B,ECdA,IAAIG,EAUK,IAAIC,MAAM,CAAE,EATH,CACdC,IAAK,SAAUC,EAAKC,GAIlB,OAHKD,EAAIE,eAAeD,KACtBD,EAAIC,GAAQE,EAAWF,IAElBD,EAAIC,EACZ,IAUL,MAAMG,UAAaC,MAOjBC,YAAaC,EAAWrB,GAGtB,KAFAA,EAAOsB,EAAatB,IAEVuB,MAAO5B,GAAkB,WAAZ6B,EAAK7B,IAC1B,MAAM,IAAI8B,UAAU,kCAEtB,GAAIzB,EAAK0B,OAAS,GAAK1B,EAAK0B,SAAWL,EACrC,MAAM,IAAIM,MAAM,+FAGE,IAAhB3B,EAAK0B,SACP1B,EAAO,CAAC,IAEU,IAAhBA,EAAK0B,QAAkC,WAAlBF,EAAKxB,EAAK,MACjCA,EAAOmB,MAAME,GAAWO,KAAK5B,EAAK,KAGhCqB,EAAY,EACdQ,SAAS7B,IAET6B,MAAM,GACNC,KAAK,GAAK9B,EAAK,IAGjB+B,QAAQC,eAAeF,KAAM,MAAO,CAClC3D,WAAO8D,EACPC,YAAY,IAEdH,QAAQC,eAAeF,KAAM,OAAQ,CACnC3D,WAAO8D,EACPC,YAAY,IAEdH,QAAQC,eAAeF,KAAM,QAAS,CACpC3D,WAAO8D,EACPC,YAAY,IAEdH,QAAQC,eAAeF,KAAM,UAAW,CACtC3D,WAAO8D,EACPC,YAAY,GAEf,CAMGC,gBACF,OAAOL,KAAKM,MAAM,EACnB,CAYDC,IAAKC,GACHC,EAAmBD,EAAGR,KAAKU,KAAK,GAChB,WAAZhB,EAAKc,KACPA,EAAI,IAAKnB,MAAMW,KAAKU,KAAMZ,KAAKU,IAGjC,IAAIG,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKJ,SAAUgB,EACjCD,EAAOC,GAAKZ,KAAKY,GAAKJ,EAAEI,GAE1B,OAAO/B,EAASmB,KAAKU,KAAKC,EAC3B,CAUDE,MAAOL,GACLC,EAAmBD,EAAGR,KAAKU,KAAK,GAChB,WAAZhB,EAAKc,KACPA,EAAI,IAAKnB,MAAMW,KAAKU,KAAMZ,KAAKU,IAGjC,IAAIG,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,EAAOC,GAAKZ,KAAKY,GAAKJ,EAAEI,GAE1B,OAAO/B,EAASmB,KAAKU,KAAKC,EAC3B,CAMDG,MACE,OAAOjC,EAASmB,KAAKU,KAAKV,KAAKe,OAAO,GACvC,CAUDC,KAAMR,GACJC,EAAmBD,EAAGR,KAAKU,KAAK,GAChB,WAAZhB,EAAKc,KACPA,EAAI,IAAKnB,MAAMW,KAAKU,KAAMZ,KAAKU,IAGjC,IAAIG,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,EAAOC,GAAKZ,KAAKY,GAAKJ,EAAEI,GAE1B,OAAO/B,EAASmB,KAAKU,KAAKC,EAC3B,CAQDM,IAAKC,GACH,IAAIP,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,EAAOC,GAAKO,KAAKF,IAAIjB,KAAKY,GAAIM,GAEhC,OAAOrC,EAASmB,KAAKU,KAAKC,EAC3B,CASDI,MAAOP,GACLC,EAAmBD,EAAGR,KAAKU,KAAK,GAChB,WAAZhB,EAAKc,KACPA,EAAI,IAAKnB,MAAMW,KAAKU,KAAMZ,KAAKU,IAGjC,IAAIG,EAAS,GACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,EAAOC,GAAKZ,KAAKY,GAAKJ,EAAEI,GAE1B,OAAO/B,EAASmB,KAAKU,KAAKC,EAC3B,CAWDS,IAAKZ,GACHC,EAAmBD,EAAGR,KAAKU,KAE3B,IAAIC,EAAS,EACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,GAAUX,KAAKY,GAAKJ,EAAEI,GAExB,OAAOD,CACR,CAODU,YACE,OAAOrB,KAAKO,IAAIP,KAAKK,UACtB,CAQDC,MAAOY,GACL,IAAIP,EAAS,EACb,IAAK,IAAIC,EAAI,EAAGA,EAAIZ,KAAKU,MAAOE,EAC9BD,GAAUQ,KAAKF,IAAIE,KAAKG,IAAItB,KAAKY,IAAKM,GAExC,OAAOC,KAAKF,IAAIN,EAAQ,EAAIO,EAC7B,CASDK,QAASC,GACP,MAAMC,EAAID,EAAOH,YACjB,OAAOrB,KAAKa,MAAMY,EAAEV,MAAM,EAAIf,KAAKoB,IAAIK,IACxC,CAUDC,SACE,MAAMC,EAAS3B,KAAK4B,MACpB,OAAO5B,KAAK6B,OAAO,CAACC,EAAKjE,EAAG+C,IAAM/C,IAAM8D,EAASG,EAAIC,OAAO,CAACnB,IAAMkB,EAAK,GACzE,CAODE,SACE,MAAMC,EAASjC,KAAKkC,MACpB,OAAOlC,KAAK6B,OAAO,CAACC,EAAKjE,EAAG+C,IAAM/C,IAAMoE,EAASH,EAAIC,OAAO,CAACnB,IAAMkB,EAAK,GACzE,CASDK,OAAQC,GACN,IAAK/C,MAAMgD,QAAQD,GACjB,MAAM,IAAIzC,UAAU,uCAEtB,IAAKyC,EAAQ3C,MAAOmB,GAAMA,EAAIZ,KAAKU,KAAO4B,EAAQ1B,EAAE2B,aAClD,MAAM,IAAIC,WAAW,mDAGvB,IAAIhC,EAAI,GAER,OADA4B,EAAQK,QAAS7B,GAAMJ,EAAEkC,KAAK1C,KAAKY,KAC5B/B,EAAS2B,EAAEZ,QAAQY,EAC3B,CAQDmC,OACE,OAAO9D,EAASmB,KAAKU,KAAKV,KAC3B,CAQD4C,OAAQpC,GACN,OAAOA,EAAEZ,SAAWI,KAAKU,KAAOF,EAAEf,MAAM,CAAC5B,EAAG+C,IAAMZ,KAAKY,KAAO/C,EAC/D,CAUDgF,oBAAqBrC,EAAGsC,EAAU,MAChC,OAAOtC,EAAEZ,SAAWI,KAAKU,KAAOF,EAAEf,MAAM,CAAC5B,EAAG+C,IAAMO,KAAKG,IAAItB,KAAKY,GAAK/C,GAAKiF,EAC3E,CAODlB,MACE,OAAOT,KAAKS,OAAO5B,KACpB,CAODkC,MACE,OAAOf,KAAKe,OAAOlC,KACpB,CAOD+C,MACE,OAAO/C,KAAK6B,OAAO,CAACC,EAAKjE,IAAMiE,EAAMjE,EAAG,EACzC,CAODmF,UACE,OAAO3D,MAAM4D,KAAKjD,KACnB,CAUD+B,UAAW7D,GACT,MAAMyC,EAASZ,MAAMgC,OAAOmB,MAAMlD,KAAKgD,UAAW9E,GAClD,OAAOW,EAAS8B,EAAOf,QAAQe,EAChC,CAQDwC,UAAWjF,GACT,MAAMyC,EAASZ,MAAMoD,OAAOD,MAAMlD,KAAKgD,UAAW9E,GAClD,OAAIyC,EAAOf,OAAS,EACXf,EAAS8B,EAAOf,QAAQe,GAE1BA,CACR,CAQDyC,OAAQlF,GACN,MAAMyC,EAASZ,MAAMqD,OAAOlF,GAC5B,OAAIyC,EAAOlB,MAAO5B,GAAkB,WAAZ6B,EAAK7B,IACpB8C,EAEFA,EAAOqC,SACf,CAMDK,SAAUnF,GACR,MAAMyC,EAASZ,MAAMsD,MAAMH,MAAMlD,KAAKgD,UAAW9E,GACjD,OAAIyC,EAAOf,OAAS,EACXf,EAAS8B,EAAOf,QAAQe,GAE1BA,CACR,CAMD2C,UAAWpF,GACT,IAAIqF,EAAOvD,KAAKgD,UAGhB,GAFAO,EAAKD,UAAUpF,GAEXqF,EAAK3D,SAAWI,KAAKU,IACvB,MAAM,IAAIb,MAAM,0CAElB,IAAK0D,EAAK9D,MAAO5B,GAAkB,WAAZ6B,EAAK7B,IAC1B,MAAM,IAAI8B,UAAU,iCAGtB4D,EAAKd,QAAQ,CAAC5E,EAAG+C,KAAQZ,KAAKY,GAAK/C,CAAA,EACpC,CAED0E,WACE,OAAOvC,KAAK6B,OAAO,CAACpG,EAAGoC,EAAG+C,IACjBnF,EAAIoC,GAAK+C,IAAMZ,KAAKU,IAAM,EAAI,IAAM,MAC1C,MAAQ,GACZ,EA6BH,MAAM8C,EAAY,CAChBnG,IAAK,SAAU2B,EAAKC,EAAM5C,GACxB,GAAa,WAAT4C,EACF,OAAO,EAET,GAAIqD,EAAQrD,GAAO,CACjB,GAAIwE,OAAOxE,IAASD,EAAI0B,IACtB,MAAM,IAAI8B,WAAW,qDAChB,GAAoB,WAAhB9C,EAAKrD,GACd,MAAM,IAAIsD,UAAU,qCAGpB,OADAX,EAAIC,GAAQ5C,GACL,CAEV,CAED,MAAMqH,EAAmBC,EAAoB1E,EAAKsD,YAClD,SAAIvD,EAAI0B,KAAO,GAAKgD,KAwLxB,SAAqBlD,EAAG/E,EAAG2H,EAAKQ,GAC9B,GAAiB,IAAbnI,EAAEmE,OAAc,CAClB,GAAsB,WAAlBF,EAAKkE,GACP,MAAM,IAAIjE,UAAU,wBAGtB,YADAa,EAAE4C,EAAI3H,IAAMmI,EAEb,CAED,IAAKvE,MAAMgD,QAAQuB,GAAU,MAAM,IAAIjE,UAAU,qCACjD,GAAIlE,EAAEmE,SAAWgE,EAAQhE,OAAQ,MAAM,IAAID,UAAU,8CACrD,IAAKiE,EAAQnE,MAAOoE,GAAwB,WAAfnE,EAAKmE,IAAqB,MAAM,IAAIlE,UAAU,mCAE3E,GAAIlE,EAAEqI,MAAM,IAAIC,KAAMC,GAAMZ,EAAIY,IAAMxD,EAAEE,KACtC,OAGF,IAAIuD,GAAQ,EACZ,IAAK,IAAIrD,EAAI,EAAGsD,EAAS,CAAA,EAAItD,EAAInF,EAAEmE,SAAUgB,EAAG,CAC9C,GAAIsD,EAAOhF,eAAezD,EAAEmF,IAAK,CAC/BqD,GAAQ,EACR,KACD,CACDC,EAAOzI,EAAEmF,KAAM,CAChB,CACD,IAAKqD,EAAO,MAAM,IAAIE,YAAY,6DAElC1I,EAAEqI,MAAM,IAAIV,IAAKY,GAAMZ,EAAIY,IAAIvB,QAAQ,CAAC2B,EAAOxD,KAAQJ,EAAE4D,GAASR,EAAQhD,EAAC,EAC7E,CAnNMyD,CAAWrF,EAAKC,EAAKsD,WAAYmB,EAAkBrH,IAC5C,EAIV,EACD0C,IAAK,SAAUC,EAAKC,GAClB,MAAMyE,EAAmBC,EAAoB1E,EAAKsD,YAClD,OAAIvD,EAAI0B,KAAO,GAAKgD,EAsJxB,SAAqBlD,EAAG/E,EAAG4B,GACzB,MAAMiH,EAAS7I,EAAEmE,OAEjB,GAAe,IAAX0E,EACF,OAAO9D,EAAEnD,EAAI5B,IAGf,IAAI8I,EAAS9I,EAAEqI,MAAM,IAAIjC,OAAO,CAACC,EAAKjE,KACpC,IAAI+C,EAAIvD,EAAIQ,GACZ,OAAOiE,GAAOlB,EAAIJ,EAAEE,IAAMoB,EAAIC,OAAO,CAACvB,EAAEI,UAAOT,GAC9C,IACH,OAAOoE,EAAS,IAAI1F,EAASyF,MAAWC,QAAUpE,CACpD,CAjKaqE,CAAWxF,EAAKC,EAAMyE,GAGxB1E,EAAIC,EACZ,GASH,SAASE,EAAYuB,GAGnB,MAFAA,EAAM+C,OAAO/C,MAEA7B,GAAW,CACtB,GAAI4F,MAAM/D,GAAM,MAAM,IAAIf,UAAU,4CACpC,GAAIe,GAAO,EAAG,MAAM,IAAI8B,WAAW,+BACnC,IAAKiB,OAAOiB,UAAUhE,GAAM,MAAM,IAAI8B,WAAW,+BAGjD,IAAImC,EAAY,MAAQjE,EACpBkE,EAAU,CAAED,CAACA,GAAY,cAAcvF,EACzCE,eAAgBpB,GACd,GAAoB,IAAhBA,EAAK0B,QAAgB1B,EAAK,aAAckB,EAAM,CAChD,GAAIlB,EAAK,GAAGwC,IAAMA,EAChB,MAAM,IAAIf,UAAU,0BAEtBzB,EA2OV,SAAgC2G,EAAKnE,GACnC,MAAO,IAAIrB,MAAMqB,IAAM0C,IAAI,CAAC1F,EAAGkD,IAAMA,EAAIiE,EAAIjF,OAASiF,EAAIjE,GAAK,EACjE,CA7OiBkE,CAAsB5G,EAAK,GAAG8E,UAAWtC,EACjD,CACDX,MAAMW,EAAKxC,GACX+B,QAAQC,eAAeF,KAAM,MAAO,CAClC3D,MAAOqE,EACPqE,UAAU,EACV3E,YAAY,GAEf,IACCuE,GAOJ9F,EAAS6B,GALK,YAAqBxC,GACjC,IAAI8G,EAAS,IAAIJ,KAAW1G,GAE5B,OADA+G,OAAOC,kBAAkBF,GAClB,IAAIlG,MAAMkG,EAAQxB,EAC1B,CAEF,CAED,OAAO3E,EAAS6B,EAClB,CAqEA,MAAMyE,EAAe,CACnB,CAACtH,EAAG,EAAGC,EAAG,EAAGsH,EAAG,EAAGC,EAAG,GACtB,CAACC,EAAG,EAAGC,EAAG,EAAGC,EAAG,EAAGC,EAAG,GACtB,CAAChK,EAAG,EAAGiK,EAAG,EAAGxE,EAAG,EAAGyE,EAAG,IAUxB,SAAShC,EAAqBlI,GAC5B,OAAO0J,EAAaS,KAAMxC,GACjB3H,EAAEqI,MAAM,IAAIrE,MAAOuE,GAAMA,KAAKZ,GAEzC,CAgFA,SAAS3C,EAAoBoF,EAAGnF,EAAKoF,GAAc,GACjD,KAAIA,GAA2B,WAAZpG,EAAKmG,IAEbA,EAAEjG,QAAUiG,EAAEjG,SAAWc,GAGpC,MAAM,IAAIf,UAAU,uDAAuDmG,EAAc,iBAAmB,MAC9G,CAUA,SAAStG,EAAcqF,GACrB,OAAMA,aAAexF,OAAyB,IAAfwF,EAAIjF,QAG/BiF,EAAI,aAAcxF,MACbG,EAAaqF,EAAI,IAHjBA,CAMX,CASA,SAASvC,EAASb,GAChB,OAAQgD,MAAMhD,IACPgC,OAAOhC,GAAGc,aAAed,GACzBgC,OAAOiB,UAAUjB,OAAOhC,KACxBgC,OAAOhC,IAAM,CACtB,CAsBA,SAAS/B,EAAMV,GACb,OAAOiG,OAAOc,UAAUxD,SAASyD,KAAKhH,GAAKqE,MAAM,GAAI,EACvD,CAEA,IAAA4C,EAAiB,CACf9G,aACA+G,MAjOF,SAAgB1F,GACd,OAAOA,aAAapB,CACtB,EAgOE+G,KAAMtH,EAAS,GACfuH,KAAMvH,EAAS,GACfwH,KAAMxH,EAAS,GAEfyH,IA1UF,YAAiBC,GACf,MAAM7F,EAAM6F,EAAK,GAAG7F,IACpB,IAAK6F,EAAK9G,MAAOe,GAAMA,EAAEE,MAAQA,GAC/B,MAAM,IAAIf,UAAU,6CAEtB,OAAO4G,EAAK1E,OAAO,CAACC,EAAKtB,IAAMsB,EAAId,KAAKR,GAAI3B,EAAS6B,KACvD,EAqUE8F,SA9MF,YAAsBD,GACpB,MAAM7F,EAAM6F,EAAK,GAAG7F,IACpB,IAAK6F,EAAK9G,MAAOe,GAAMA,EAAEE,MAAQA,GAAM,MAAM,IAAIf,UAAU,6CAC3D,OAAO4G,EAAK1E,OAAO,CAACC,EAAKtB,IAAMsB,EAAIf,MAAMP,GAAI3B,EAAS6B,GAAK,GAC7D,EA2MA+F,KA5NA,SAAeC,EAAIC,EAAIjB,GACrB,GAAIgB,EAAGhG,MAAQiG,EAAGjG,IAAK,MAAM,IAAIf,UAAU,yCAE3C,OADA+F,EAAIA,EAAI,EAAI,EAAKA,EAAI,EAAI,EAAIA,EACtBgB,EAAG1F,KAAK2F,EAAG9F,MAAM6F,GAAI3F,MAAM2E,GACpC,EAyNEkB,MAlMF,SAAgBF,EAAIC,EAAIjB,GACtB,GAAIgB,EAAGhG,MAAQiG,EAAGjG,IAAK,MAAM,IAAIf,UAAU,yCAE3C+F,EAAIA,EAAI,EAAI,EAAKA,EAAI,EAAI,EAAIA,EAC7B,IAAItE,EAAMsF,EAAGrF,YAAYD,IAAIuF,EAAGtF,aAChCD,EAAMA,GAAO,GAAK,EAAKA,EAAM,EAAI,EAAIA,EACrC,MAAMyF,EAAQ1F,KAAK2F,KAAK1F,GAAOsE,EACzBqB,EAAWJ,EAAG9F,MAAM6F,EAAG3F,MAAMK,IAAMC,YACnChB,EAAYqG,EAAGrG,WAAcsG,EAAGtG,UAAYqG,EAAGrG,WAAaqF,EAClE,OAAOgB,EAAG3F,MAAMI,KAAK6F,IAAIH,IAAQ7F,KAAK+F,EAAShG,MAAMI,KAAK8F,IAAIJ,KAC3DxF,YAAYN,MAAMV,EACvB,kECnkBM6G,EAAc,SAAHnN,GACf,IAAA2E,EAAQ3E,EAAR2E,SACAyI,EAAQpN,EAARoN,SACAC,EAAWrN,EAAXqN,YACAjN,EAAWJ,EAAXI,YACAkN,EAAWtN,EAAXsN,YACAC,EAAUvN,EAAVuN,WACAxL,EAAe/B,EAAf+B,gBACAyL,EAAQxN,EAARwN,SAAQC,EAAAzN,EACR0N,WAAAA,OAAU,IAAAD,EAAG,EAAGA,EAAAE,EAAA3N,EAChB4N,UAAAA,OAAY,IAAHD,EAAG,EAACA,EAEPE,EAAQ7M,EAAMA,OAAQ,MACtBQ,EAAOH,WAAS,SAACK,GAAC,OAAKA,EAAEF,IAAI,GAmCnC,OAjCAkC,EAAQA,SAAC,SAACC,EAAGC,GACX,GAAKxD,EAAYyD,WAAjB,CAEA,IAIMiK,EAAwB,GAAjBR,EAAY,GAA2B,GAAhBC,EAAW,GAAWK,EAAY7L,EAuBtE8L,EAAM1M,QAAQ0D,SAASd,ECvC3B,SAAcgK,EAAQ9C,EAAQ+C,EAAMC,EAAYC,EAAY,IAG1D,OCnBgBvB,EDoBO1B,EAAR8C,GCnBF,GADOpC,ODmBM,IAAfsC,EACoBD,EAKF,EAAI5G,KAAKF,IADpB,EAAI8G,EADAC,GAAc,EAAIC,MCtBtBvB,EAAGhB,EADvB,IAAkBgB,EAAIhB,CD0BtB,CD6B+Be,CAAKmB,EAAM1M,QAAQ0D,SAASd,EAZnD3D,EAAYuB,UAfGyL,EAAWQ,GAAapM,EAAKiC,OAeT,EACjCqK,EAGG1N,EAAY8D,WAlBCmJ,EAAcC,EAAY,GAAMvL,EAkBL,GAZ9CqL,EAAWrL,EACZ+L,GACC1N,EAAYuB,SAAW,GAAKH,EAAKiC,OAAS1B,EAC3C6L,EAAY7L,EALoB,IAAjBuL,EAAY,GAA2B,GAAhBC,EAAW,GAsBUG,EAAY9J,GAC3E,EAAG4J,GAEIpJ,EAAAA,+BAAOnE,IAAK4N,GAAQlJ,EAC7B,8BFrCmC,SAAHwJ,GAAM,IAAAxJ,EAAQwJ,EAARxJ,SAAQyJ,EAAAD,EAAEE,MAAAA,OAAQ,IAAHD,EAAG,EAACA,EAAKvN,EAAKC,EAAAqN,EAAAtO,GAE3DyO,EAAiBD,EAAQ,EAC/B,OAEEjK,EAAC,QAAAC,cAAAkK,EAAWA,YAAAhK,EAAA,CAACiK,SAAS,EAAOC,iBAA4C,IAAvBrH,KAAKS,IAAI,EAAG,IAJ5C,GAIwE,KAAShH,GAChG,SAACA,GAAK,OACLuD,EAAAA,QAAAC,cAACK,EAAaH,EAAA,CAACK,SAAU0J,GAAoBzN,GAC1C8D,EAAS9D,GACI,EAIxB,4BEqEiC,SAAH6N,OAAM/J,EAAQ+J,EAAR/J,SAAUgK,EAAKD,EAALC,MAAOjB,EAAUgB,EAAVhB,WAAYkB,EAAYF,EAAZE,aAAiB/N,EAAKC,EAAA4N,EAAAG,GAC/ErN,EAAOH,WAAS,SAACK,GAAC,OAAKA,EAAEF,IAAI,GAC3BO,EAAoBC,EAAYA,eAAhCD,gBAEF+M,EAAc9N,EAAMA,OAAC2N,EAAMxN,SAIjC4N,EAAkC3M,EAAAA,QAAQ,WACxC,IAEI4M,EAFEC,EAAQC,iBAAiBP,EAAMxN,SAgBrC,MAbuB,WAAnB8N,EAAMpK,UACRiK,EAAY3N,QAAUwN,EAAMxN,QAAQgO,cAIP,YAD7BH,EAAcE,iBAAiBJ,EAAY3N,UAC3B0D,UACduK,QAAQC,MACN,uIAIJD,QAAQC,MAAM,6DAET,CAACJ,EAAOD,EACjB,EAAG,CAACL,EAAOnN,IAlBJ8N,EAAUP,EAAEC,GAAAA,EAAWD,EAAA,GAoB9B,OACE3K,EAAAA,sBAACmK,cAAWhK,GAACoK,MAAOG,GAAiBjO,GAxElB,SACrB8D,EACAnD,EACA8N,EACAN,EACAjN,EAAuBoM,GAErB,IADAT,EAAUS,EAAVT,WAAYkB,EAAYT,EAAZS,aAEd,OAAO,SAAAW,GAAG,IAAApP,EAAKoP,EAALpP,MAAUU,EAAKC,EAAAyO,EAAA1P,GACnB0N,EAAalI,EAAKgH,KAAKmD,WAAWF,EAAW9L,OAAQgM,WAAWF,EAAW7L,QAAS,GACpF2J,EAAWoC,WAAWF,EAAWG,KACjCpC,EAAc7L,EAAKiC,OAAS2J,EAAWG,EAAW,GAElDqB,IACFrB,EAAalI,EAAKgH,KAAK7K,EAAKgC,MAAOhC,EAAKiC,OAAQ,GAChD2J,EAAW,EACXC,EAAc,GAGhB,IAAMO,EAAY4B,WAAWR,EAAYS,KAEzC,OAEErL,EAAAA,QAAAC,cAAC8I,EAAW5I,EACVqJ,CAAAA,UAAWA,EACXN,YAAanN,EACboN,WAAYA,EAAWvG,MAAMjF,GAC7B2L,WAAYA,EACZN,SAAUA,EACVC,YAAaA,EACbtL,gBAAiBA,GACblB,GAEH8D,EAAQJ,GACPpE,MAAOoN,EAAWvG,MAAMjF,GACxBuL,YAAanN,GACVU,IAIX,CACF,CAgCO6O,CAAe/K,EAAUnD,EAAM8N,EAAYN,EAAajN,EAAiB,CACxE2L,WAAAA,EACAkB,aAAAA,IAIR,yCJrHyB,SAAH5O,GAWD,IAVnBE,EAAEF,EAAFE,GACAyE,EAAQ3E,EAAR2E,SACA5D,EAAQf,EAARe,SACAZ,EAAKH,EAALG,MACAwP,EAAI3P,EAAJ2P,KAAIC,EAAA5P,EACJ6P,YAAAA,OAAc,IAAHD,EAAG,EAACA,EAAAE,EAAA9P,EACf+P,YAAAA,OAAc,IAAHD,EAAG,EAACA,EAAAE,EAAAhQ,EACfiQ,iBAAAA,OAAmB,IAAHD,GAAQA,EACxBE,EAAKlQ,EAALkQ,MACGrP,EAAKC,EAAAd,EAAAH,GAEA2B,EAASH,EAAQA,WAAjBG,KACAO,EAAoBC,EAAYA,eAAhCD,gBAERgN,EAAsE3M,EAAOA,QAAC,WAC5E,IAAKlC,EAAGiB,QAAS,MAAO,CAAA,EACxB,IAAMgP,EAAKC,OAAOlB,iBAAiBhP,EAAGiB,SAGlCkP,EAAYH,GAASC,EAAGD,MAS5B,OARKA,GAAsB,qBAAbC,EAAGD,OAAgChQ,EAAGiB,QAAQgO,gBAC1DkB,EAAYD,OAAOlB,iBAAiBhP,EAAGiB,QAAQgO,eAAee,OAOzD,CACLI,eAJqBd,WAAWW,EAAGG,gBAAkB,GAAKd,WAAWW,EAAGI,UAKxEC,YAJkBhB,WAAWW,EAAGK,aAAe,GAAKhB,WAAWW,EAAGI,UAKlEF,UAAAA,EACAE,SAAUf,WAAWW,EAAGI,UAAYxO,EACpC0O,UAAWN,EAAGM,UAGlB,EAAG,CAACvQ,EAAIsB,EAAMrB,EAAO+P,EAAOnO,IAtBpBsO,EAAStB,EAATsB,UAAWE,EAAQxB,EAARwB,SAAUE,EAAS1B,EAAT0B,UAAWD,EAAUzB,EAAVyB,WAAYF,EAAavB,EAAbuB,cAwBpDjN,EAAAA,UAAU,WACJtC,GAAYkP,IAEdlP,EAAS2P,SAAWR,EAExB,EAAG,CAACnP,EAAUmP,EAAOD,IAErB,IAAIU,EAAU,EASd,MARkB,SAAdF,GAAsC,UAAdA,EAC1BE,GAAsB,GAAZxQ,EAAM,GACO,UAAdsQ,GAAuC,QAAdA,IAClCE,EAAqB,GAAXxQ,EAAM,IAMhBiE,EAAAA,QAACC,cAAAuM,EAAAA,KAAIrM,EACHgM,CAAAA,SAAUA,EACVM,SAAU1Q,EAAQA,EAAM,GAAKqB,EAAKgC,MAClCgN,WAAYA,EAEZC,UAAWA,EACXH,cAAeA,EACfQ,aAAa,aACbnB,KAAMA,EACNO,MAAOG,EAEPU,QAASN,EACTO,QAAQ,MAERnM,SAAU,CAAC8L,EAAUJ,EAAWR,GAjBpB5P,EAAmB,GAAXA,EAAM,GAAyB,GAAdqB,EAAKiC,QAiBa8M,EAAWV,EAAa,GAC/E9O,SAAUA,GACNF,GAEH8D,EAGP"}