react-native-skia 0.0.1 → 2.15.0

package/lib/module/animation/functions/interpolate.js

@@ -0,0 +1,123 @@
+export let Extrapolate = /*#__PURE__*/function (Extrapolate) {
+  Extrapolate["IDENTITY"] = "identity";
+  Extrapolate["CLAMP"] = "clamp";
+  Extrapolate["EXTEND"] = "extend";
+  return Extrapolate;
+}({});
+function getVal(type, coef, val, leftEdgeOutput, rightEdgeOutput, x) {
+  "worklet";
+
+  switch (type) {
+    case Extrapolate.IDENTITY:
+      return x;
+    case Extrapolate.CLAMP:
+      if (coef * val < coef * leftEdgeOutput) {
+        return leftEdgeOutput;
+      }
+      return rightEdgeOutput;
+    case Extrapolate.EXTEND:
+    default:
+      return val;
+  }
+}
+function isExtrapolate(value) {
+  "worklet";
+
+  return value === Extrapolate.EXTEND || value === Extrapolate.CLAMP || value === Extrapolate.IDENTITY;
+}
+
+// validates extrapolations type
+// if type is correct, converts it to ExtrapolationConfig
+export function validateInterpolationOptions(type) {
+  "worklet";
+
+  // initialize extrapolationConfig with default extrapolation
+  const extrapolationConfig = {
+    extrapolateLeft: Extrapolate.EXTEND,
+    extrapolateRight: Extrapolate.EXTEND
+  };
+  if (!type) {
+    return extrapolationConfig;
+  }
+  if (typeof type === "string") {
+    if (!isExtrapolate(type)) {
+      throw new Error(`No supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
+        interpolate(value, [inputRange], [outputRange], "clamp")`);
+    }
+    extrapolationConfig.extrapolateLeft = type;
+    extrapolationConfig.extrapolateRight = type;
+    return extrapolationConfig;
+  }
+
+  // otherwise type is extrapolation config object
+  if (type.extrapolateLeft && !isExtrapolate(type.extrapolateLeft) || type.extrapolateRight && !isExtrapolate(type.extrapolateRight)) {
+    throw new Error(`No supported value for "interpolate" \nSupported values: ["extend", "clamp", "identity", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\n Valid example:
+      interpolate(value, [inputRange], [outputRange], {
+        extrapolateLeft: Extrapolation.CLAMP,
+        extrapolateRight: Extrapolation.IDENTITY
+      }})`);
+  }
+  Object.assign(extrapolationConfig, type);
+  return extrapolationConfig;
+}
+function internalInterpolate(x, narrowedInput, extrapolationConfig) {
+  "worklet";
+
+  const {
+    leftEdgeInput,
+    rightEdgeInput,
+    leftEdgeOutput,
+    rightEdgeOutput
+  } = narrowedInput;
+  if (rightEdgeInput - leftEdgeInput === 0) {
+    return leftEdgeOutput;
+  }
+  const progress = (x - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);
+  const val = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput);
+  const coef = rightEdgeOutput >= leftEdgeOutput ? 1 : -1;
+  if (coef * val < coef * leftEdgeOutput) {
+    return getVal(extrapolationConfig.extrapolateLeft, coef, val, leftEdgeOutput, rightEdgeOutput, x);
+  } else if (coef * val > coef * rightEdgeOutput) {
+    return getVal(extrapolationConfig.extrapolateRight, coef, val, leftEdgeOutput, rightEdgeOutput, x);
+  }
+  return val;
+}
+
+// e.g. function interpolate(x, input, output, type = Extrapolatation.CLAMP)
+export function interpolate(x, input, output, type) {
+  "worklet";
+
+  if (input.length < 2 || output.length < 2) {
+    throw Error("Interpolation input and output should contain at least two values.");
+  }
+  const extrapolationConfig = validateInterpolationOptions(type);
+  const {
+    length
+  } = input;
+  const narrowedInput = {
+    leftEdgeInput: input[0],
+    rightEdgeInput: input[1],
+    leftEdgeOutput: output[0],
+    rightEdgeOutput: output[1]
+  };
+  if (length > 2) {
+    if (x > input[length - 1]) {
+      narrowedInput.leftEdgeInput = input[length - 2];
+      narrowedInput.rightEdgeInput = input[length - 1];
+      narrowedInput.leftEdgeOutput = output[length - 2];
+      narrowedInput.rightEdgeOutput = output[length - 1];
+    } else {
+      for (let i = 1; i < length; ++i) {
+        if (x <= input[i]) {
+          narrowedInput.leftEdgeInput = input[i - 1];
+          narrowedInput.rightEdgeInput = input[i];
+          narrowedInput.leftEdgeOutput = output[i - 1];
+          narrowedInput.rightEdgeOutput = output[i];
+          break;
+        }
+      }
+    }
+  }
+  return internalInterpolate(x, narrowedInput, extrapolationConfig);
+}
+//# sourceMappingURL=interpolate.js.map

