rubiks-cube-3d 1.0.0

package/dist/core-L1AjC-fV.js

@@ -0,0 +1,932 @@
+import * as e from "three";
+import { RoomEnvironment as t } from "three/examples/jsm/environments/RoomEnvironment.js";
+import n from "matter-js";
+import { RoundedBoxGeometry as r } from "three/examples/jsm/geometries/RoundedBoxGeometry.js";
+//#region src/core/physics.ts
+var i = 1e3 / 60, a = 6, o = 6.5, s = class {
+	constructor(e) {
+		this.accumulator = 0, this.elapsed = 0, this.spinningUp = !1, this.bobbing = !1, this.snapping = !1, this.opts = e, this.engine = n.Engine.create({ gravity: {
+			x: 0,
+			y: 0,
+			scale: 0
+		} }), this.flywheel = n.Bodies.circle(0, 0, 1, {
+			frictionAir: e.scrambleFriction,
+			collisionFilter: {
+				group: -1,
+				mask: 0
+			}
+		}), n.Body.setMass(this.flywheel, 1), this.floater = n.Bodies.circle(0, 0, 1, {
+			frictionAir: .012,
+			collisionFilter: {
+				group: -1,
+				mask: 0
+			}
+		}), n.Body.setMass(this.floater, 1), this.floatSpring = n.Constraint.create({
+			pointA: {
+				x: 0,
+				y: 0
+			},
+			bodyB: this.floater,
+			length: 0,
+			stiffness: e.floatStiffness,
+			damping: e.floatDamping
+		}), this.snapper = n.Bodies.circle(0, 0, 1, {
+			frictionAir: 0,
+			collisionFilter: {
+				group: -1,
+				mask: 0
+			}
+		}), n.Body.setMass(this.snapper, 1), this.snapSpring = n.Constraint.create({
+			pointA: {
+				x: 0,
+				y: 0
+			},
+			bodyB: this.snapper,
+			length: 0,
+			stiffness: e.snapStiffness,
+			damping: e.snapDamping
+		}), n.Composite.add(this.engine.world, [
+			this.flywheel,
+			this.floater,
+			this.floatSpring,
+			this.snapper,
+			this.snapSpring
+		]);
+	}
+	setOptions(e) {
+		this.opts = e, this.flywheel.frictionAir = e.scrambleFriction, this.floatSpring.stiffness = e.floatStiffness, this.floatSpring.damping = e.floatDamping, this.snapSpring.stiffness = e.snapStiffness, this.snapSpring.damping = e.snapDamping;
+	}
+	resetFlywheel() {
+		n.Body.setPosition(this.flywheel, {
+			x: 0,
+			y: 0
+		}), n.Body.setVelocity(this.flywheel, {
+			x: 0,
+			y: 0
+		}), this.spinningUp = !1;
+	}
+	setSpinningUp(e) {
+		this.spinningUp = e;
+	}
+	get scrambleSpeed() {
+		let e = Math.abs(this.flywheel.velocity.x);
+		return Math.min(this.opts.maxSpeed, Math.max(this.opts.minSpeed, e));
+	}
+	get flywheelVelocity() {
+		return this.flywheel.velocity.x;
+	}
+	get quarterTurnsToCoast() {
+		let e = Math.abs(this.flywheel.velocity.x), t = Math.max(1e-4, this.opts.scrambleFriction);
+		return Math.max(0, e - this.opts.minSpeed) / (60 * t) / (Math.PI / 2);
+	}
+	setFloatTarget(e) {
+		this.floatSpring.pointA.y = e;
+	}
+	setBobbing(e) {
+		this.bobbing = e;
+	}
+	get floatY() {
+		return this.floater.position.y;
+	}
+	beginSnap(e, t, r) {
+		n.Body.setPosition(this.snapper, {
+			x: e,
+			y: 0
+		}), n.Body.setVelocity(this.snapper, {
+			x: t / 60,
+			y: 0
+		}), this.snapSpring.pointA.x = r, this.snapping = !0;
+	}
+	endSnap() {
+		this.snapping = !1;
+	}
+	get snapAngle() {
+		return this.snapper.position.x;
+	}
+	get snapTarget() {
+		return this.snapSpring.pointA.x;
+	}
+	get snapSettled() {
+		return this.snapping && Math.abs(this.snapper.position.x - this.snapSpring.pointA.x) < .004 && Math.abs(this.snapper.velocity.x) < .004;
+	}
+	step(e) {
+		this.accumulator += Math.min(e, .1) * 1e3;
+		let t = 0;
+		for (; this.accumulator >= i && t < a;) this.substep(), this.accumulator -= i, t++;
+		t === a && (this.accumulator = 0);
+	}
+	substep() {
+		this.elapsed += i / 1e3;
+		let { opts: e } = this;
+		if (this.spinningUp && n.Body.applyForce(this.flywheel, this.flywheel.position, {
+			x: e.scrambleForce,
+			y: 0
+		}), n.Body.setPosition(this.flywheel, {
+			x: 0,
+			y: 0
+		}), this.bobbing) {
+			let t = 2 * Math.PI * e.floatFrequency, r = Math.sin(this.elapsed * t) * e.floatAmplitude * e.floatStiffness * o;
+			n.Body.applyForce(this.floater, this.floater.position, {
+				x: 0,
+				y: r / 277.8
+			});
+		}
+		n.Body.setPosition(this.floater, {
+			x: 0,
+			y: this.floater.position.y
+		}), n.Engine.update(this.engine, i);
+	}
+	dispose() {
+		n.World.clear(this.engine.world, !1), n.Engine.clear(this.engine);
+	}
+}, c = {
+	R: new e.Vector3(1, 0, 0),
+	L: new e.Vector3(-1, 0, 0),
+	U: new e.Vector3(0, 1, 0),
+	D: new e.Vector3(0, -1, 0),
+	F: new e.Vector3(0, 0, 1),
+	B: new e.Vector3(0, 0, -1)
+};
+function l(t, n) {
+	let r = t / 2, i = new e.Shape();
+	return i.moveTo(-r + n, -r), i.lineTo(r - n, -r), i.quadraticCurveTo(r, -r, r, -r + n), i.lineTo(r, r - n), i.quadraticCurveTo(r, r, r - n, r), i.lineTo(-r + n, r), i.quadraticCurveTo(-r, r, -r, r - n), i.lineTo(-r, -r + n), i.quadraticCurveTo(-r, -r, -r + n, -r), i;
+}
+function u(t) {
+	return new e.MeshPhysicalMaterial({
+		color: new e.Color(t.body),
+		roughness: .42,
+		metalness: 0,
+		clearcoat: .55,
+		clearcoatRoughness: .3,
+		envMapIntensity: .9
+	});
+}
+function d(t, n) {
+	return new e.MeshPhysicalMaterial({
+		color: new e.Color(t),
+		roughness: n,
+		metalness: 0,
+		clearcoat: .9,
+		clearcoatRoughness: .18,
+		envMapIntensity: .9
+	});
+}
+function f(t) {
+	let { size: n, colors: i, sticker: a } = t, o = 1 - t.cubieGap, s = (n - 1) / 2, f = [], p = [], m = new r(o, o, o, 5, t.cubieRounding * o);
+	f.push(m);
+	let h = u(i);
+	p.push(h);
+	let g = .006, _ = a.inset * o - 2 * g, v = new e.ExtrudeGeometry(l(_, a.cornerRadius * o), {
+		depth: Math.max(.002, a.height - g),
+		bevelEnabled: !0,
+		bevelThickness: g,
+		bevelSize: g,
+		bevelSegments: 2,
+		curveSegments: 6
+	});
+	v.computeVertexNormals(), f.push(v);
+	let y = {
+		U: d(i.U, a.roughness),
+		D: d(i.D, a.roughness),
+		F: d(i.F, a.roughness),
+		B: d(i.B, a.roughness),
+		L: d(i.L, a.roughness),
+		R: d(i.R, a.roughness)
+	};
+	p.push(...Object.values(y));
+	let b = [], x = new e.Vector3(0, 0, 1);
+	for (let t = 0; t < n; t++) for (let r = 0; r < n; r++) for (let i = 0; i < n; i++) {
+		let n = t - s, a = r - s, l = i - s;
+		if (Math.abs(n) !== s && Math.abs(a) !== s && Math.abs(l) !== s) continue;
+		let u = new e.Group();
+		u.position.set(n, a, l);
+		let d = new e.Mesh(m, h);
+		d.castShadow = !0, d.receiveShadow = !0, u.add(d);
+		let f = [], p = [];
+		n === s && p.push("R"), n === -s && p.push("L"), a === s && p.push("U"), a === -s && p.push("D"), l === s && p.push("F"), l === -s && p.push("B");
+		for (let t of p) {
+			let n = c[t], r = new e.Mesh(v, y[t]);
+			r.quaternion.setFromUnitVectors(x, n), r.position.copy(n).multiplyScalar(o / 2 - .002), r.castShadow = !1, r.receiveShadow = !0, r.userData.face = t, u.add(r), f.push({
+				face: t,
+				localNormal: n.clone(),
+				mesh: r
+			});
+		}
+		let g = {
+			object: u,
+			body: d,
+			stickers: f,
+			grid: new e.Vector3(n, a, l),
+			home: new e.Vector3(n, a, l)
+		};
+		u.userData.cubie = g, d.userData.cubie = g, b.push(g);
+	}
+	return {
+		cubies: b,
+		resources: {
+			geometries: f,
+			materials: p
+		}
+	};
+}
+function p(t) {
+	let n = new e.Matrix4().makeRotationFromQuaternion(t), r = n.elements;
+	for (let e = 0; e < 16; e++) r[e] = Math.round(r[e]);
+	t.setFromRotationMatrix(n);
+}
+function m(e) {
+	e.x = Math.round(e.x * 2) / 2, e.y = Math.round(e.y * 2) / 2, e.z = Math.round(e.z * 2) / 2, Object.is(e.x, -0) && (e.x = 0), Object.is(e.y, -0) && (e.y = 0), Object.is(e.z, -0) && (e.z = 0);
+}
+//#endregion
+//#region src/core/notation.ts
+var h = {
+	R: {
+		axis: "x",
+		sign: 1,
+		cw: -1
+	},
+	L: {
+		axis: "x",
+		sign: -1,
+		cw: 1
+	},
+	U: {
+		axis: "y",
+		sign: 1,
+		cw: -1
+	},
+	D: {
+		axis: "y",
+		sign: -1,
+		cw: 1
+	},
+	F: {
+		axis: "z",
+		sign: 1,
+		cw: -1
+	},
+	B: {
+		axis: "z",
+		sign: -1,
+		cw: 1
+	}
+}, g = {
+	M: {
+		axis: "x",
+		cw: 1
+	},
+	E: {
+		axis: "y",
+		cw: 1
+	},
+	S: {
+		axis: "z",
+		cw: -1
+	}
+}, _ = {
+	x: {
+		axis: "x",
+		cw: -1
+	},
+	y: {
+		axis: "y",
+		cw: -1
+	},
+	z: {
+		axis: "z",
+		cw: -1
+	}
+}, v = /^(\d*)([UDFBLRudfblrMESxyz])(w?)(['’2]*)$/;
+function y(e) {
+	let t = (e - 1) / 2, n = [];
+	for (let r = 0; r < e; r++) n.push(r - t);
+	return n;
+}
+function b(e) {
+	let t = 1;
+	for (let n of e) t *= n === "2" ? 2 : -1;
+	return t;
+}
+function x(e, t) {
+	let n = (t - 1) / 2, r = [];
+	for (let i of e.trim().split(/\s+/)) {
+		if (!i) continue;
+		let e = v.exec(i);
+		if (!e) throw Error(`rubiks-cube-3d: cannot parse move "${i}"`);
+		let [, a, o, s, c] = e, l = b(c), u = a ? parseInt(a, 10) : 0;
+		if (o === "x" || o === "y" || o === "z") {
+			let e = _[o];
+			r.push({
+				axis: e.axis,
+				layers: y(t),
+				quarterTurns: e.cw * l
+			});
+			continue;
+		}
+		if (o === "M" || o === "E" || o === "S") {
+			let e = g[o], n = t % 2 == 1 ? [0] : [-.5, .5];
+			r.push({
+				axis: e.axis,
+				layers: n,
+				quarterTurns: e.cw * l
+			});
+			continue;
+		}
+		let d = o === o.toLowerCase(), f = h[o.toUpperCase()], p = d || s === "w", m = [];
+		if (p) {
+			let e = Math.min(t - 1, Math.max(2, u || 2));
+			for (let t = 0; t < e; t++) m.push(f.sign * (n - t));
+		} else u > 1 ? m.push(f.sign * (n - Math.min(u, t) + 1)) : m.push(f.sign * n);
+		r.push({
+			axis: f.axis,
+			layers: m,
+			quarterTurns: f.cw * l
+		});
+	}
+	return r;
+}
+function S(e, t) {
+	let n = (t - 1) / 2, r = (e.quarterTurns % 4 + 4) % 4;
+	if (r === 0) return "";
+	let i = (e) => {
+		let t = e * (r === 3 ? -1 : r);
+		return t === 2 || t === -2 ? "2" : t > 0 ? "" : "'";
+	}, a = [...e.layers].sort((e, t) => e - t);
+	if (a.length === t) {
+		let t = _[e.axis];
+		return `${e.axis}${i(t.cw)}`;
+	}
+	let o = a.find((e) => Math.abs(e) === n), s = o === void 0 ? a[a.length - 1] > 0 : o > 0, c = Object.keys(h).find((t) => h[t].axis === e.axis && h[t].sign > 0 === s), l = h[c];
+	if (a.length === 1) {
+		let r = a[0];
+		if (Math.abs(r) === n) return `${c}${i(l.cw)}`;
+		if (t % 2 == 1 && r === 0) {
+			let t = e.axis === "x" ? "M" : e.axis === "y" ? "E" : "S";
+			return `${t}${i(g[t].cw)}`;
+		}
+		return `${Math.round(n - Math.abs(r)) + 1}${c}${i(l.cw)}`;
+	}
+	if (t % 2 == 0 && a.length === 2 && a[0] === -.5 && a[1] === .5) {
+		let t = e.axis === "x" ? "M" : e.axis === "y" ? "E" : "S";
+		return `${t}${i(g[t].cw)}`;
+	}
+	let u = a.length;
+	return `${u > 2 ? u : ""}${c}w${i(l.cw)}`;
+}
+function C(e, t, n = Math.random) {
+	let r = [
+		"x",
+		"y",
+		"z"
+	], i = y(e), a = (e - 1) / 2, o = [], s = null, c = 0;
+	for (let l = 0; l < t; l++) {
+		let t;
+		do
+			t = r[Math.floor(n() * 3)];
+		while (t === s && c >= 1 && n() < .85);
+		c = t === s ? c + 1 : 0, s = t;
+		let l;
+		l = e === 3 || n() < .7 ? n() < .5 ? a : -a : i[Math.floor(n() * i.length)];
+		let u = n() < .15 ? 2 : n() < .5 ? 1 : -1;
+		o.push({
+			axis: t,
+			layers: [l],
+			quarterTurns: u
+		});
+	}
+	return o;
+}
+//#endregion
+//#region src/core/types.ts
+var w = {
+	U: "#ffd60a",
+	D: "#f7f7f7",
+	F: "#e5352b",
+	B: "#ff7f11",
+	L: "#3a7bd5",
+	R: "#3cb44b",
+	body: "#0b0b0d"
+}, T = {
+	scrambleForce: 66e-5,
+	scrambleFriction: .013,
+	maxSpeed: 11,
+	minSpeed: 1.6,
+	floatLift: .22,
+	floatAmplitude: .09,
+	floatFrequency: .45,
+	floatStiffness: .004,
+	floatDamping: .03,
+	idleSpin: .25,
+	idleTumble: .06,
+	snapStiffness: .03,
+	snapDamping: .07
+}, E = {
+	enabled: !0,
+	dragPixelsPerQuarterTurn: 110,
+	orbit: !0,
+	orbitSensitivity: .008,
+	interruptScramble: !1
+}, D = {
+	fov: 32,
+	pitch: 31,
+	yaw: 38
+}, O = {
+	inset: .84,
+	cornerRadius: .09,
+	height: .018,
+	roughness: .28
+}, k = {
+	size: 3,
+	background: "transparent",
+	colors: {},
+	scrambleOnMount: !0,
+	scrambleMoves: 25,
+	scrambleDelay: 350,
+	moveDuration: 260,
+	physics: {},
+	interaction: {},
+	camera: {},
+	sticker: {},
+	shadow: !0,
+	shadowOpacity: .28,
+	shadowMapSize: 2048,
+	cubieRounding: .1,
+	cubieGap: .035,
+	maxPixelRatio: 2,
+	antialias: !0,
+	exposure: 1,
+	idleOnMount: !0
+};
+function A(e) {
+	let t = {};
+	if (!e) return t;
+	for (let n of Object.keys(e)) e[n] !== void 0 && (t[n] = e[n]);
+	return t;
+}
+function j(e = {}) {
+	let t = A(e), n = Math.max(2, Math.min(7, Math.round(t.size ?? k.size)));
+	return {
+		...k,
+		...t,
+		size: n,
+		colors: {
+			...w,
+			...A(t.colors)
+		},
+		physics: {
+			...T,
+			...A(t.physics)
+		},
+		interaction: {
+			...E,
+			...A(t.interaction)
+		},
+		camera: {
+			...D,
+			...A(t.camera)
+		},
+		sticker: {
+			...O,
+			...A(t.sticker)
+		}
+	};
+}
+//#endregion
+//#region src/core/RubiksCubeEngine.ts
+var M = Math.PI / 2, N = {
+	x: new e.Vector3(1, 0, 0),
+	y: new e.Vector3(0, 1, 0),
+	z: new e.Vector3(0, 0, 1)
+}, P = class {
+	constructor(n, r = {}) {
+		this.cubeGroup = new e.Group(), this.cubies = [], this.raycaster = new e.Raycaster(), this.queue = [], this.active = null, this.drag = null, this.scrambleRemaining = 0, this.scrambleResolve = null, this.hovering = !1, this.solved = !0, this.timer = new e.Timer(), this.elapsed = 0, this.rafId = 0, this.disposed = !1, this.touchLeaveTimer = 0, this.listeners = /* @__PURE__ */ new Map(), this.mountTimer = 0, this.squareMode = !1, this.resize = () => {
+			let e = this.container.clientWidth || 300;
+			this.container.clientHeight || (this.squareMode = !0);
+			let t = this.squareMode ? e : this.container.clientHeight;
+			this.canvas.style.height = this.squareMode ? `${e}px` : "100%", this.renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, this.options.maxPixelRatio)), this.renderer.setSize(e, t, !1), this.camera.aspect = e / t, this.camera.updateProjectionMatrix();
+		}, this.tick = () => {
+			if (this.disposed) return;
+			this.rafId = requestAnimationFrame(this.tick), this.timer.update();
+			let e = Math.min(this.timer.getDelta(), .1);
+			this.elapsed += e, this.physics.step(e), this.updateTurn(e), this.updateIdle(e), this.cubeGroup.position.y = this.physics.floatY, this.renderer.render(this.scene, this.camera);
+		}, this.preventDefault = (e) => e.preventDefault(), this.onPointerEnter = (e) => {
+			e.pointerType !== "touch" && (window.clearTimeout(this.touchLeaveTimer), this.setHover(!0));
+		}, this.onPointerLeave = (e) => {
+			e.pointerType !== "touch" && (this.drag || this.setHover(!1));
+		}, this.onPointerDown = (e) => {
+			let t = this.options.interaction;
+			if (!t.enabled || e.pointerType === "mouse" && e.button !== 0 || (e.pointerType === "touch" && (window.clearTimeout(this.touchLeaveTimer), this.setHover(!0)), this.drag)) return;
+			let n = this.state === "scrambling";
+			if (n && !t.interruptScramble) return;
+			let r = this.pickCubie(e);
+			if (r) {
+				if (this.active) {
+					n && this.cancelQueue();
+					return;
+				}
+				this.drag = {
+					pointerId: e.pointerId,
+					startX: e.clientX,
+					startY: e.clientY,
+					lastX: e.clientX,
+					lastY: e.clientY,
+					kind: "undecided",
+					cubie: r.cubie,
+					normal: r.normal,
+					hit: r.point,
+					samples: []
+				};
+			} else if (t.orbit) this.drag = {
+				pointerId: e.pointerId,
+				startX: e.clientX,
+				startY: e.clientY,
+				lastX: e.clientX,
+				lastY: e.clientY,
+				kind: "orbit",
+				samples: []
+			};
+			else return;
+			this.canvas.setPointerCapture(e.pointerId), this.canvas.style.cursor = "grabbing", e.preventDefault();
+		}, this.onPointerMove = (t) => {
+			let n = this.drag;
+			if (!n || n.pointerId !== t.pointerId) {
+				!n && t.pointerType === "mouse" && (this.canvas.style.cursor = this.pickCubie(t) ? "grab" : "default");
+				return;
+			}
+			let r = t.clientX - n.lastX, i = t.clientY - n.lastY;
+			if (n.lastX = t.clientX, n.lastY = t.clientY, n.kind === "orbit") {
+				let t = this.options.interaction.orbitSensitivity, n = new e.Quaternion().setFromAxisAngle(N.y, r * t), a = new e.Quaternion().setFromAxisAngle(N.x, i * t);
+				this.cubeGroup.quaternion.premultiply(n).premultiply(a);
+				return;
+			}
+			let a = t.clientX - n.startX, o = t.clientY - n.startY;
+			if (n.kind === "undecided" && (Math.hypot(a, o) < 6 || (this.decideLayerDrag(n, new e.Vector2(a, o)), n.kind !== "layer"))) return;
+			let s = new e.Vector2(a, o).dot(n.screenDir) / this.options.interaction.dragPixelsPerQuarterTurn * M * n.sign;
+			this.setTurnAngle(s), n.samples.push({
+				t: performance.now(),
+				angle: s
+			}), n.samples.length > 6 && n.samples.shift();
+		}, this.onPointerUp = (e) => {
+			let t = this.drag;
+			if (e.pointerType === "touch" && (window.clearTimeout(this.touchLeaveTimer), this.touchLeaveTimer = window.setTimeout(() => this.setHover(!1), 1500)), t && t.pointerId === e.pointerId) {
+				if (this.drag = null, this.canvas.hasPointerCapture(e.pointerId) && this.canvas.releasePointerCapture(e.pointerId), this.canvas.style.cursor = "grab", t.kind === "layer" && this.active?.mode === "drag") {
+					let e = this.active, n = 0;
+					if (t.samples.length >= 2) {
+						let e = t.samples[0], r = t.samples[t.samples.length - 1], i = r.t - e.t;
+						i > 0 && (n = (r.angle - e.angle) / i * 1e3);
+					}
+					let r = e.angle + n * .12, i = Math.floor(e.angle / M) * M, a = Math.ceil(e.angle / M) * M, o = Math.max(i, Math.min(a, Math.round(r / M) * M));
+					e.mode = "snap", e.target = o, this.physics.beginSnap(e.angle, n, o);
+				}
+				if (e.pointerType === "mouse") {
+					let t = this.canvas.getBoundingClientRect();
+					e.clientX >= t.left && e.clientX <= t.right && e.clientY >= t.top && e.clientY <= t.bottom || this.setHover(!1);
+				}
+			}
+		}, this.container = n, this.options = j(r), this.idleEnabled = this.options.idleOnMount, this.renderer = new e.WebGLRenderer({
+			alpha: !0,
+			antialias: this.options.antialias,
+			powerPreference: "high-performance",
+			premultipliedAlpha: !0
+		}), this.renderer.shadowMap.enabled = !0, this.renderer.shadowMap.type = e.PCFShadowMap, this.renderer.toneMapping = e.NeutralToneMapping, this.renderer.toneMappingExposure = this.options.exposure, this.renderer.outputColorSpace = e.SRGBColorSpace, this.canvas = this.renderer.domElement, Object.assign(this.canvas.style, {
+			display: "block",
+			width: "100%",
+			height: "100%",
+			touchAction: "none",
+			userSelect: "none",
+			cursor: "grab",
+			outline: "none"
+		}), this.canvas.setAttribute("aria-label", "Interactive Rubik's cube"), this.canvas.setAttribute("role", "img"), n.appendChild(this.canvas), this.applyBackground(), this.scene = new e.Scene(), this.pmrem = new e.PMREMGenerator(this.renderer), this.envTexture = this.pmrem.fromScene(new t(), .04).texture, this.scene.environment = this.envTexture, this.scene.environmentIntensity = .7, this.keyLight = new e.DirectionalLight(16777215, 2.4), this.keyLight.position.set(4, 9, 6), this.keyLight.castShadow = !0, this.keyLight.shadow.mapSize.set(this.options.shadowMapSize, this.options.shadowMapSize), this.keyLight.shadow.bias = -4e-4, this.keyLight.shadow.normalBias = .02, this.keyLight.shadow.radius = 4, this.scene.add(this.keyLight), this.scene.add(this.keyLight.target);
+		let i = new e.DirectionalLight(14674175, .55);
+		i.position.set(-6, 2, -4), this.scene.add(i);
+		let a = new e.DirectionalLight(16777215, .35);
+		a.position.set(0, -3, -6), this.scene.add(a), this.scene.add(this.cubeGroup), this.camera = new e.PerspectiveCamera(this.options.camera.fov, 1, .1, 100), this.placeCamera(), this.physics = new s(this.options.physics), this.buildCube(), this.buildShadow(), this.resize(), typeof ResizeObserver < "u" ? (this.resizeObserver = new ResizeObserver(() => this.resize()), this.resizeObserver.observe(n)) : window.addEventListener("resize", this.resize), this.bindPointerEvents();
+		for (let e of [
+			"onMove",
+			"onScrambleStart",
+			"onScrambleEnd",
+			"onSolved",
+			"onStateChange",
+			"onHoverChange"
+		]) {
+			let t = this.options[e];
+			t && this.on(e.slice(2).replace(/^[A-Z]/, (e) => e.toLowerCase()), t);
+		}
+		this.applyIdleState(), this.rafId = requestAnimationFrame(this.tick), this.options.scrambleOnMount && (this.mountTimer = window.setTimeout(() => {
+			this.mountTimer = 0, this.scramble();
+		}, this.options.scrambleDelay));
+	}
+	get state() {
+		return this.scrambleRemaining > 0 || this.active?.mode === "flywheel" ? "scrambling" : this.drag?.kind === "layer" ? "dragging" : this.active?.mode === "snap" ? "snapping" : this.active || this.queue.length ? "animating" : "idle";
+	}
+	get isHovering() {
+		return this.hovering;
+	}
+	isSolved() {
+		return this.solved;
+	}
+	on(e, t) {
+		return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(t), () => this.listeners.get(e)?.delete(t);
+	}
+	off(e, t) {
+		this.listeners.get(e)?.delete(t);
+	}
+	emit(e, ...t) {
+		this.listeners.get(e)?.forEach((e) => {
+			try {
+				e(...t);
+			} catch (e) {
+				console.error(e);
+			}
+		});
+	}
+	scramble(e = this.options.scrambleMoves) {
+		this.cancelQueue(), this.scrambleRemaining > 0 && this.finishScramble();
+		let t = C(this.options.size, e);
+		return this.physics.resetFlywheel(), this.physics.setSpinningUp(!0), this.scrambleRemaining = t.length, this.emit("scrambleStart"), new Promise((e) => {
+			this.scrambleResolve = e;
+			for (let e of t) this.queue.push({
+				turn: e,
+				mode: "flywheel",
+				duration: 0,
+				resolve: () => {}
+			});
+		});
+	}
+	move(e, t = this.options.moveDuration) {
+		let n = x(e, this.options.size);
+		return Promise.all(n.map((e) => this.turn(e, t))).then(() => void 0);
+	}
+	turn(e, t = this.options.moveDuration) {
+		return t <= 0 && !this.active ? (this.applyInstant(e), Promise.resolve()) : new Promise((n) => {
+			this.queue.push({
+				turn: e,
+				mode: "timed",
+				duration: t,
+				resolve: n
+			});
+		});
+	}
+	reset() {
+		this.cancelQueue(), this.abortActive();
+		for (let e of this.cubies) e.grid.copy(e.home), e.object.position.copy(e.home), e.object.quaternion.identity();
+		this.updateSolved(!0);
+	}
+	setHover(e) {
+		this.hovering !== e && (this.hovering = e, this.applyIdleState(), this.emit("hoverChange", e));
+	}
+	setIdle(e) {
+		this.idleEnabled = e, this.applyIdleState();
+	}
+	resetOrientation() {
+		this.cubeGroup.quaternion.identity();
+	}
+	setOptions(e) {
+		let t = this.options, n = A(e);
+		this.options = j({
+			...t,
+			...n,
+			colors: {
+				...t.colors,
+				...A(n.colors)
+			},
+			physics: {
+				...t.physics,
+				...A(n.physics)
+			},
+			interaction: {
+				...t.interaction,
+				...A(n.interaction)
+			},
+			camera: {
+				...t.camera,
+				...A(n.camera)
+			},
+			sticker: {
+				...t.sticker,
+				...A(n.sticker)
+			}
+		});
+		let r = this.options;
+		this.physics.setOptions(r.physics), this.renderer.toneMappingExposure = r.exposure, this.applyBackground(), this.camera.fov = r.camera.fov, this.camera.updateProjectionMatrix(), this.placeCamera(), this.shadowPlane && (this.shadowPlane.material.opacity = r.shadowOpacity), r.shadow !== t.shadow && this.buildShadow(), (r.size !== t.size || r.cubieGap !== t.cubieGap || r.cubieRounding !== t.cubieRounding || JSON.stringify(r.colors) !== JSON.stringify(t.colors) || JSON.stringify(r.sticker) !== JSON.stringify(t.sticker)) && (this.buildCube(), this.buildShadow()), this.applyIdleState();
+	}
+	dispose() {
+		this.disposed || (this.disposed = !0, cancelAnimationFrame(this.rafId), window.clearTimeout(this.mountTimer), window.clearTimeout(this.touchLeaveTimer), this.cancelQueue(), this.resizeObserver?.disconnect(), window.removeEventListener("resize", this.resize), this.unbindPointerEvents(), this.disposeCubies(), this.shadowPlane?.geometry.dispose(), this.shadowPlane?.material.dispose(), this.envTexture.dispose(), this.pmrem.dispose(), this.physics.dispose(), this.renderer.dispose(), this.canvas.remove(), this.listeners.clear());
+	}
+	applyBackground() {
+		let t = (this.options.background ?? "").trim();
+		t && t !== "transparent" && t !== "none" && (typeof CSS > "u" || typeof CSS.supports != "function" || CSS.supports("color", t)) ? (this.renderer.setClearColor(new e.Color(t), 1), this.canvas.style.background = "") : (this.renderer.setClearColor(0, 0), this.canvas.style.background = t && t !== "transparent" && t !== "none" ? t : "");
+	}
+	placeCamera() {
+		let { size: t, camera: n } = this.options, r = n.distance ?? 3.5 * t, i = e.MathUtils.degToRad(n.pitch), a = e.MathUtils.degToRad(n.yaw);
+		this.camera.position.set(r * Math.cos(i) * Math.sin(a), r * Math.sin(i), r * Math.cos(i) * Math.cos(a)), this.camera.lookAt(0, 0, 0);
+	}
+	buildCube() {
+		this.abortActive(), this.disposeCubies();
+		let { cubies: e, resources: t } = f(this.options);
+		this.cubies = e, this.resources = t;
+		for (let t of e) this.cubeGroup.add(t.object);
+		let n = this.options.size, r = this.keyLight.shadow.camera;
+		r.left = r.bottom = -n * 1.4, r.right = r.top = n * 1.4, r.near = 1, r.far = 40, r.updateProjectionMatrix(), this.updateSolved(!0);
+	}
+	disposeCubies() {
+		for (let e of this.cubies) this.cubeGroup.remove(e.object);
+		this.cubies = [], this.resources &&= (this.resources.geometries.forEach((e) => e.dispose()), this.resources.materials.forEach((e) => e.dispose()), void 0);
+	}
+	buildShadow() {
+		if (this.shadowPlane &&= (this.scene.remove(this.shadowPlane), this.shadowPlane.geometry.dispose(), this.shadowPlane.material.dispose(), void 0), !this.options.shadow) return;
+		let t = this.options.size, n = new e.Mesh(new e.PlaneGeometry(t * 6, t * 6), new e.ShadowMaterial({
+			opacity: this.options.shadowOpacity,
+			transparent: !0
+		}));
+		n.rotation.x = -Math.PI / 2, n.position.y = -(t / 2) * 1.05 - .35, n.receiveShadow = !0, this.scene.add(n), this.shadowPlane = n;
+	}
+	updateIdle(t) {
+		if (this.hovering || !this.idleEnabled) return;
+		let n = this.options.physics, r = new e.Quaternion().setFromAxisAngle(N.y, n.idleSpin * t), i = new e.Quaternion().setFromAxisAngle(N.x, Math.sin(this.elapsed * .7) * n.idleTumble * t);
+		this.cubeGroup.quaternion.premultiply(i).premultiply(r);
+	}
+	applyIdleState() {
+		let e = !this.hovering && this.idleEnabled;
+		this.physics.setBobbing(e), this.physics.setFloatTarget(e ? this.options.physics.floatLift : 0);
+	}
+	cubiesInLayers(e, t) {
+		return this.cubies.filter((n) => t.some((t) => Math.abs(n.grid[e] - t) < .001));
+	}
+	beginTurn(t, n, r, i, a, o) {
+		let s = new e.Group();
+		this.cubeGroup.add(s);
+		let c = this.cubiesInLayers(t, n);
+		for (let e of c) s.attach(e.object);
+		let l = {
+			axis: t,
+			layers: n,
+			mode: r,
+			pivot: s,
+			cubies: c,
+			angle: 0,
+			target: i,
+			startedAt: this.elapsed,
+			duration: a,
+			resolve: o
+		};
+		return this.active = l, l;
+	}
+	setTurnAngle(e) {
+		this.active && (this.active.angle = e, this.active.pivot.rotation.set(0, 0, 0), this.active.pivot.rotation[this.active.axis] = e);
+	}
+	completeTurn() {
+		let e = this.active;
+		if (!e) return;
+		let t = Math.round(e.angle / M);
+		this.setTurnAngle(t * M), e.pivot.updateMatrixWorld(!0);
+		for (let t of e.cubies) this.cubeGroup.attach(t.object), m(t.object.position), p(t.object.quaternion), t.grid.copy(t.object.position);
+		if (this.cubeGroup.remove(e.pivot), this.active = null, e.mode === "snap" && this.physics.endSnap(), e.resolve?.(), t !== 0) {
+			let n = {
+				axis: e.axis,
+				layers: e.layers,
+				quarterTurns: t
+			};
+			this.emit("move", n, S(n, this.options.size)), this.updateSolved();
+		}
+		e.mode === "flywheel" && (--this.scrambleRemaining, this.scrambleRemaining <= 0 && this.finishScramble());
+	}
+	abortActive() {
+		let e = this.active;
+		if (e) {
+			this.setTurnAngle(0);
+			for (let t of e.cubies) this.cubeGroup.attach(t.object), t.object.position.copy(t.grid), p(t.object.quaternion);
+			this.cubeGroup.remove(e.pivot), this.active = null, this.physics.endSnap(), e.resolve?.(), e.mode === "flywheel" && this.scrambleRemaining > 0 && this.finishScramble(), this.drag?.kind === "layer" && (this.drag = null);
+		}
+	}
+	applyInstant(e) {
+		this.beginTurn(e.axis, e.layers, "timed", e.quarterTurns * M, 0), this.setTurnAngle(e.quarterTurns * M), this.completeTurn();
+	}
+	cancelQueue() {
+		let e = this.queue;
+		this.queue = [], e.forEach((e) => e.resolve()), this.scrambleRemaining > 0 && (this.active?.mode === "flywheel" ? this.scrambleRemaining = 1 : this.finishScramble());
+	}
+	finishScramble() {
+		this.scrambleRemaining = 0, this.physics.setSpinningUp(!1);
+		let e = this.scrambleResolve;
+		this.scrambleResolve = null, this.emit("scrambleEnd"), e?.();
+	}
+	updateTurn(e) {
+		if (!this.active && this.queue.length && this.drag?.kind !== "layer") {
+			let e = this.queue.shift(), t = e.turn.quarterTurns * M;
+			this.beginTurn(e.turn.axis, e.turn.layers, e.mode, t, e.duration / 1e3, e.resolve);
+		}
+		let t = this.active;
+		if (t) switch (t.mode) {
+			case "timed": {
+				let e = t.duration > 0 ? Math.min(1, (this.elapsed - t.startedAt) / t.duration) : 1, n = e < .5 ? 4 * e * e * e : 1 - (-2 * e + 2) ** 3 / 2;
+				this.setTurnAngle(t.target * n), e >= 1 && this.completeTurn();
+				break;
+			}
+			case "flywheel": {
+				let n = this.scrambleRemaining - Math.abs(t.angle) / M;
+				this.physics.setSpinningUp(n > this.physics.quarterTurnsToCoast + .6);
+				let r = Math.sign(t.target), i = t.angle + r * this.physics.scrambleSpeed * e;
+				Math.abs(i) >= Math.abs(t.target) ? (this.setTurnAngle(t.target), this.completeTurn()) : this.setTurnAngle(i);
+				break;
+			}
+			case "drag": break;
+			case "snap": this.setTurnAngle(this.physics.snapAngle), this.physics.snapSettled && (this.setTurnAngle(this.physics.snapTarget), this.completeTurn());
+		}
+	}
+	updateSolved(e) {
+		let t = e ?? this.computeSolved(), n = t !== this.solved;
+		this.solved = t, (n || e !== void 0) && this.emit("stateChange", t), n && t && this.emit("solved");
+	}
+	computeSolved() {
+		let t = /* @__PURE__ */ new Map(), n = new e.Vector3();
+		for (let e of this.cubies) for (let r of e.stickers) {
+			n.copy(r.localNormal).applyQuaternion(e.object.quaternion);
+			let i = `${Math.round(n.x)},${Math.round(n.y)},${Math.round(n.z)}`, a = t.get(i);
+			if (a === void 0) t.set(i, r.face);
+			else if (a !== r.face) return !1;
+		}
+		return !0;
+	}
+	bindPointerEvents() {
+		let e = this.canvas;
+		e.addEventListener("pointerdown", this.onPointerDown), e.addEventListener("pointermove", this.onPointerMove), e.addEventListener("pointerup", this.onPointerUp), e.addEventListener("pointercancel", this.onPointerUp), e.addEventListener("pointerenter", this.onPointerEnter), e.addEventListener("pointerleave", this.onPointerLeave), e.addEventListener("contextmenu", this.preventDefault);
+	}
+	unbindPointerEvents() {
+		let e = this.canvas;
+		e.removeEventListener("pointerdown", this.onPointerDown), e.removeEventListener("pointermove", this.onPointerMove), e.removeEventListener("pointerup", this.onPointerUp), e.removeEventListener("pointercancel", this.onPointerUp), e.removeEventListener("pointerenter", this.onPointerEnter), e.removeEventListener("pointerleave", this.onPointerLeave), e.removeEventListener("contextmenu", this.preventDefault);
+	}
+	pointerNdc(t) {
+		let n = this.canvas.getBoundingClientRect();
+		return new e.Vector2((t.clientX - n.left) / n.width * 2 - 1, -((t.clientY - n.top) / n.height) * 2 + 1);
+	}
+	pickCubie(e) {
+		this.raycaster.setFromCamera(this.pointerNdc(e), this.camera);
+		let t = this.raycaster.intersectObjects(this.cubies.map((e) => e.body), !1)[0];
+		if (!t || !t.face) return null;
+		let n = t.object.userData.cubie, r = t.face.normal.clone().applyQuaternion(n.object.quaternion), i = Math.abs(r.x), a = Math.abs(r.y), o = Math.abs(r.z);
+		return i >= a && i >= o ? r.set(Math.sign(r.x), 0, 0) : a >= i && a >= o ? r.set(0, Math.sign(r.y), 0) : r.set(0, 0, Math.sign(r.z)), {
+			cubie: n,
+			normal: r,
+			point: this.cubeGroup.worldToLocal(t.point.clone())
+		};
+	}
+	toScreen(t) {
+		let n = this.canvas.getBoundingClientRect(), r = this.cubeGroup.localToWorld(t.clone()).project(this.camera);
+		return new e.Vector2((r.x + 1) / 2 * n.width, (1 - r.y) / 2 * n.height);
+	}
+	decideLayerDrag(t, n) {
+		let r = t.normal, i = t.hit, a = t.cubie;
+		if (this.active) return;
+		let o = [
+			"x",
+			"y",
+			"z"
+		].filter((e) => Math.abs(r[e]) < .5).map((e) => N[e].clone()), s = this.toScreen(i), c = null;
+		for (let e of o) {
+			let t = this.toScreen(i.clone().addScaledVector(e, .5)).sub(s);
+			if (t.lengthSq() < 1e-6) continue;
+			t.normalize();
+			let r = n.clone().normalize().dot(t);
+			(!c || Math.abs(r) > Math.abs(c.dot)) && (c = {
+				t: e,
+				dir: t,
+				dot: r
+			});
+		}
+		if (!c) {
+			this.drag = null;
+			return;
+		}
+		let l = new e.Vector3().crossVectors(r, c.t), u = Math.abs(l.x) > .5 ? "x" : Math.abs(l.y) > .5 ? "y" : "z", d = l[u] > 0 ? 1 : -1, f = a.grid[u];
+		t.kind = "layer", t.screenDir = c.dir, t.sign = d, this.beginTurn(u, [f], "drag", 0, 0);
+	}
+};
+//#endregion
+//#region src/core/mount.ts
+function F(e, t = {}) {
+	let n = typeof e == "string" ? document.querySelector(e) : e;
+	if (!n) throw Error(`rubiks-cube-3d: container not found (${String(e)})`);
+	let r = new P(n, t);
+	return {
+		engine: r,
+		scramble: (e) => r.scramble(e),
+		move: (e, t) => r.move(e, t),
+		turn: (e, t) => r.turn(e, t),
+		reset: () => r.reset(),
+		resetOrientation: () => r.resetOrientation(),
+		isSolved: () => r.isSolved(),
+		get state() {
+			return r.state;
+		},
+		setHover: (e) => r.setHover(e),
+		setIdle: (e) => r.setIdle(e),
+		setOptions: (e) => r.setOptions(e),
+		on: (e, t) => r.on(e, t),
+		destroy: () => r.dispose()
+	};
+}
+//#endregion
+export { E as a, O as c, x as d, C as f, w as i, j as l, s as m, P as n, k as o, S as p, D as r, T as s, F as t, y as u };
+
+//# sourceMappingURL=core-L1AjC-fV.js.map