lecodes-cli 0.1.6 → 0.1.7

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // src/index.ts
-import { readFileSync as readFileSync8 } from "node:fs";
+import { readFileSync as readFileSync9 } from "node:fs";
 import { dirname as dirname7, join as join11 } from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 
@@ -322,10 +322,13 @@ var DEFAULT_IGNORE_FILE = `# Files matched here are NOT pushed to LeCodes.
 # Only untracked files are affected — assets already in the project stay tracked
 # even if they match a pattern. Built-in defaults (node_modules, _*, *.log) always apply.
 
-# Render / preview outputs
+# Render / preview outputs (the default \`lecodes render --png\` target)
 screenshot.png
 shots/
-*.png
+
+# Image & other binary assets ARE pushed by default — they're real project resources.
+# Uncomment a pattern below only if you want to keep some untracked ones out of pushes.
+# *.png
 
 # Local notes & dumps (uncomment to ignore)
 # *.json
@@ -904,12 +907,14 @@ var collectEntries = (root, manifest, project) => {
 
 // src/compile/projectCompile.ts
 import { existsSync as existsSync6 } from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
 import { dirname as dirname5, join as join9 } from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 // ../sdk/src/compile/bundler.ts
 import * as esbuild from "esbuild";
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname4, join as join8 } from "node:path";
+import { existsSync as existsSync5, readdirSync as readdirSync4, readFileSync as readFileSync7, statSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+import { dirname as dirname4, join as join8, relative as relative2 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../sdk/src/compile/assetMacro.ts
@@ -989,7 +994,7 @@ var resolveWithExtensions = (files, importer, specifier) => {
   throw new Error(`Module not found: ${specifier} from ${importer}`);
 };
 var getLoader = (path) => path.endsWith(".ts") ? "ts" : "js";
-var bundleProject = async (entrypoint, files, format = "esm") => {
+var bundleProjectEsbuild = async (entrypoint, files, format = "esm") => {
   const fileMap = new Map(Object.entries(files).map(([k, v]) => [normalize(k), v]));
   const entry = normalize(entrypoint);
   if (!fileMap.has(entry))
@@ -1030,6 +1035,95 @@ var bundleProject = async (entrypoint, files, format = "esm") => {
     throw new Error("Compilation produced no output");
   return output.text;
 };
+var CHISEL_DEFINE = { RAD2DEG: "57.29577951308232", DEG2RAD: "0.017453292519943295" };
+var CHISEL_KEEP = ["_*"];
+var resolveSdkSrc = () => {
+  const inject = resolveInject();
+  if (!inject.endsWith("inject.ts")) {
+    throw new Error(`chisel needs the SDK source tree (src/inject.ts); got a prebuilt inject at ${inject}. ` + `Set LECODES_SDK_INJECT to the source, or use esbuild (unset LECODES_BUNDLER).`);
+  }
+  return dirname4(inject);
+};
+var isSdkSource = (path) => /\.[tj]s$/.test(path) && !path.endsWith(".d.ts") && !path.includes("/compile/") && !path.includes("/tests/") && !path.includes("/__tests__/");
+var sdkFilesCache = new Map;
+var collectSdkFiles = (sdkSrc) => {
+  const cached = sdkFilesCache.get(sdkSrc);
+  if (cached)
+    return cached;
+  const out = {};
+  const walk = (dir) => {
+    for (const name of readdirSync4(dir)) {
+      const p = join8(dir, name);
+      if (statSync(p).isDirectory())
+        walk(p);
+      else if (isSdkSource(p))
+        out["/__sdk/" + relative2(sdkSrc, p)] = readFileSync7(p, "utf8");
+    }
+  };
+  walk(sdkSrc);
+  sdkFilesCache.set(sdkSrc, out);
+  return out;
+};
+var resolveChiselBin = () => {
+  const override = process.env.LECODES_CHISEL_BIN;
+  if (override) {
+    if (existsSync5(override))
+      return override;
+    throw new Error(`LECODES_CHISEL_BIN points at a missing file: ${override}`);
+  }
+  const here = dirname4(fileURLToPath(import.meta.url));
+  for (const rel of ["release/chisel", "debug/chisel"]) {
+    const p = join8(here, "..", "..", "..", "..", "..", "chisel", "target", rel);
+    if (existsSync5(p))
+      return p;
+  }
+  throw new Error("chisel binary not found. Build it (`cargo build --release` in the chisel repo) or set LECODES_CHISEL_BIN.");
+};
+var bundleProjectChisel = async (entrypoint, files, format, sourcemap) => {
+  const entry = normalize(entrypoint);
+  const projFiles = {};
+  for (const [k, v] of Object.entries(files)) {
+    const path = normalize(k);
+    projFiles[path] = /\.[tj]sx?$/.test(path) && hasAssetMacro(v) ? desugarAssetMacros(v, path) : v;
+  }
+  if (!projFiles[entry])
+    throw new Error(`Entrypoint not found: ${entry}`);
+  const sdkFiles = collectSdkFiles(resolveSdkSrc());
+  const minify = process.env.LECODES_CHISEL_MINIFY !== "0";
+  const input = JSON.stringify({
+    files: { ...sdkFiles, ...projFiles },
+    entry,
+    inject: ["/__sdk/inject.ts"],
+    format,
+    minify,
+    fuse: process.env.LECODES_CHISEL_FUSE === "1",
+    define: CHISEL_DEFINE,
+    keep: CHISEL_KEEP,
+    sourcemap
+  });
+  const bin = resolveChiselBin();
+  const r = spawnSync(bin, [], { input, encoding: "utf8", maxBuffer: 256 * 1024 * 1024 });
+  if (r.status === 2 || r.error) {
+    throw new Error(`chisel failed: ${r.error?.message ?? r.stderr ?? "unknown error"}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(r.stdout || "{}");
+  } catch {
+    throw new Error(`chisel produced invalid output: ${(r.stdout || r.stderr || "").slice(0, 200)}`);
+  }
+  if (parsed.error)
+    throw new Error(`chisel: ${parsed.error}`);
+  if (parsed.code == null)
+    throw new Error("chisel produced no code");
+  return { code: parsed.code, map: parsed.map ?? null };
+};
+var bundleProjectWithMap = async (entrypoint, files, format = "esm") => {
+  if (process.env.LECODES_BUNDLER === "chisel") {
+    return bundleProjectChisel(entrypoint, files, format, true);
+  }
+  return { code: await bundleProjectEsbuild(entrypoint, files, format), map: null };
+};
 
 // ../sdk/src/compile/header.ts
 var buildHeader = (name, code, opts = {}) => {
@@ -1067,6 +1161,19 @@ var buildHeader = (name, code, opts = {}) => {
   return header;
 };
 
+// ../sdk/src/compile/sourcemap.ts
+var offsetSourceMap = (mapJson, lines) => {
+  if (lines <= 0)
+    return mapJson;
+  const map = JSON.parse(mapJson);
+  map.mappings = ";".repeat(lines) + map.mappings;
+  return JSON.stringify(map);
+};
+var inlineSourceMapComment = (mapJson) => {
+  const b64 = Buffer.from(mapJson, "utf8").toString("base64");
+  return `//# lecodesMap=data:application/json;charset=utf-8;base64,${b64}`;
+};
+
 // ../sdk/src/compile/compileProject.ts
 var detectEntry = (entries) => {
   let entry = "";
@@ -1106,13 +1213,39 @@ var compileProject = async (opts) => {
       files[e.path] = e.text ?? "";
     }
   }
-  const code = await bundleProject(entry, files, opts.format ?? "esm");
-  return opts.header === false ? code : buildHeader(opts.name, code, { icon: opts.icon }) + code;
+  const { code, map } = await bundleProjectWithMap(entry, files, opts.format ?? "esm");
+  if (opts.header === false) {
+    return map ? `${code}
+${inlineSourceMapComment(map)}` : code;
+  }
+  const header = buildHeader(opts.name, code, { icon: opts.icon });
+  if (!map)
+    return header + code;
+  const headerLines = (header.match(/\n/g) ?? []).length;
+  return `${header}${code}
+${inlineSourceMapComment(offsetSourceMap(map, headerLines))}`;
 };
 // src/compile/projectCompile.ts