package/lib/module/animation/functions/interpolate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Extrapolate","getVal","type","coef","val","leftEdgeOutput","rightEdgeOutput","x","IDENTITY","CLAMP","EXTEND","isExtrapolate","value","validateInterpolationOptions","extrapolationConfig","extrapolateLeft","extrapolateRight","Error","Object","assign","internalInterpolate","narrowedInput","leftEdgeInput","rightEdgeInput","progress","interpolate","input","output","length","i"],"sources":["interpolate.ts"],"sourcesContent":["export enum Extrapolate {\n  IDENTITY = \"identity\",\n  CLAMP = \"clamp\",\n  EXTEND = \"extend\",\n}\n\ninterface InterpolationNarrowedInput {\n  leftEdgeInput: number;\n  rightEdgeInput: number;\n  leftEdgeOutput: number;\n  rightEdgeOutput: number;\n}\n\nexport interface ExtrapolationConfig {\n  extrapolateLeft?: Extrapolate | string;\n  extrapolateRight?: Extrapolate | string;\n}\n\ninterface RequiredExtrapolationConfig {\n  extrapolateLeft: Extrapolate;\n  extrapolateRight: Extrapolate;\n}\n\nexport type ExtrapolationType =\n  ExtrapolationConfig | Extrapolate | string | undefined;\n\nfunction getVal(\n  type: Extrapolate,\n  coef: number,\n  val: number,\n  leftEdgeOutput: number,\n  rightEdgeOutput: number,\n  x: number\n): number {\n  \"worklet\";\n  switch (type) {\n    case Extrapolate.IDENTITY:\n      return x;\n    case Extrapolate.CLAMP:\n      if (coef * val < coef * leftEdgeOutput) {\n        return leftEdgeOutput;\n      }\n      return rightEdgeOutput;\n    case Extrapolate.EXTEND:\n    default:\n      return val;\n  }\n}\n\nfunction isExtrapolate(value: string): value is Extrapolate {\n  \"worklet\";\n  return (\n    value === Extrapolate.EXTEND ||\n    value === Extrapolate.CLAMP ||\n    value === Extrapolate.IDENTITY\n  );\n}\n\n// validates extrapolations type\n// if type is correct, converts it to ExtrapolationConfig\nexport function validateInterpolationOptions(\n  type: ExtrapolationType\n): RequiredExtrapolationConfig {\n  \"worklet\";\n  // initialize extrapolationConfig with default extrapolation\n  const extrapolationConfig: RequiredExtrapolationConfig = {\n    extrapolateLeft: Extrapolate.EXTEND,\n    extrapolateRight: Extrapolate.EXTEND,\n  };\n\n  if (!type) {\n    return extrapolationConfig;\n  }\n\n  if (typeof type === \"string\") {\n    if (!isExtrapolate(type)) {\n      throw new Error(\n        `No supported value for \"interpolate\" \\nSupported values: [\"extend\", \"clamp\", \"identity\", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\\n Valid example:\n        interpolate(value, [inputRange], [outputRange], \"clamp\")`\n      );\n    }\n    extrapolationConfig.extrapolateLeft = type;\n    extrapolationConfig.extrapolateRight = type;\n    return extrapolationConfig;\n  }\n\n  // otherwise type is extrapolation config object\n  if (\n    (type.extrapolateLeft && !isExtrapolate(type.extrapolateLeft)) ||\n    (type.extrapolateRight && !isExtrapolate(type.extrapolateRight))\n  ) {\n    throw new Error(\n      `No supported value for \"interpolate\" \\nSupported values: [\"extend\", \"clamp\", \"identity\", Extrapolatation.CLAMP, Extrapolatation.EXTEND, Extrapolatation.IDENTITY]\\n Valid example:\n      interpolate(value, [inputRange], [outputRange], {\n        extrapolateLeft: Extrapolation.CLAMP,\n        extrapolateRight: Extrapolation.IDENTITY\n      }})`\n    );\n  }\n\n  Object.assign(extrapolationConfig, type);\n  return extrapolationConfig;\n}\n\nfunction internalInterpolate(\n  x: number,\n  narrowedInput: InterpolationNarrowedInput,\n  extrapolationConfig: RequiredExtrapolationConfig\n) {\n  \"worklet\";\n  const { leftEdgeInput, rightEdgeInput, leftEdgeOutput, rightEdgeOutput } =\n    narrowedInput;\n  if (rightEdgeInput - leftEdgeInput === 0) {\n    return leftEdgeOutput;\n  }\n  const progress = (x - leftEdgeInput) / (rightEdgeInput - leftEdgeInput);\n  const val = leftEdgeOutput + progress * (rightEdgeOutput - leftEdgeOutput);\n  const coef = rightEdgeOutput >= leftEdgeOutput ? 1 : -1;\n\n  if (coef * val < coef * leftEdgeOutput) {\n    return getVal(\n      extrapolationConfig.extrapolateLeft,\n      coef,\n      val,\n      leftEdgeOutput,\n      rightEdgeOutput,\n      x\n    );\n  } else if (coef * val > coef * rightEdgeOutput) {\n    return getVal(\n      extrapolationConfig.extrapolateRight,\n      coef,\n      val,\n      leftEdgeOutput,\n      rightEdgeOutput,\n      x\n    );\n  }\n\n  return val;\n}\n\n// e.g. function interpolate(x, input, output, type = Extrapolatation.CLAMP)\nexport function interpolate(\n  x: number,\n  input: readonly number[],\n  output: readonly number[],\n  type?: ExtrapolationType\n): number {\n  \"worklet\";\n  if (input.length < 2 || output.length < 2) {\n    throw Error(\n      \"Interpolation input and output should contain at least two values.\"\n    );\n  }\n\n  const extrapolationConfig = validateInterpolationOptions(type);\n  const { length } = input;\n  const narrowedInput: InterpolationNarrowedInput = {\n    leftEdgeInput: input[0],\n    rightEdgeInput: input[1],\n    leftEdgeOutput: output[0],\n    rightEdgeOutput: output[1],\n  };\n  if (length > 2) {\n    if (x > input[length - 1]) {\n      narrowedInput.leftEdgeInput = input[length - 2];\n      narrowedInput.rightEdgeInput = input[length - 1];\n      narrowedInput.leftEdgeOutput = output[length - 2];\n      narrowedInput.rightEdgeOutput = output[length - 1];\n    } else {\n      for (let i = 1; i < length; ++i) {\n        if (x <= input[i]) {\n          narrowedInput.leftEdgeInput = input[i - 1];\n          narrowedInput.rightEdgeInput = input[i];\n          narrowedInput.leftEdgeOutput = output[i - 1];\n          narrowedInput.rightEdgeOutput = output[i];\n          break;\n        }\n      }\n    }\n  }\n\n  return internalInterpolate(x, narrowedInput, extrapolationConfig);\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/module/animation/functions/interpolateColors.d.ts

@@ -0,0 +1,3 @@
+import type { Color } from "../../skia";
+export declare const interpolateColors: (value: number, inputRange: number[], _outputRange: Color[]) => number[];
+export declare const mixColors: (value: number, x: Color, y: Color) => Float32Array<ArrayBuffer>;

package/lib/module/animation/functions/interpolateColors.js

@@ -0,0 +1,27 @@
+import { mix } from "../../renderer/processors/math";
+import { Skia } from "../../skia";
+import { interpolate } from "./interpolate";
+const interpolateColorsRGB = (value, inputRange, outputRange) => {
+  "worklet";
+
+  const r = interpolate(value, inputRange, outputRange.map(c => c[0]), "clamp");
+  const g = interpolate(value, inputRange, outputRange.map(c => c[1]), "clamp");
+  const b = interpolate(value, inputRange, outputRange.map(c => c[2]), "clamp");
+  const a = interpolate(value, inputRange, outputRange.map(c => c[3]), "clamp");
+  // TODO: once Float32Array are supported in the reanimated integration we can switch there
+  return [r, g, b, a];
+};
+export const interpolateColors = (value, inputRange, _outputRange) => {
+  "worklet";
+
+  const outputRange = _outputRange.map(cl => Skia.Color(cl));
+  return interpolateColorsRGB(value, inputRange, outputRange);
+};
+export const mixColors = (value, x, y) => {
+  "worklet";
+
+  const c1 = Skia.Color(x);
+  const c2 = Skia.Color(y);
+  return new Float32Array([mix(value, c1[0], c2[0]), mix(value, c1[1], c2[1]), mix(value, c1[2], c2[2]), mix(value, c1[3], c2[3])]);
+};
+//# sourceMappingURL=interpolateColors.js.map

package/lib/module/animation/functions/interpolateColors.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["mix","Skia","interpolate","interpolateColorsRGB","value","inputRange","outputRange","r","map","c","g","b","a","interpolateColors","_outputRange","cl","Color","mixColors","x","y","c1","c2","Float32Array"],"sources":["interpolateColors.ts"],"sourcesContent":["import { mix } from \"../../renderer/processors/math\";\nimport type { Color, SkColor } from \"../../skia\";\nimport { Skia } from \"../../skia\";\n\nimport { interpolate } from \"./interpolate\";\n\nconst interpolateColorsRGB = (\n  value: number,\n  inputRange: number[],\n  outputRange: SkColor[]\n) => {\n  \"worklet\";\n  const r = interpolate(\n    value,\n    inputRange,\n    outputRange.map((c) => c[0]),\n    \"clamp\"\n  );\n  const g = interpolate(\n    value,\n    inputRange,\n    outputRange.map((c) => c[1]),\n    \"clamp\"\n  );\n  const b = interpolate(\n    value,\n    inputRange,\n    outputRange.map((c) => c[2]),\n    \"clamp\"\n  );\n  const a = interpolate(\n    value,\n    inputRange,\n    outputRange.map((c) => c[3]),\n    \"clamp\"\n  );\n  // TODO: once Float32Array are supported in the reanimated integration we can switch there\n  return [r, g, b, a];\n};\n\nexport const interpolateColors = (\n  value: number,\n  inputRange: number[],\n  _outputRange: Color[]\n) => {\n  \"worklet\";\n  const outputRange = _outputRange.map((cl) => Skia.Color(cl));\n  return interpolateColorsRGB(value, inputRange, outputRange);\n};\n\nexport const mixColors = (value: number, x: Color, y: Color) => {\n  \"worklet\";\n  const c1 = Skia.Color(x);\n  const c2 = Skia.Color(y);\n  return new Float32Array([\n    mix(value, c1[0], c2[0]),\n    mix(value, c1[1], c2[1]),\n    mix(value, c1[2], c2[2]),\n    mix(value, c1[3], c2[3]),\n  ]);\n};\n"],"mappings":"AAAA,SAASA,GAAG,QAAQ,gCAAgC;AAEpD,SAASC,IAAI,QAAQ,YAAY;AAEjC,SAASC,WAAW,QAAQ,eAAe;AAE3C,MAAMC,oBAAoB,GAAGA,CAC3BC,KAAa,EACbC,UAAoB,EACpBC,WAAsB,KACnB;EACH,SAAS;;EACT,MAAMC,CAAC,GAAGL,WAAW,CACnBE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACE,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAAC,CAAC,CAAC,CAAC,EAC5B,OACF,CAAC;EACD,MAAMC,CAAC,GAAGR,WAAW,CACnBE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACE,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAAC,CAAC,CAAC,CAAC,EAC5B,OACF,CAAC;EACD,MAAME,CAAC,GAAGT,WAAW,CACnBE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACE,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAAC,CAAC,CAAC,CAAC,EAC5B,OACF,CAAC;EACD,MAAMG,CAAC,GAAGV,WAAW,CACnBE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACE,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAAC,CAAC,CAAC,CAAC,EAC5B,OACF,CAAC;EACD;EACA,OAAO,CAACF,CAAC,EAAEG,CAAC,EAAEC,CAAC,EAAEC,CAAC,CAAC;AACrB,CAAC;AAED,OAAO,MAAMC,iBAAiB,GAAGA,CAC/BT,KAAa,EACbC,UAAoB,EACpBS,YAAqB,KAClB;EACH,SAAS;;EACT,MAAMR,WAAW,GAAGQ,YAAY,CAACN,GAAG,CAAEO,EAAE,IAAKd,IAAI,CAACe,KAAK,CAACD,EAAE,CAAC,CAAC;EAC5D,OAAOZ,oBAAoB,CAACC,KAAK,EAAEC,UAAU,EAAEC,WAAW,CAAC;AAC7D,CAAC;AAED,OAAO,MAAMW,SAAS,GAAGA,CAACb,KAAa,EAAEc,CAAQ,EAAEC,CAAQ,KAAK;EAC9D,SAAS;;EACT,MAAMC,EAAE,GAAGnB,IAAI,CAACe,KAAK,CAACE,CAAC,CAAC;EACxB,MAAMG,EAAE,GAAGpB,IAAI,CAACe,KAAK,CAACG,CAAC,CAAC;EACxB,OAAO,IAAIG,YAAY,CAAC,CACtBtB,GAAG,CAACI,KAAK,EAAEgB,EAAE,CAAC,CAAC,CAAC,EAAEC,EAAE,CAAC,CAAC,CAAC,CAAC,EACxBrB,GAAG,CAACI,KAAK,EAAEgB,EAAE,CAAC,CAAC,CAAC,EAAEC,EAAE,CAAC,CAAC,CAAC,CAAC,EACxBrB,GAAG,CAACI,KAAK,EAAEgB,EAAE,CAAC,CAAC,CAAC,EAAEC,EAAE,CAAC,CAAC,CAAC,CAAC,EACxBrB,GAAG,CAACI,KAAK,EAAEgB,EAAE,CAAC,CAAC,CAAC,EAAEC,EAAE,CAAC,CAAC,CAAC,CAAC,CACzB,CAAC;AACJ,CAAC","ignoreList":[]}

