{"version":3,"sources":["jsdelivr-header.js","/npm/spring-easing@2.3.3/lib/index.mjs"],"names":[],"mappings":"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","file":"/npm/spring-easing@2.3.3/lib/index.mjs","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/spring-easing@2.3.3/lib/index.mjs\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","function isNumberLike(num) {\n  const value = parseFloat(num);\n  return typeof value == \"number\" && !Number.isNaN(value);\n}\nfunction limit(value, min, max) {\n  return Math.min(Math.max(value, min), max);\n}\nfunction scale(t, start, end) {\n  return start + (end - start) * t;\n}\nfunction toFixed(value, decimal) {\n  return Math.round(value * 10 ** decimal) / 10 ** decimal;\n}\nfunction getUnit(str) {\n  const num = parseFloat(str);\n  return str.toString().replace(num.toString(), \"\");\n}\nfunction batchInterpolateNumber(arr_t, values, decimal = 3) {\n  const n = values.length - 1;\n  const results = [];\n  let t = 0;\n  let t_index = 0;\n  let len = arr_t.length;\n  for (; t_index < len; t_index++) {\n    t = arr_t[t_index];\n    const i = limit(Math.floor(t * n), 0, n - 1);\n    const start = values[i];\n    const end = values[i + 1];\n    const progress = (t - i / n) * n;\n    results.push(toFixed(scale(progress, start, end), decimal));\n  }\n  return results;\n}\nfunction batchInterpolateSequence(arr_t, values) {\n  const n = values.length - 1;\n  const results = [];\n  let t = 0;\n  let t_index = 0;\n  let len = arr_t.length;\n  for (; t_index < len; t_index++) {\n    t = limit(arr_t[t_index], 0, 1);\n    const i = Math.round(t * n);\n    results.push(values[i]);\n  }\n  return results;\n}\nconst batchInterpolateUsingIndex = batchInterpolateSequence;\nfunction batchInterpolateString(arr_t, values, decimal = 3) {\n  let units = \"\";\n  if (isNumberLike(values[0]))\n    units = getUnit(values[0]);\n  return batchInterpolateNumber(\n    arr_t,\n    values.map((v) => typeof v === \"number\" ? v : parseFloat(v)),\n    decimal\n  ).map((value) => value + units);\n}\nfunction batchInterpolateComplex(arr_t, values, decimal = 3) {\n  let isNumber = true;\n  let isLikeNumber = true;\n  let i = 0;\n  let v;\n  const len = values.length;\n  for (; i < len; i++) {\n    v = values[i];\n    if (isNumber)\n      isNumber = typeof v === \"number\";\n    if (isLikeNumber)\n      isLikeNumber = isNumberLike(v);\n  }\n  if (isNumber)\n    return batchInterpolateNumber(arr_t, values, decimal);\n  if (isLikeNumber)\n    return batchInterpolateString(arr_t, values, decimal);\n  return batchInterpolateSequence(arr_t, values);\n}\nfunction BatchSpringEasing(values, options = {}, customInterpolate = batchInterpolateComplex) {\n  const optionsObj = EasingOptions(options);\n  const [frames, duration] = GenerateSpringFrames(optionsObj);\n  return [\n    customInterpolate == null ? void 0 : customInterpolate(frames, values, optionsObj.decimal),\n    duration\n  ];\n}\nfunction toAnimationFrames(customInterpolate) {\n  return (arr_t, values, decimal) => {\n    return arr_t.map((t) => customInterpolate(t, values, decimal));\n  };\n}\n/*!\n * Based off of https://github.com/jakearchibald/linear-easing-generator\n * \n * Changes:\n * - Added comments and docs top explain logic\n * - Switched to iterative approach for the `ramerDouglasPeucker` algorithim\n * - Renamed functions, parameters and variables to improve readability and to better match a library usecase \n * \n * Copyright 2023 Jake Archibald [@jakearchibald](https://github.com/jakearchibald)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nfunction squaredSegmentDistance(point, lineStart, lineEnd) {\n  let [x, y] = lineStart;\n  let dx = lineEnd[0] - x;\n  let dy = lineEnd[1] - y;\n  if (dx !== 0 || dy !== 0) {\n    let t = ((point[0] - x) * dx + (point[1] - y) * dy) / (dx * dx + dy * dy);\n    if (t > 1) {\n      x = lineEnd[0];\n      y = lineEnd[1];\n    } else if (t > 0) {\n      x += dx * t;\n      y += dy * t;\n    }\n  }\n  dx = point[0] - x;\n  dy = point[1] - y;\n  return dx * dx + dy * dy;\n}\nfunction ramerDouglasPeucker(points, tolerance) {\n  const sqTolerance = tolerance * tolerance;\n  if (points.length < 3)\n    return points;\n  let result = [points[0]];\n  let stack = [[0, points.length - 1]];\n  while (stack.length > 0) {\n    let [start, end] = stack.pop();\n    let maxSqDist = 0;\n    let index = 0;\n    for (let i = start + 1; i < end; i++) {\n      const sqDist = squaredSegmentDistance(points[i], points[start], points[end]);\n      if (sqDist > maxSqDist) {\n        index = i;\n        maxSqDist = sqDist;\n      }\n    }\n    if (maxSqDist > sqTolerance) {\n      stack.push([start, index]);\n      stack.push([index, end]);\n    } else {\n      result.push(points[end]);\n    }\n  }\n  return result.sort((a, b) => a[0] - b[0]);\n}\nfunction getOptimizedPoints(fullPoints, simplify, round) {\n  if (!fullPoints)\n    return null;\n  const xRounding = Math.max(round, 2);\n  return ramerDouglasPeucker(fullPoints, simplify).map(\n    ([x, y]) => [\n      toFixed(x, xRounding),\n      // Round x values\n      toFixed(y, round)\n      // Round y values\n    ]\n  );\n}\n/*!\n * Based off of https://github.com/jakearchibald/linear-easing-generator\n * \n * Changes:\n * - Added comments and docs top explain logic\n * - Switched to iterative approach for the `ramerDouglasPeucker` algorithim\n * - Renamed functions, parameters and variables to improve readability and to better match a library usecase \n * \n * Copyright 2023 Jake Archibald [@jakearchibald](https://github.com/jakearchibald)\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nfunction getLinearSyntax(points, round) {\n  if (!points)\n    return [];\n  const xFormat = new Intl.NumberFormat(\"en-US\", {\n    maximumFractionDigits: Math.max(round - 2, 0)\n  });\n  const yFormat = new Intl.NumberFormat(\"en-US\", {\n    maximumFractionDigits: round\n  });\n  const pointsValue = points;\n  const valuesWithRedundantX = /* @__PURE__ */ new Set();\n  const maxDelta = 1 / 10 ** round;\n  for (const [i, value] of pointsValue.entries()) {\n    const [x] = value;\n    if (i === 0) {\n      if (x === 0)\n        valuesWithRedundantX.add(value);\n      continue;\n    }\n    if (i === pointsValue.length - 1) {\n      const previous2 = pointsValue[i - 1][0];\n      if (x === 1 && previous2 <= 1)\n        valuesWithRedundantX.add(value);\n      continue;\n    }\n    const previous = pointsValue[i - 1][0];\n    const next = pointsValue[i + 1][0];\n    const averagePos = (next - previous) / 2 + previous;\n    const delta = Math.abs(x - averagePos);\n    if (delta < maxDelta)\n      valuesWithRedundantX.add(value);\n  }\n  const groupedValues = [[pointsValue[0]]];\n  for (const value of pointsValue.slice(1)) {\n    if (value[1] === groupedValues.at(-1)[0][1]) {\n      groupedValues.at(-1).push(value);\n    } else {\n      groupedValues.push([value]);\n    }\n  }\n  const outputValues = groupedValues.map((group) => {\n    const yValue = yFormat.format(group[0][1]);\n    const regularValue = group.map((value) => {\n      const [x] = value;\n      let output = yValue;\n      if (!valuesWithRedundantX.has(value)) {\n        output += \" \" + xFormat.format(x * 100) + \"%\";\n      }\n      return output;\n    }).join(\", \");\n    if (group.length === 1)\n      return regularValue;\n    const xVals = [group[0][0], group.at(-1)[0]];\n    const positionalValues = xVals.map((x) => xFormat.format(x * 100) + \"%\").join(\" \");\n    const skipValue = `${yValue} ${positionalValues}`;\n    return skipValue.length > regularValue.length ? regularValue : skipValue;\n  });\n  return outputValues;\n}\nfunction CSSSpringEasing(options = {}) {\n  const optionsObj = EasingOptions(options);\n  const [frames, duration] = GenerateSpringFrames(optionsObj);\n  const quality = limit(optionsObj.quality ?? 0.85, 0, 1);\n  const simplify = scale(1 - quality, 0, 0.025);\n  const len = frames.length;\n  const pts = frames.map((x, i) => [i / (len - 1), x]);\n  const optimizedPoints = getOptimizedPoints(pts, simplify, optionsObj.decimal);\n  return [\n    getLinearSyntax(optimizedPoints, optionsObj.decimal).join(\", \"),\n    duration\n  ];\n}\n/*!\n * Spring solver inspired by Webkit Copyright © 2016 Apple Inc. All rights reserved. https://webkit.org/demos/spring/spring.js\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions\n * are met:\n * 1. Redistributions of source code must retain the above copyright\n *    notice, this list of conditions and the following disclaimer.\n * 2. Redistributions in binary form must reproduce the above copyright\n *    notice, this list of conditions and the following disclaimer in the\n *    documentation and/or other materials provided with the distribution.\n *\n * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,\n * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR\n * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS\n * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\n * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF\n * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS\n * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN\n * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)\n * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF\n * THE POSSIBILITY OF SUCH DAMAGE.\n*/\nconst SpringFrame = (t, [mass = 1, stiffness = 100, damping = 10, velocity = 0] = [], duration) => {\n  mass = limit(mass, 1e-4, 1e3);\n  stiffness = limit(stiffness, 1e-4, 1e3);\n  damping = limit(damping, 1e-4, 1e3);\n  velocity = limit(velocity, 1e-4, 1e3);\n  const w0 = Math.sqrt(stiffness / mass);\n  const zeta = damping / (2 * Math.sqrt(stiffness * mass));\n  const wd = zeta < 1 ? w0 * Math.sqrt(1 - zeta * zeta) : 0;\n  const b = zeta < 1 ? (zeta * w0 + -velocity) / wd : -velocity + w0;\n  let position = duration ? duration * t / 1e3 : t;\n  if (zeta < 1) {\n    position = Math.exp(-position * zeta * w0) * (Math.cos(wd * position) + b * Math.sin(wd * position));\n  } else {\n    position = (1 + b * position) * Math.exp(-position * w0);\n  }\n  return 1 - position;\n};\nconst EasingDurationCache = /* @__PURE__ */ new Map();\nconst INFINITE_LOOP_LIMIT = 1e5;\nfunction getSpringDuration([mass, stiffness, damping, velocity] = []) {\n  let params = [mass, stiffness, damping, velocity];\n  let easing = `${params}`;\n  if (EasingDurationCache.has(easing))\n    return EasingDurationCache.get(easing);\n  const step = 1 / 6;\n  let time = 0;\n  let numPoints = 0;\n  while (++numPoints < INFINITE_LOOP_LIMIT) {\n    if (Math.abs(1 - SpringFrame(time, params)) < 1e-3) {\n      let restStart = time;\n      let restSteps = 1;\n      while (++numPoints < INFINITE_LOOP_LIMIT) {\n        time += step;\n        if (Math.abs(1 - SpringFrame(time, params)) >= 1e-3)\n          break;\n        restSteps++;\n        if (restSteps === 16) {\n          const duration2 = restStart * 1e3;\n          EasingDurationCache.set(easing, [duration2, numPoints]);\n          return [duration2, numPoints];\n        }\n      }\n    }\n    time += step;\n  }\n  const duration = time * 1e3;\n  EasingDurationCache.set(easing, [duration, numPoints]);\n  return [duration, numPoints];\n}\nfunction EaseOut(frame) {\n  return (t, params = [], duration) => 1 - frame(1 - t, params, duration);\n}\nfunction EaseInOut(frame) {\n  return function(t, params = [], duration) {\n    return t < 0.5 ? frame(t * 2, params, duration) / 2 : 1 - frame(t * -2 + 2, params, duration) / 2;\n  };\n}\nfunction EaseOutIn(frame) {\n  return function(t, params = [], duration) {\n    return t < 0.5 ? (1 - frame(1 - t * 2, params, duration)) / 2 : (frame(t * 2 - 1, params, duration) + 1) / 2;\n  };\n}\nconst SpringInFrame = SpringFrame;\nconst SpringOutFrame = EaseOut(SpringFrame);\nconst SpringInOutFrame = EaseInOut(SpringFrame);\nconst SpringOutInFrame = EaseOutIn(SpringFrame);\nfunction interpolateNumber(t, values, decimal = 3) {\n  const n = values.length - 1;\n  const i = limit(Math.floor(t * n), 0, n - 1);\n  const start = values[i];\n  const end = values[i + 1];\n  const progress = (t - i / n) * n;\n  return toFixed(scale(progress, start, end), decimal);\n}\nfunction interpolateSequence(t, values) {\n  const n = values.length - 1;\n  t = limit(t, 0, 1);\n  const i = Math.round(t * n);\n  return values[i];\n}\nconst interpolateUsingIndex = interpolateSequence;\nfunction interpolateString(t, values, decimal = 3) {\n  let units = \"\";\n  if (isNumberLike(values[0]))\n    units = getUnit(values[0]);\n  return interpolateNumber(\n    t,\n    values.map((v) => typeof v === \"number\" ? v : parseFloat(v)),\n    decimal\n  ) + units;\n}\nfunction interpolateComplex(t, values, decimal = 3) {\n  const isNumber = values.every((v) => typeof v === \"number\");\n  if (isNumber)\n    return interpolateNumber(t, values, decimal);\n  const isLikeNumber = values.every((v) => isNumberLike(v));\n  if (isLikeNumber)\n    return interpolateString(t, values, decimal);\n  return interpolateSequence(t, values);\n}\nlet EasingFunctions = {\n  spring: SpringFrame,\n  \"spring-in\": SpringInFrame,\n  \"spring-out\": SpringOutFrame,\n  \"spring-in-out\": SpringInOutFrame,\n  \"spring-out-in\": SpringOutInFrame\n};\nlet EasingFunctionKeys = Object.keys(EasingFunctions);\nfunction registerEasingFunction(key, fn) {\n  EasingFunctions = { ...EasingFunctions, [key]: fn };\n  EasingFunctionKeys = Object.keys(EasingFunctions);\n}\nfunction registerEasingFunctions(obj) {\n  EasingFunctions = { ...EasingFunctions, ...obj };\n  EasingFunctionKeys = Object.keys(EasingFunctions);\n}\nfunction parseEasingParameters(str) {\n  const match = /(\\(|\\s)([^)]+)\\)?/.exec(str.toString());\n  return match ? match[2].split(\",\").map((value) => {\n    let num = parseFloat(value);\n    return !Number.isNaN(num) ? num : value.trim();\n  }) : [];\n}\nfunction EasingOptions(options = {}) {\n  const isEasing = typeof options === \"string\" || Array.isArray(options) && typeof options[0] === \"function\";\n  let {\n    easing = [SpringFrame, 1, 100, 10, 0],\n    numPoints = 38,\n    decimal = 3,\n    ...rest\n  } = isEasing ? { easing: options } : options;\n  if (typeof easing === \"string\") {\n    const frameFunction = EasingFunctions[easing.replace(/(\\(|\\s).+/, \"\").toLowerCase().trim()];\n    const params = parseEasingParameters(easing);\n    easing = [frameFunction, ...params];\n  }\n  return { easing, numPoints, decimal, ...rest };\n}\nconst FramePtsCache = /* @__PURE__ */ new Map();\nfunction GenerateSpringFrames(options = {}) {\n  let {\n    easing,\n    numPoints\n  } = EasingOptions(options);\n  if (Array.isArray(easing)) {\n    if (typeof easing[0] != \"function\") {\n      throw new Error(\n        \"[spring-easing] A frame function is required as the first element in the easing array, e.g. [SpringFrame, ...]\"\n      );\n    }\n  } else {\n    throw new Error(\n      `[spring-easing] The easing needs to be in the format:  \n* \"spring-out(mass, stiffness, damping, velocity)\" or \n* [SpringOutFrame, mass, stiffness, damping, velocity], the easing recieved is \"${easing}\", [spring-easing] doesn't really know what to do with that.`\n    );\n  }\n  let [frameFunction, ...params] = easing;\n  const [idealDuration, idealNumPoints = 38] = getSpringDuration(params);\n  if (!numPoints)\n    numPoints = idealNumPoints;\n  const key = `${params},${numPoints}`;\n  if (FramePtsCache.has(key)) {\n    let tempObj2 = FramePtsCache.get(key);\n    if (tempObj2.has(frameFunction))\n      return tempObj2.get(frameFunction);\n  }\n  const points = [];\n  for (let i = 0; i < numPoints; i++) {\n    points[i] = frameFunction(i / (numPoints - 1), params, idealDuration);\n  }\n  const tempObj = FramePtsCache.has(key) ? FramePtsCache.get(key) : /* @__PURE__ */ new WeakMap();\n  tempObj.set(frameFunction, [points, idealDuration]);\n  FramePtsCache.set(key, tempObj);\n  return [points, idealDuration];\n}\nfunction SpringEasing(values, options = {}, customInterpolate = interpolateComplex) {\n  const optionsObj = EasingOptions(options);\n  const [frames, duration] = GenerateSpringFrames(optionsObj);\n  return [\n    frames.map((t) => customInterpolate(t, values, optionsObj.decimal)),\n    duration\n  ];\n}\nexport {\n  BatchSpringEasing,\n  CSSSpringEasing,\n  EaseInOut,\n  EaseOut,\n  EaseOutIn,\n  EasingDurationCache,\n  EasingFunctionKeys,\n  EasingFunctions,\n  EasingOptions,\n  FramePtsCache,\n  GenerateSpringFrames,\n  INFINITE_LOOP_LIMIT,\n  SpringEasing,\n  SpringFrame,\n  SpringInFrame,\n  SpringInOutFrame,\n  SpringOutFrame,\n  SpringOutInFrame,\n  batchInterpolateComplex,\n  batchInterpolateNumber,\n  batchInterpolateSequence,\n  batchInterpolateString,\n  batchInterpolateUsingIndex,\n  SpringEasing as default,\n  getLinearSyntax,\n  getOptimizedPoints,\n  getSpringDuration,\n  getUnit,\n  interpolateComplex,\n  interpolateNumber,\n  interpolateSequence,\n  interpolateString,\n  interpolateUsingIndex,\n  isNumberLike,\n  limit,\n  parseEasingParameters,\n  ramerDouglasPeucker,\n  registerEasingFunction,\n  registerEasingFunctions,\n  scale,\n  squaredSegmentDistance,\n  toAnimationFrames,\n  toFixed\n};\n"]}