-var vendoredInject = join9(dirname5(fileURLToPath2(import.meta.url)), "..", "runtime", "inject.js");
+var here = dirname5(fileURLToPath2(import.meta.url));
+var vendoredInject = join9(here, "..", "runtime", "sdk", "inject.ts");
 if (existsSync6(vendoredInject))
   process.env.LECODES_SDK_INJECT = vendoredInject;
+var resolveChiselBin2 = () => {
+  if (process.env.LECODES_CHISEL_BIN)
+    return process.env.LECODES_CHISEL_BIN;
+  try {
+    return createRequire2(import.meta.url)("@letary/chisel").binaryPath() ?? null;
+  } catch {
+    return null;
+  }
+};
+if (!process.env.LECODES_BUNDLER) {
+  const chiselBin = resolveChiselBin2();
+  if (chiselBin) {
+    process.env.LECODES_CHISEL_BIN = chiselBin;
+    process.env.LECODES_BUNDLER = "chisel";
+  }
+}
 var compileProject2 = (opts) => compileProject({
   entries: opts.entries.map((e) => ({ path: e.path, type: e.type, text: e.text, fileSrc: e.fileSrc, shaders: e.shaders })),
   name: opts.name,
@@ -1356,7 +1489,7 @@ var pullPaths = async (root, manifest, project, paths, apiUrl, token) => {
 
 // src/commands/push.ts
 import { basename as basename3 } from "node:path";
-import { readFileSync as readFileSync7 } from "node:fs";
+import { readFileSync as readFileSync8 } from "node:fs";
 var push = async (args) => {
   const root = findProjectRoot(process.cwd());
   const manifest = readManifest(root);
@@ -1381,6 +1514,12 @@ var push = async (args) => {
     if (commits.headId !== manifest.baseHeadId) {
       throw new CliError("The project changed on the server since your last sync. Run `lecodes diff` to compare, `lecodes pull` to take the server's version, or `lecodes push --force` to overwrite.");
     }
+    if (commits.dirty) {
+      const drift = serverPathDrift(await getProject(apiUrl, token, manifest.uuid), manifest);
+      if (drift) {
+        throw new CliError(`The project has uncommitted changes in the web editor your checkout doesn't have (${drift}). Run \`lecodes pull\` to take them, or \`lecodes push --force\` to overwrite the server.`);
+      }
+    }
   }
   if (force) {
     const project = await getProject(apiUrl, token, manifest.uuid);
@@ -1409,9 +1548,9 @@ var push = async (args) => {
     if (source)
       entry.assetId = source.id;
     if (isTextKind(kind)) {
-      entry.text = readFileSync7(file.absPath, "utf8");
+      entry.text = readFileSync8(file.absPath, "utf8");
     } else if (!source || source.sha !== file.sha) {
-      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename3(file.path), readFileSync7(file.absPath));
+      const blob = await uploadBlob(apiUrl, token, manifest.uuid, basename3(file.path), readFileSync8(file.absPath));
       entry.blobFileId = blob.id;
       uploaded++;
     }
@@ -1443,6 +1582,19 @@ var push = async (args) => {
   if (publish)
     reportPublish(res);
 };
+var serverPathDrift = (project, manifest) => {
+  const pathById = buildPaths(project.assets);
+  const serverPaths = new Set(project.assets.filter((a) => a.type !== "folder").map((a) => pathById.get(a.id)));
+  const manifestPaths = new Set(Object.keys(manifest.files));
+  const added = [...serverPaths].filter((p) => !manifestPaths.has(p));
+  const removed = [...manifestPaths].filter((p) => !serverPaths.has(p));
+  const describe = (label, paths) => `${paths.length} ${label} on the server: ${paths.slice(0, 3).join(", ")}${paths.length > 3 ? ", …" : ""}`;
+  const parts = [
+    added.length ? describe("added", added) : "",
+    removed.length ? describe("removed", removed) : ""
+  ].filter(Boolean);
+  return parts.length ? parts.join("; ") : null;
+};
 var reportPublish = (res) => {
   if (res.published)
     success("Published — the project is now live.");
@@ -1527,8 +1679,8 @@ Config lives in ~/.lecodes/config.json (override with LECODES_API / LECODES_TOKE
 var commands = { login, create, clone, status, diff, pull, push, preview, render };
 var readVersion = () => {
   try {
-    const here = dirname7(fileURLToPath3(import.meta.url));
-    return JSON.parse(readFileSync8(join11(here, "..", "package.json"), "utf8")).version ?? "unknown";
+    const here2 = dirname7(fileURLToPath3(import.meta.url));
+    return JSON.parse(readFileSync9(join11(here2, "..", "package.json"), "utf8")).version ?? "unknown";
   } catch {
     return "unknown";
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lecodes-cli",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Clone, edit and push LeCodes projects from your machine.",
   "type": "module",
   "license": "MIT",
@@ -21,12 +21,13 @@
   },
   "scripts": {
     "vendor-runtime": "bun scripts/vendor-runtime.ts",
-    "build": "bun scripts/vendor-runtime.ts && bun build src/index.ts --target=node --outfile dist/index.js --external esbuild --external lecodes-renderer --banner=\"#!/usr/bin/env node\"",
+    "build": "bun scripts/vendor-runtime.ts && bun build src/index.ts --target=node --outfile dist/index.js --external esbuild --external @letary/chisel --external lecodes-renderer --banner=\"#!/usr/bin/env node\"",
     "typecheck": "tsc --noEmit",
     "dev": "bun run src/index.ts",
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
+    "@letary/chisel": "^0.1.2",
     "esbuild": "^0.27.3"
   },
   "peerDependencies": {

package/runtime/sdk/animate/animate.ts

@@ -0,0 +1,238 @@
+// animate self-implements its matrix decompose/recompose; these are just the numeric-array shapes.
+type mat4 = Float32Array | number[]
+type quat = Float32Array | number[]
+type vec2 = Float32Array | number[]
+type vec3 = Float32Array | number[]
+import type { Easing } from "./easings"
+
+type AnimateProps = number | string | vec2 | vec3 | quat
+
+export type AnimateOptions<T> = {
+  from: T,
+  to: T,
+  duration: number,
+  onUpdate(val: T): void,
+  onComplete?(): void,
+  easing?: Easing,
+}
+
+export const animate = <T extends AnimateProps>(options: AnimateOptions<T>): number => {
+  
+  let onRawUpdate
+  if (typeof options.to === "number") {
+    const { onUpdate, from, to } = options as AnimateOptions<number>
+    onRawUpdate = (t: number) => onUpdate(from + (to - from) * t)
+  } else if (options.to === "string") {
+    // TODO: Make color animate here
+    const { onUpdate, from, to } = options as AnimateOptions<string>
+    onRawUpdate = (t: number) => onUpdate(from)
+    
+    // onRawUpdate = (val: number) => onUpdate(from + (to - from) * val)
+  } else if (options.to.length === 2) {
+    const { onUpdate, from, to } = options as AnimateOptions<vec2>
+    const tempVec = new Float32Array(3)
+    onRawUpdate = (t: number) => onUpdate(lerp2(tempVec, from, to, t))
+
+  } else if (options.to.length === 3) {
+    const { onUpdate, from, to } = options as AnimateOptions<vec3>
+    const tempVec = new Float32Array(3)
+
+    onRawUpdate = (t: number) => onUpdate(lerp(tempVec, from, to, t))
+  } else if (options.to.length === 4) { 
+    const { onUpdate, from, to } = options as AnimateOptions<quat>
+
+    const tempQuat = new Float32Array(4)
+    onRawUpdate = (t: number) => onUpdate(slerp(tempQuat, from, to, t))
+  } else {
+    onRawUpdate = () => {}
+  }
+
+  const animationId = _creatorUtils.animate(val => {
+    const _val = options.easing? options.easing(val): val
+    onRawUpdate(_val)
+    if (val === 1 && options.onComplete) {
+      options.onComplete()
+    }
+  }, options.duration)
+
+  return animationId
+}
+
+export const stopAnimation = (id: number): void =>  _creatorUtils.stopAnimation(id)
+export const pauseAnimation = (id: number): void => _creatorUtils.pauseAnimation(id)
+export const resumeAnimation = (id: number): void => _creatorUtils.resumeAnimation(id)
+
+export const animateMat4 = (options: AnimateOptions<mat4>): number => {
+  const fromPosition = new Float32Array(3)
+  const fromQuaternion = new Float32Array(4)
+  const fromScale = new Float32Array(3)
+  const toPosition = new Float32Array(3)
+  const toQuaternion = new Float32Array(4)
+  const toScale = new Float32Array(3)
+  decompose(fromQuaternion, fromPosition, fromScale, (options as AnimateOptions<mat4>).from)
+  decompose(toQuaternion, toPosition, toScale, (options as AnimateOptions<mat4>).to)
+
+  const tempPosition = new Float32Array(3)
+  const tempQuat = new Float32Array(4)
+  const tempScale = new Float32Array(3)
+  const tempMat = new Float32Array(16)
+
+  const onUpdate = (options as AnimateOptions<mat4>).onUpdate
+  const onRawUpdate = (t: number) => {
+    lerp(tempPosition, fromPosition, toPosition, t)
+    slerp(tempQuat, fromQuaternion, toQuaternion, t)
+    lerp(tempScale, fromScale, toScale, t)
+
+    onUpdate(fromRotationTranslationScale(tempMat, tempQuat, tempPosition, tempScale))
+  }
+
+  const animationId = _creatorUtils.animate(val => {
+    const _val = options.easing? options.easing(val): val
+    onRawUpdate(_val)
+    if (val === 1 && options.onComplete) {
+      options.onComplete()
+    }
+  }, options.duration)
+
+  return animationId
+}
+
+const EPSILON = 1e-6;
+function slerp(out: quat, a: quat, b: quat, t: number) {
+  const ax = a[0], ay = a[1], az = a[2], aw = a[3];
+  let bx = b[0], by = b[1], bz = b[2], bw = b[3];
+  let omega, cosom, sinom, scale0, scale1;
+  cosom = ax * bx + ay * by + az * bz + aw * bw;
+  if (cosom < 0) {
+    cosom = -cosom;
+    bx = -bx;
+    by = -by;
+    bz = -bz;
+    bw = -bw;
+  }
+  if (1 - cosom > EPSILON) {
+    omega = Math.acos(cosom);
+    sinom = Math.sin(omega);
+    scale0 = Math.sin((1 - t) * omega) / sinom;
+    scale1 = Math.sin(t * omega) / sinom;
+  } else {
+    scale0 = 1 - t;
+    scale1 = t;
+  }
+  out[0] = scale0 * ax + scale1 * bx;
+  out[1] = scale0 * ay + scale1 * by;
+  out[2] = scale0 * az + scale1 * bz;
+  out[3] = scale0 * aw + scale1 * bw;
+  return out;
+}
+function lerp(out: vec3, a: vec3, b: vec3, t: number) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  out[2] = az + t * (b[2] - az);
+  return out;
+}
+
+function lerp2(out: vec2, a: vec2, b: vec2, t: number) {
+  const ax = a[0];
+  const ay = a[1];
+  const az = a[2];
+  out[0] = ax + t * (b[0] - ax);
+  out[1] = ay + t * (b[1] - ay);
+  return out;
+}
+function fromRotationTranslationScale(out: mat4, q: quat, v: vec3, s: vec3) {
+  const x = q[0], y = q[1], z = q[2], w = q[3];
+  const x2 = x + x;
+  const y2 = y + y;
+  const z2 = z + z;
+  const xx = x * x2;
+  const xy = x * y2;
+  const xz = x * z2;
+  const yy = y * y2;
+  const yz = y * z2;
+  const zz = z * z2;
+  const wx = w * x2;
+  const wy = w * y2;
+  const wz = w * z2;
+  const sx = s[0];
+  const sy = s[1];
+  const sz = s[2];
+  out[0] = (1 - (yy + zz)) * sx;
+  out[1] = (xy + wz) * sx;
+  out[2] = (xz - wy) * sx;
+  out[3] = 0;
+  out[4] = (xy - wz) * sy;
+  out[5] = (1 - (xx + zz)) * sy;
+  out[6] = (yz + wx) * sy;
+  out[7] = 0;
+  out[8] = (xz + wy) * sz;
+  out[9] = (yz - wx) * sz;
+  out[10] = (1 - (xx + yy)) * sz;
+  out[11] = 0;
+  out[12] = v[0];
+  out[13] = v[1];
+  out[14] = v[2];
+  out[15] = 1;
+  return out;
+}
+
+function decompose(out_r: mat4, out_t: vec3, out_s: vec3, mat: mat4) {
+  out_t[0] = mat[12];
+  out_t[1] = mat[13];
+  out_t[2] = mat[14];
+  const m11 = mat[0];
+  const m12 = mat[1];
+  const m13 = mat[2];
+  const m21 = mat[4];
+  const m22 = mat[5];
+  const m23 = mat[6];
+  const m31 = mat[8];
+  const m32 = mat[9];
+  const m33 = mat[10];
+  out_s[0] = Math.hypot(m11, m12, m13);
+  out_s[1] = Math.hypot(m21, m22, m23);
+  out_s[2] = Math.hypot(m31, m32, m33);
+  const is1 = 1 / out_s[0];
+  const is2 = 1 / out_s[1];
+  const is3 = 1 / out_s[2];
+  const sm11 = m11 * is1;
+  const sm12 = m12 * is2;
+  const sm13 = m13 * is3;
+  const sm21 = m21 * is1;
+  const sm22 = m22 * is2;
+  const sm23 = m23 * is3;
+  const sm31 = m31 * is1;
+  const sm32 = m32 * is2;
+  const sm33 = m33 * is3;
+  const trace = sm11 + sm22 + sm33;
+  let S = 0;
+  if (trace > 0) {
+    S = Math.sqrt(trace + 1) * 2;
+    out_r[3] = 0.25 * S;
+    out_r[0] = (sm23 - sm32) / S;
+    out_r[1] = (sm31 - sm13) / S;
+    out_r[2] = (sm12 - sm21) / S;
+  } else if (sm11 > sm22 && sm11 > sm33) {
+    S = Math.sqrt(1 + sm11 - sm22 - sm33) * 2;
+    out_r[3] = (sm23 - sm32) / S;
+    out_r[0] = 0.25 * S;
+    out_r[1] = (sm12 + sm21) / S;
+    out_r[2] = (sm31 + sm13) / S;
+  } else if (sm22 > sm33) {
+    S = Math.sqrt(1 + sm22 - sm11 - sm33) * 2;
+    out_r[3] = (sm31 - sm13) / S;
+    out_r[0] = (sm12 + sm21) / S;
+    out_r[1] = 0.25 * S;
+    out_r[2] = (sm23 + sm32) / S;
+  } else {
+    S = Math.sqrt(1 + sm33 - sm11 - sm22) * 2;
+    out_r[3] = (sm12 - sm21) / S;
+    out_r[0] = (sm31 + sm13) / S;
+    out_r[1] = (sm23 + sm32) / S;
+    out_r[2] = 0.25 * S;
+  }
+  return out_r;
+}

package/runtime/sdk/animate/bezier.ts

@@ -0,0 +1,138 @@
+/*
+  Bezier function generator
+
+  Gaëtan Renaudeau's BezierEasing
+  https://github.com/gre/bezier-easing/blob/master/src/index.js
+  https://github.com/gre/bezier-easing/blob/master/LICENSE
+  You're a hero
+
+  Use
+
+    const easeOut = cubicBezier(.17,.67,.83,.67);
+    const x = easeOut(0.5); // returns 0.627...
+*/
+
+import type { Easing } from "./easings"
+
+const a = (a1: number, a2: number) => 1.0 - 3.0 * a2 + 3.0 * a1
+const b = (a1: number, a2: number) => 3.0 * a2 - 6.0 * a1
+const c = (a1: number) => 3.0 * a1
+
+// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.
+const calcBezier = (t: number, a1: number, a2: number) =>
+    ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t
+
+// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.
+const getSlope = (t: number, a1: number, a2: number) =>
+    3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1)
+
+const subdivisionPrecision = 0.0000001
+const subdivisionMaxIterations = 10
+
+function binarySubdivide(
+    aX: number,
+    aA: number,
+    aB: number,
+    mX1: number,
+    mX2: number
+) {
+    let currentX: number
+    let currentT: number
+    let i: number = 0
+
+    do {
+        currentT = aA + (aB - aA) / 2.0
+        currentX = calcBezier(currentT, mX1, mX2) - aX
+        if (currentX > 0.0) {
+            aB = currentT
+        } else {
+            aA = currentT
+        }
+    } while (
+        Math.abs(currentX) > subdivisionPrecision &&
+        ++i < subdivisionMaxIterations
+    )
+
+    return currentT
+}
+
+const newtonIterations = 8
+const newtonMinSlope = 0.001
+function newtonRaphsonIterate(
+    aX: number,
+    aGuessT: number,
+    mX1: number,
+    mX2: number
+) {
+    for (let i = 0; i < newtonIterations; ++i) {
+        const currentSlope = getSlope(aGuessT, mX1, mX2)
+        if (currentSlope === 0.0) {
+            return aGuessT
+        }
+        const currentX = calcBezier(aGuessT, mX1, mX2) - aX
+        aGuessT -= currentX / currentSlope
+    }
+    return aGuessT
+}
+
+const kSplineTableSize = 11
+const kSampleStepSize = 1.0 / (kSplineTableSize - 1.0)
+
+const linear: Easing = p => p
+
+export function cubicBezier(
+    mX1: number,
+    mY1: number,
+    mX2: number,
+    mY2: number
+): Easing {
+    // If this is a linear gradient, return linear easing
+    if (mX1 === mY1 && mX2 === mY2) return linear
+
+    // Precompute samples table
+    const sampleValues = new Float32Array(kSplineTableSize)
+
+    for (let i = 0; i < kSplineTableSize; ++i) {
+        sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2)
+    }
+
+    function getTForX(aX: number) {
+        let intervalStart = 0.0
+        let currentSample = 1
+        const lastSample = kSplineTableSize - 1
+
+        for (
+            ;
+            currentSample !== lastSample && sampleValues[currentSample] <= aX;
+            ++currentSample
+        ) {
+            intervalStart += kSampleStepSize
+        }
+        --currentSample
+
+        // Interpolate to provide an initial guess for t
+        const dist =
+            (aX - sampleValues[currentSample]) /
+            (sampleValues[currentSample + 1] - sampleValues[currentSample])
+        const guessForT = intervalStart + dist * kSampleStepSize
+
+        const initialSlope = getSlope(guessForT, mX1, mX2)
+        if (initialSlope >= newtonMinSlope) {
+            return newtonRaphsonIterate(aX, guessForT, mX1, mX2)
+        } else if (initialSlope === 0.0) {
+            return guessForT
+        } else {
+            return binarySubdivide(
+                aX,
+                intervalStart,
+                intervalStart + kSampleStepSize,
+                mX1,
+                mX2
+            )
+        }
+    }
+
+    // If animation is at start/end, return t without easing
+    return (t: number) =>
+        t === 0 || t === 1 ? t : calcBezier(getTForX(t), mY1, mY2)
+}