package/lib/module/animation/functions/interpolatePaths.d.ts

@@ -0,0 +1,19 @@
+import type { SkPath } from "../../skia/types";
+import type { ExtrapolationType } from "./interpolate";
+/**
+ * Maps an input value within a range to an output path within a path range.
+ * @param value - The input value.
+ * @param inputRange - The range of the input value.
+ * @param outputRange - The range of the output path.
+ * @param options - Extrapolation options
+ * @returns The output path.
+ * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>
+ * const path1 = new Path();
+ * path1.moveTo(0, 0);
+ * path1.lineTo(100, 0);
+ * const path2 = new Path();
+ * path2.moveTo(0, 0);
+ * path2.lineTo(0, 100);
+ * const path = interpolatePath(0.5, [0, 1], [path1, path2]);
+ */
+export declare const interpolatePaths: (value: number, input: number[], outputRange: SkPath[], options?: ExtrapolationType, _output?: SkPath) => SkPath;

package/lib/module/animation/functions/interpolatePaths.js

@@ -0,0 +1,80 @@
+import { exhaustiveCheck } from "../../renderer/typeddash";
+import { validateInterpolationOptions, Extrapolate } from "./interpolate";
+const lerp = (value, from, to, p1, p2) => {
+  "worklet";
+
+  // Zero-width segment (duplicate input stops): t would be NaN or Infinity.
+  // Return the segment's end path (p2), i.e. the value jumps to p2 at the stop.
+  // reanimated's interpolate has no explicit guard here, so this is our choice.
+  if (to === from) {
+    return p2;
+  }
+  const t = (value - from) / (to - from);
+  // interpolate returns a new path (immutable operation)
+  return p2.interpolate(p1, t);
+};
+
+/**
+ * Maps an input value within a range to an output path within a path range.
+ * @param value - The input value.
+ * @param inputRange - The range of the input value.
+ * @param outputRange - The range of the output path.
+ * @param options - Extrapolation options
+ * @returns The output path.
+ * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>
+ * const path1 = new Path();
+ * path1.moveTo(0, 0);
+ * path1.lineTo(100, 0);
+ * const path2 = new Path();
+ * path2.moveTo(0, 0);
+ * path2.lineTo(0, 100);
+ * const path = interpolatePath(0.5, [0, 1], [path1, path2]);
+ */
+export const interpolatePaths = (value, input, outputRange, options, _output) => {
+  "worklet";
+
+  if (input.length < 2 || input.length !== outputRange.length) {
+    throw new Error(`interpolatePaths() requires input and outputRange to have the same length and at least 2 entries, received ${input.length} and ${outputRange.length}`);
+  }
+  if (Number.isNaN(value)) {
+    throw new Error("interpolatePaths() received NaN as value");
+  }
+  const extrapolation = validateInterpolationOptions(options);
+  if (value < input[0]) {
+    switch (extrapolation.extrapolateLeft) {
+      case Extrapolate.CLAMP:
+        return outputRange[0];
+      case Extrapolate.EXTEND:
+        if (!Number.isFinite(value)) {
+          throw new Error("interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead");
+        }
+        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);
+      case Extrapolate.IDENTITY:
+        throw new Error("Identity is not a supported extrapolation type for interpolatePaths()");
+      default:
+        exhaustiveCheck(extrapolation.extrapolateLeft);
+    }
+  } else if (value > input[input.length - 1]) {
+    switch (extrapolation.extrapolateRight) {
+      case Extrapolate.CLAMP:
+        return outputRange[outputRange.length - 1];
+      case Extrapolate.EXTEND:
+        if (!Number.isFinite(value)) {
+          throw new Error("interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead");
+        }
+        return lerp(value, input[input.length - 2], input[input.length - 1], outputRange[input.length - 2], outputRange[input.length - 1]);
+      case Extrapolate.IDENTITY:
+        throw new Error("Identity is not a supported extrapolation type for interpolatePaths()");
+      default:
+        exhaustiveCheck(extrapolation.extrapolateRight);
+    }
+  }
+  let i = 0;
+  for (; i <= input.length - 1; i++) {
+    if (value >= input[i] && value <= input[i + 1]) {
+      break;
+    }
+  }
+  return lerp(value, input[i], input[i + 1], outputRange[i], outputRange[i + 1]);
+};
+//# sourceMappingURL=interpolatePaths.js.map

package/lib/module/animation/functions/interpolatePaths.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exhaustiveCheck","validateInterpolationOptions","Extrapolate","lerp","value","from","to","p1","p2","t","interpolate","interpolatePaths","input","outputRange","options","_output","length","Error","Number","isNaN","extrapolation","extrapolateLeft","CLAMP","EXTEND","isFinite","IDENTITY","extrapolateRight","i"],"sources":["interpolatePaths.ts"],"sourcesContent":["import type { SkPath } from \"../../skia/types\";\nimport { exhaustiveCheck } from \"../../renderer/typeddash\";\n\nimport type { ExtrapolationType } from \"./interpolate\";\nimport { validateInterpolationOptions, Extrapolate } from \"./interpolate\";\n\nconst lerp = (\n  value: number,\n  from: number,\n  to: number,\n  p1: SkPath,\n  p2: SkPath\n) => {\n  \"worklet\";\n  // Zero-width segment (duplicate input stops): t would be NaN or Infinity.\n  // Return the segment's end path (p2), i.e. the value jumps to p2 at the stop.\n  // reanimated's interpolate has no explicit guard here, so this is our choice.\n  if (to === from) {\n    return p2;\n  }\n  const t = (value - from) / (to - from);\n  // interpolate returns a new path (immutable operation)\n  return p2.interpolate(p1, t)!;\n};\n\n/**\n * Maps an input value within a range to an output path within a path range.\n * @param value - The input value.\n * @param inputRange - The range of the input value.\n * @param outputRange - The range of the output path.\n * @param options - Extrapolation options\n * @returns The output path.\n * @example <caption>Map a value between 0 and 1 to a path between two paths.</caption>\n * const path1 = new Path();\n * path1.moveTo(0, 0);\n * path1.lineTo(100, 0);\n * const path2 = new Path();\n * path2.moveTo(0, 0);\n * path2.lineTo(0, 100);\n * const path = interpolatePath(0.5, [0, 1], [path1, path2]);\n */\nexport const interpolatePaths = (\n  value: number,\n  input: number[],\n  outputRange: SkPath[],\n  options?: ExtrapolationType,\n  _output?: SkPath\n) => {\n  \"worklet\";\n  if (input.length < 2 || input.length !== outputRange.length) {\n    throw new Error(\n      `interpolatePaths() requires input and outputRange to have the same length and at least 2 entries, received ${input.length} and ${outputRange.length}`\n    );\n  }\n  if (Number.isNaN(value)) {\n    throw new Error(\"interpolatePaths() received NaN as value\");\n  }\n  const extrapolation = validateInterpolationOptions(options);\n  if (value < input[0]) {\n    switch (extrapolation.extrapolateLeft) {\n      case Extrapolate.CLAMP:\n        return outputRange[0];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(value, input[0], input[1], outputRange[0], outputRange[1]);\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateLeft);\n    }\n  } else if (value > input[input.length - 1]) {\n    switch (extrapolation.extrapolateRight) {\n      case Extrapolate.CLAMP:\n        return outputRange[outputRange.length - 1];\n      case Extrapolate.EXTEND:\n        if (!Number.isFinite(value)) {\n          throw new Error(\n            \"interpolatePaths() cannot extend with an infinite value, use clamp extrapolation instead\"\n          );\n        }\n        return lerp(\n          value,\n          input[input.length - 2],\n          input[input.length - 1],\n          outputRange[input.length - 2],\n          outputRange[input.length - 1]\n        );\n      case Extrapolate.IDENTITY:\n        throw new Error(\n          \"Identity is not a supported extrapolation type for interpolatePaths()\"\n        );\n      default:\n        exhaustiveCheck(extrapolation.extrapolateRight);\n    }\n  }\n  let i = 0;\n  for (; i <= input.length - 1; i++) {\n    if (value >= input[i] && value <= input[i + 1]) {\n      break;\n    }\n  }\n  return lerp(\n    value,\n    input[i],\n    input[i + 1],\n    outputRange[i],\n    outputRange[i + 1]\n  );\n};\n"],"mappings":"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","ignoreList":[]}

package/lib/module/animation/functions/interpolateVector.d.ts

@@ -0,0 +1,10 @@
+import type { Vector } from "../../skia/types";
+import { interpolate } from "./interpolate";
+export declare const interpolateVector: (value: number, inputRange: readonly number[], outputRange: readonly Vector[], options?: Parameters<typeof interpolate>[3]) => {
+    x: number;
+    y: number;
+};
+export declare const mixVector: (value: number, from: Vector, to: Vector) => {
+    x: number;
+    y: number;
+};

package/lib/module/animation/functions/interpolateVector.js

@@ -0,0 +1,15 @@
+import { interpolate } from "./interpolate";
+export const interpolateVector = (value, inputRange, outputRange, options) => {
+  "worklet";
+
+  return {
+    x: interpolate(value, inputRange, outputRange.map(v => v.x), options),
+    y: interpolate(value, inputRange, outputRange.map(v => v.y), options)
+  };
+};
+export const mixVector = (value, from, to) => {
+  "worklet";
+
+  return interpolateVector(value, [0, 1], [from, to]);
+};
+//# sourceMappingURL=interpolateVector.js.map

package/lib/module/animation/functions/interpolateVector.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["interpolate","interpolateVector","value","inputRange","outputRange","options","x","map","v","y","mixVector","from","to"],"sources":["interpolateVector.ts"],"sourcesContent":["import type { Vector } from \"../../skia/types\";\n\nimport { interpolate } from \"./interpolate\";\n\nexport const interpolateVector = (\n  value: number,\n  inputRange: readonly number[],\n  outputRange: readonly Vector[],\n  options?: Parameters<typeof interpolate>[3]\n) => {\n  \"worklet\";\n  return {\n    x: interpolate(\n      value,\n      inputRange,\n      outputRange.map((v) => v.x),\n      options\n    ),\n    y: interpolate(\n      value,\n      inputRange,\n      outputRange.map((v) => v.y),\n      options\n    ),\n  };\n};\n\nexport const mixVector = (value: number, from: Vector, to: Vector) => {\n  \"worklet\";\n  return interpolateVector(value, [0, 1], [from, to]);\n};\n"],"mappings":"AAEA,SAASA,WAAW,QAAQ,eAAe;AAE3C,OAAO,MAAMC,iBAAiB,GAAGA,CAC/BC,KAAa,EACbC,UAA6B,EAC7BC,WAA8B,EAC9BC,OAA2C,KACxC;EACH,SAAS;;EACT,OAAO;IACLC,CAAC,EAAEN,WAAW,CACZE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACG,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAACF,CAAC,CAAC,EAC3BD,OACF,CAAC;IACDI,CAAC,EAAET,WAAW,CACZE,KAAK,EACLC,UAAU,EACVC,WAAW,CAACG,GAAG,CAAEC,CAAC,IAAKA,CAAC,CAACC,CAAC,CAAC,EAC3BJ,OACF;EACF,CAAC;AACH,CAAC;AAED,OAAO,MAAMK,SAAS,GAAGA,CAACR,KAAa,EAAES,IAAY,EAAEC,EAAU,KAAK;EACpE,SAAS;;EACT,OAAOX,iBAAiB,CAACC,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAACS,IAAI,EAAEC,EAAE,CAAC,CAAC;AACrD,CAAC","ignoreList":[]}

package/lib/module/animation/index.d.ts

@@ -0,0 +1 @@
+export * from "./functions";

package/lib/module/animation/index.js

@@ -0,0 +1,2 @@
+export * from "./functions";
+//# sourceMappingURL=index.js.map

package/lib/module/animation/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export * from \"./functions\";\n"],"mappings":"AAAA,cAAc,aAAa","ignoreList":[]}

package/lib/module/dom/nodes/datatypes/Circle.d.ts

@@ -0,0 +1,6 @@
+import type { CircleDef, ScalarCircleDef } from "../../types";
+export declare const isCircleScalarDef: (def: CircleDef) => def is ScalarCircleDef;
+export declare const processCircle: (def: CircleDef) => {
+    c: import("../../..").SkPoint;
+    r: number;
+};

package/lib/module/dom/nodes/datatypes/Circle.js

@@ -0,0 +1,29 @@
+export const isCircleScalarDef = def => {
+  "worklet";
+
+  // We have an issue to check property existence on JSI backed instances
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  return def.cx !== undefined;
+};
+export const processCircle = def => {
+  "worklet";
+
+  var _def$c;
+  if (isCircleScalarDef(def)) {
+    return {
+      c: {
+        x: def.cx,
+        y: def.cy
+      },
+      r: def.r
+    };
+  }
+  return {
+    ...def,
+    c: (_def$c = def.c) !== null && _def$c !== void 0 ? _def$c : {
+      x: 0,
+      y: 0
+    }
+  };
+};
+//# sourceMappingURL=Circle.js.map

package/lib/module/dom/nodes/datatypes/Circle.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isCircleScalarDef","def","cx","undefined","processCircle","_def$c","c","x","y","cy","r"],"sources":["Circle.ts"],"sourcesContent":["import type { CircleDef, ScalarCircleDef } from \"../../types\";\n\nexport const isCircleScalarDef = (def: CircleDef): def is ScalarCircleDef => {\n  \"worklet\";\n  // We have an issue to check property existence on JSI backed instances\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  return (def as any).cx !== undefined;\n};\n\nexport const processCircle = (def: CircleDef) => {\n  \"worklet\";\n  if (isCircleScalarDef(def)) {\n    return { c: { x: def.cx, y: def.cy }, r: def.r };\n  }\n  return { ...def, c: def.c ?? { x: 0, y: 0 } };\n};\n"],"mappings":"AAEA,OAAO,MAAMA,iBAAiB,GAAIC,GAAc,IAA6B;EAC3E,SAAS;;EACT;EACA;EACA,OAAQA,GAAG,CAASC,EAAE,KAAKC,SAAS;AACtC,CAAC;AAED,OAAO,MAAMC,aAAa,GAAIH,GAAc,IAAK;EAC/C,SAAS;;EAAC,IAAAI,MAAA;EACV,IAAIL,iBAAiB,CAACC,GAAG,CAAC,EAAE;IAC1B,OAAO;MAAEK,CAAC,EAAE;QAAEC,CAAC,EAAEN,GAAG,CAACC,EAAE;QAAEM,CAAC,EAAEP,GAAG,CAACQ;MAAG,CAAC;MAAEC,CAAC,EAAET,GAAG,CAACS;IAAE,CAAC;EAClD;EACA,OAAO;IAAE,GAAGT,GAAG;IAAEK,CAAC,GAAAD,MAAA,GAAEJ,GAAG,CAACK,CAAC,cAAAD,MAAA,cAAAA,MAAA,GAAI;MAAEE,CAAC,EAAE,CAAC;MAAEC,CAAC,EAAE;IAAE;EAAE,CAAC;AAC/C,CAAC","ignoreList":[]}

package/lib/module/dom/nodes/datatypes/Enum.d.ts

@@ -0,0 +1 @@
+export declare const enumKey: <K extends string>(k: K) => Capitalize<K>;

package/lib/module/dom/nodes/datatypes/Enum.js

@@ -0,0 +1,6 @@
+export const enumKey = k => {
+  "worklet";
+
+  return k.charAt(0).toUpperCase() + k.slice(1);
+};
+//# sourceMappingURL=Enum.js.map

package/lib/module/dom/nodes/datatypes/Enum.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["enumKey","k","charAt","toUpperCase","slice"],"sources":["Enum.ts"],"sourcesContent":["export const enumKey = <K extends string>(k: K) => {\n  \"worklet\";\n  return (k.charAt(0).toUpperCase() + k.slice(1)) as Capitalize<K>;\n};\n"],"mappings":"AAAA,OAAO,MAAMA,OAAO,GAAsBC,CAAI,IAAK;EACjD,SAAS;;EACT,OAAQA,CAAC,CAACC,MAAM,CAAC,CAAC,CAAC,CAACC,WAAW,CAAC,CAAC,GAAGF,CAAC,CAACG,KAAK,CAAC,CAAC,CAAC;AAChD,CAAC","ignoreList":[]}

package/lib/module/dom/nodes/datatypes/Fitting.d.ts

@@ -0,0 +1,33 @@
+import type { SkRect } from "../../../skia/types";
+import type { Fit } from "../../types";
+export interface Size {
+    width: number;
+    height: number;
+}
+export declare const size: (width?: number, height?: number) => {
+    width: number;
+    height: number;
+};
+export declare const rect2rect: (src: SkRect, dst: SkRect) => [{
+    translateX: number;
+}, {
+    translateY: number;
+}, {
+    scaleX: number;
+}, {
+    scaleY: number;
+}];
+export declare const fitRects: (fit: Fit, rect: SkRect, { x, y, width, height }: SkRect) => {
+    src: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    dst: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+};

package/lib/module/dom/nodes/datatypes/Fitting.js

@@ -0,0 +1,132 @@
+import { exhaustiveCheck } from "../../../renderer/typeddash";
+export const size = (width = 0, height = 0) => {
+  "worklet";
+
+  return {
+    width,
+    height
+  };
+};
+export const rect2rect = (src, dst) => {
+  "worklet";
+
+  const scaleX = dst.width / src.width;
+  const scaleY = dst.height / src.height;
+  const translateX = dst.x - src.x * scaleX;
+  const translateY = dst.y - src.y * scaleY;
+  return [{
+    translateX
+  }, {
+    translateY
+  }, {
+    scaleX
+  }, {
+    scaleY
+  }];
+};
+const inscribe = ({
+  width,
+  height
+}, rect) => {
+  "worklet";
+
+  const halfWidthDelta = (rect.width - width) / 2.0;
+  const halfHeightDelta = (rect.height - height) / 2.0;
+  return {
+    x: rect.x + halfWidthDelta,
+    y: rect.y + halfHeightDelta,
+    width,
+    height
+  };
+};
+const applyBoxFit = (fit, input, output) => {
+  "worklet";
+
+  let src = size(),
+    dst = size();
+  if (input.height <= 0.0 || input.width <= 0.0 || output.height <= 0.0 || output.width <= 0.0) {
+    return {
+      src,
+      dst
+    };
+  }
+  switch (fit) {
+    case "fill":
+      src = input;
+      dst = output;
+      break;
+    case "contain":
+      src = input;
+      if (output.width / output.height > src.width / src.height) {
+        dst = size(src.width * output.height / src.height, output.height);
+      } else {
+        dst = size(output.width, src.height * output.width / src.width);
+      }
+      break;
+    case "cover":
+      if (output.width / output.height > input.width / input.height) {
+        src = size(input.width, input.width * output.height / output.width);
+      } else {
+        src = size(input.height * output.width / output.height, input.height);
+      }
+      dst = output;
+      break;
+    case "fitWidth":
+      src = size(input.width, input.width * output.height / output.width);
+      dst = size(output.width, src.height * output.width / src.width);
+      break;
+    case "fitHeight":
+      src = size(input.height * output.width / output.height, input.height);
+      dst = size(src.width * output.height / src.height, output.height);
+      break;
+    case "none":
+      src = size(Math.min(input.width, output.width), Math.min(input.height, output.height));
+      dst = src;
+      break;
+    case "scaleDown":
+      src = input;
+      dst = input;
+      const aspectRatio = input.width / input.height;
+      if (dst.height > output.height) {
+        dst = size(output.height * aspectRatio, output.height);
+      }
+      if (dst.width > output.width) {
+        dst = size(output.width, output.width / aspectRatio);
+      }
+      break;
+    default:
+      exhaustiveCheck(fit);
+  }
+  return {
+    src,
+    dst
+  };
+};
+export const fitRects = (fit, rect, {
+  x,
+  y,
+  width,
+  height
+}) => {
+  "worklet";
+
+  const sizes = applyBoxFit(fit, {
+    width: rect.width,
+    height: rect.height
+  }, {
+    width,
+    height
+  });
+  const src = inscribe(sizes.src, rect);
+  const dst = inscribe(sizes.dst, {
+    x,
+    y,
+    width,
+    height
+  });
+  return {
+    src,
+    dst
+  };
+};
+//# sourceMappingURL=Fitting.js.map

package/lib/module/dom/nodes/datatypes/Fitting.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["exhaustiveCheck","size","width","height","rect2rect","src","dst","scaleX","scaleY","translateX","x","translateY","y","inscribe","rect","halfWidthDelta","halfHeightDelta","applyBoxFit","fit","input","output","Math","min","aspectRatio","fitRects","sizes"],"sources":["Fitting.ts"],"sourcesContent":["import { exhaustiveCheck } from \"../../../renderer/typeddash\";\nimport type { SkRect } from \"../../../skia/types\";\nimport type { Fit } from \"../../types\";\n\nexport interface Size {\n  width: number;\n  height: number;\n}\n\nexport const size = (width = 0, height = 0) => {\n  \"worklet\";\n  return { width, height };\n};\n\nexport const rect2rect = (\n  src: SkRect,\n  dst: SkRect\n): [\n  { translateX: number },\n  { translateY: number },\n  { scaleX: number },\n  { scaleY: number },\n] => {\n  \"worklet\";\n  const scaleX = dst.width / src.width;\n  const scaleY = dst.height / src.height;\n  const translateX = dst.x - src.x * scaleX;\n  const translateY = dst.y - src.y * scaleY;\n  return [{ translateX }, { translateY }, { scaleX }, { scaleY }];\n};\n\nconst inscribe = (\n  { width, height }: Size,\n  rect: { x: number; y: number; width: number; height: number }\n) => {\n  \"worklet\";\n  const halfWidthDelta = (rect.width - width) / 2.0;\n  const halfHeightDelta = (rect.height - height) / 2.0;\n  return {\n    x: rect.x + halfWidthDelta,\n    y: rect.y + halfHeightDelta,\n    width,\n    height,\n  };\n};\n\nconst applyBoxFit = (fit: Fit, input: Size, output: Size) => {\n  \"worklet\";\n  let src = size(),\n    dst = size();\n  if (\n    input.height <= 0.0 ||\n    input.width <= 0.0 ||\n    output.height <= 0.0 ||\n    output.width <= 0.0\n  ) {\n    return { src, dst };\n  }\n  switch (fit) {\n    case \"fill\":\n      src = input;\n      dst = output;\n      break;\n    case \"contain\":\n      src = input;\n      if (output.width / output.height > src.width / src.height) {\n        dst = size((src.width * output.height) / src.height, output.height);\n      } else {\n        dst = size(output.width, (src.height * output.width) / src.width);\n      }\n      break;\n    case \"cover\":\n      if (output.width / output.height > input.width / input.height) {\n        src = size(input.width, (input.width * output.height) / output.width);\n      } else {\n        src = size((input.height * output.width) / output.height, input.height);\n      }\n      dst = output;\n      break;\n    case \"fitWidth\":\n      src = size(input.width, (input.width * output.height) / output.width);\n      dst = size(output.width, (src.height * output.width) / src.width);\n      break;\n    case \"fitHeight\":\n      src = size((input.height * output.width) / output.height, input.height);\n      dst = size((src.width * output.height) / src.height, output.height);\n      break;\n    case \"none\":\n      src = size(\n        Math.min(input.width, output.width),\n        Math.min(input.height, output.height)\n      );\n      dst = src;\n      break;\n    case \"scaleDown\":\n      src = input;\n      dst = input;\n      const aspectRatio = input.width / input.height;\n      if (dst.height > output.height) {\n        dst = size(output.height * aspectRatio, output.height);\n      }\n      if (dst.width > output.width) {\n        dst = size(output.width, output.width / aspectRatio);\n      }\n      break;\n    default:\n      exhaustiveCheck(fit);\n  }\n  return { src, dst };\n};\n\nexport const fitRects = (\n  fit: Fit,\n  rect: SkRect,\n  { x, y, width, height }: SkRect\n) => {\n  \"worklet\";\n  const sizes = applyBoxFit(\n    fit,\n    { width: rect.width, height: rect.height },\n    { width, height }\n  );\n  const src = inscribe(sizes.src, rect);\n  const dst = inscribe(sizes.dst, {\n    x,\n    y,\n    width,\n    height,\n  });\n  return { src, dst };\n};\n"],"mappings":"AAAA,SAASA,eAAe,QAAQ,6BAA6B;AAS7D,OAAO,MAAMC,IAAI,GAAGA,CAACC,KAAK,GAAG,CAAC,EAAEC,MAAM,GAAG,CAAC,KAAK;EAC7C,SAAS;;EACT,OAAO;IAAED,KAAK;IAAEC;EAAO,CAAC;AAC1B,CAAC;AAED,OAAO,MAAMC,SAAS,GAAGA,CACvBC,GAAW,EACXC,GAAW,KAMR;EACH,SAAS;;EACT,MAAMC,MAAM,GAAGD,GAAG,CAACJ,KAAK,GAAGG,GAAG,CAACH,KAAK;EACpC,MAAMM,MAAM,GAAGF,GAAG,CAACH,MAAM,GAAGE,GAAG,CAACF,MAAM;EACtC,MAAMM,UAAU,GAAGH,GAAG,CAACI,CAAC,GAAGL,GAAG,CAACK,CAAC,GAAGH,MAAM;EACzC,MAAMI,UAAU,GAAGL,GAAG,CAACM,CAAC,GAAGP,GAAG,CAACO,CAAC,GAAGJ,MAAM;EACzC,OAAO,CAAC;IAAEC;EAAW,CAAC,EAAE;IAAEE;EAAW,CAAC,EAAE;IAAEJ;EAAO,CAAC,EAAE;IAAEC;EAAO,CAAC,CAAC;AACjE,CAAC;AAED,MAAMK,QAAQ,GAAGA,CACf;EAAEX,KAAK;EAAEC;AAAa,CAAC,EACvBW,IAA6D,KAC1D;EACH,SAAS;;EACT,MAAMC,cAAc,GAAG,CAACD,IAAI,CAACZ,KAAK,GAAGA,KAAK,IAAI,GAAG;EACjD,MAAMc,eAAe,GAAG,CAACF,IAAI,CAACX,MAAM,GAAGA,MAAM,IAAI,GAAG;EACpD,OAAO;IACLO,CAAC,EAAEI,IAAI,CAACJ,CAAC,GAAGK,cAAc;IAC1BH,CAAC,EAAEE,IAAI,CAACF,CAAC,GAAGI,eAAe;IAC3Bd,KAAK;IACLC;EACF,CAAC;AACH,CAAC;AAED,MAAMc,WAAW,GAAGA,CAACC,GAAQ,EAAEC,KAAW,EAAEC,MAAY,KAAK;EAC3D,SAAS;;EACT,IAAIf,GAAG,GAAGJ,IAAI,CAAC,CAAC;IACdK,GAAG,GAAGL,IAAI,CAAC,CAAC;EACd,IACEkB,KAAK,CAAChB,MAAM,IAAI,GAAG,IACnBgB,KAAK,CAACjB,KAAK,IAAI,GAAG,IAClBkB,MAAM,CAACjB,MAAM,IAAI,GAAG,IACpBiB,MAAM,CAAClB,KAAK,IAAI,GAAG,EACnB;IACA,OAAO;MAAEG,GAAG;MAAEC;IAAI,CAAC;EACrB;EACA,QAAQY,GAAG;IACT,KAAK,MAAM;MACTb,GAAG,GAAGc,KAAK;MACXb,GAAG,GAAGc,MAAM;MACZ;IACF,KAAK,SAAS;MACZf,GAAG,GAAGc,KAAK;MACX,IAAIC,MAAM,CAAClB,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAGE,GAAG,CAACH,KAAK,GAAGG,GAAG,CAACF,MAAM,EAAE;QACzDG,GAAG,GAAGL,IAAI,CAAEI,GAAG,CAACH,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAIE,GAAG,CAACF,MAAM,EAAEiB,MAAM,CAACjB,MAAM,CAAC;MACrE,CAAC,MAAM;QACLG,GAAG,GAAGL,IAAI,CAACmB,MAAM,CAAClB,KAAK,EAAGG,GAAG,CAACF,MAAM,GAAGiB,MAAM,CAAClB,KAAK,GAAIG,GAAG,CAACH,KAAK,CAAC;MACnE;MACA;IACF,KAAK,OAAO;MACV,IAAIkB,MAAM,CAAClB,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAGgB,KAAK,CAACjB,KAAK,GAAGiB,KAAK,CAAChB,MAAM,EAAE;QAC7DE,GAAG,GAAGJ,IAAI,CAACkB,KAAK,CAACjB,KAAK,EAAGiB,KAAK,CAACjB,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAIiB,MAAM,CAAClB,KAAK,CAAC;MACvE,CAAC,MAAM;QACLG,GAAG,GAAGJ,IAAI,CAAEkB,KAAK,CAAChB,MAAM,GAAGiB,MAAM,CAAClB,KAAK,GAAIkB,MAAM,CAACjB,MAAM,EAAEgB,KAAK,CAAChB,MAAM,CAAC;MACzE;MACAG,GAAG,GAAGc,MAAM;MACZ;IACF,KAAK,UAAU;MACbf,GAAG,GAAGJ,IAAI,CAACkB,KAAK,CAACjB,KAAK,EAAGiB,KAAK,CAACjB,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAIiB,MAAM,CAAClB,KAAK,CAAC;MACrEI,GAAG,GAAGL,IAAI,CAACmB,MAAM,CAAClB,KAAK,EAAGG,GAAG,CAACF,MAAM,GAAGiB,MAAM,CAAClB,KAAK,GAAIG,GAAG,CAACH,KAAK,CAAC;MACjE;IACF,KAAK,WAAW;MACdG,GAAG,GAAGJ,IAAI,CAAEkB,KAAK,CAAChB,MAAM,GAAGiB,MAAM,CAAClB,KAAK,GAAIkB,MAAM,CAACjB,MAAM,EAAEgB,KAAK,CAAChB,MAAM,CAAC;MACvEG,GAAG,GAAGL,IAAI,CAAEI,GAAG,CAACH,KAAK,GAAGkB,MAAM,CAACjB,MAAM,GAAIE,GAAG,CAACF,MAAM,EAAEiB,MAAM,CAACjB,MAAM,CAAC;MACnE;IACF,KAAK,MAAM;MACTE,GAAG,GAAGJ,IAAI,CACRoB,IAAI,CAACC,GAAG,CAACH,KAAK,CAACjB,KAAK,EAAEkB,MAAM,CAAClB,KAAK,CAAC,EACnCmB,IAAI,CAACC,GAAG,CAACH,KAAK,CAAChB,MAAM,EAAEiB,MAAM,CAACjB,MAAM,CACtC,CAAC;MACDG,GAAG,GAAGD,GAAG;MACT;IACF,KAAK,WAAW;MACdA,GAAG,GAAGc,KAAK;MACXb,GAAG,GAAGa,KAAK;MACX,MAAMI,WAAW,GAAGJ,KAAK,CAACjB,KAAK,GAAGiB,KAAK,CAAChB,MAAM;MAC9C,IAAIG,GAAG,CAACH,MAAM,GAAGiB,MAAM,CAACjB,MAAM,EAAE;QAC9BG,GAAG,GAAGL,IAAI,CAACmB,MAAM,CAACjB,MAAM,GAAGoB,WAAW,EAAEH,MAAM,CAACjB,MAAM,CAAC;MACxD;MACA,IAAIG,GAAG,CAACJ,KAAK,GAAGkB,MAAM,CAAClB,KAAK,EAAE;QAC5BI,GAAG,GAAGL,IAAI,CAACmB,MAAM,CAAClB,KAAK,EAAEkB,MAAM,CAAClB,KAAK,GAAGqB,WAAW,CAAC;MACtD;MACA;IACF;MACEvB,eAAe,CAACkB,GAAG,CAAC;EACxB;EACA,OAAO;IAAEb,GAAG;IAAEC;EAAI,CAAC;AACrB,CAAC;AAED,OAAO,MAAMkB,QAAQ,GAAGA,CACtBN,GAAQ,EACRJ,IAAY,EACZ;EAAEJ,CAAC;EAAEE,CAAC;EAAEV,KAAK;EAAEC;AAAe,CAAC,KAC5B;EACH,SAAS;;EACT,MAAMsB,KAAK,GAAGR,WAAW,CACvBC,GAAG,EACH;IAAEhB,KAAK,EAAEY,IAAI,CAACZ,KAAK;IAAEC,MAAM,EAAEW,IAAI,CAACX;EAAO,CAAC,EAC1C;IAAED,KAAK;IAAEC;EAAO,CAClB,CAAC;EACD,MAAME,GAAG,GAAGQ,QAAQ,CAACY,KAAK,CAACpB,GAAG,EAAES,IAAI,CAAC;EACrC,MAAMR,GAAG,GAAGO,QAAQ,CAACY,KAAK,CAACnB,GAAG,EAAE;IAC9BI,CAAC;IACDE,CAAC;IACDV,KAAK;IACLC;EACF,CAAC,CAAC;EACF,OAAO;IAAEE,GAAG;IAAEC;EAAI,CAAC;AACrB,CAAC","ignoreList":[]}