@seayoo-web/pixi-live2d 0.1.0 → 0.1.1

package/dist/cubism4.es-B18JJVJM.js

@@ -0,0 +1,3116 @@
+import { Bt as e, Kt as t, Lt as n, Rt as r, dn as i, jt as a, nn as o, nt as s } from "./core-DiacFOEI.js";
+//#region ../../node_modules/.pnpm/pixi-live2d-display@0.4.0_d39e0d9e955e28505b3b8642eca0c111/node_modules/pixi-live2d-display/dist/cubism4.es.js
+var c = Math.pow, l = (e, t, n) => new Promise((r, i) => {
+	var a = (e) => {
+		try {
+			s(n.next(e));
+		} catch (e) {
+			i(e);
+		}
+	}, o = (e) => {
+		try {
+			s(n.throw(e));
+		} catch (e) {
+			i(e);
+		}
+	}, s = (e) => e.done ? r(e.value) : Promise.resolve(e.value).then(a, o);
+	s((n = n.apply(e, t)).next());
+}), u = class e {
+	constructor() {
+		this._breathParameters = [], this._currentTime = 0;
+	}
+	static create() {
+		return new e();
+	}
+	setParameters(e) {
+		this._breathParameters = e;
+	}
+	getParameters() {
+		return this._breathParameters;
+	}
+	updateParameters(e, t) {
+		this._currentTime += t;
+		let n = this._currentTime * 2 * 3.14159;
+		for (let t = 0; t < this._breathParameters.length; ++t) {
+			let r = this._breathParameters[t];
+			e.addParameterValueById(r.parameterId, r.offset + r.peak * Math.sin(n / r.cycle), r.weight);
+		}
+	}
+}, d = class {
+	constructor(e, t, n, r, i) {
+		this.parameterId = e ?? void 0, this.offset = t ?? 0, this.peak = n ?? 0, this.cycle = r ?? 0, this.weight = i ?? 0;
+	}
+}, f = class {
+	static create(e) {
+		return new f(e);
+	}
+	setBlinkingInterval(e) {
+		this._blinkingIntervalSeconds = e;
+	}
+	setBlinkingSetting(e, t, n) {
+		this._closingSeconds = e, this._closedSeconds = t, this._openingSeconds = n;
+	}
+	setParameterIds(e) {
+		this._parameterIds = e;
+	}
+	getParameterIds() {
+		return this._parameterIds;
+	}
+	updateParameters(e, t) {
+		this._userTimeSeconds += t;
+		let n, r = 0;
+		switch (this._blinkingState) {
+			case m.EyeState_Closing:
+				r = (this._userTimeSeconds - this._stateStartTimeSeconds) / this._closingSeconds, r >= 1 && (r = 1, this._blinkingState = m.EyeState_Closed, this._stateStartTimeSeconds = this._userTimeSeconds), n = 1 - r;
+				break;
+			case m.EyeState_Closed:
+				r = (this._userTimeSeconds - this._stateStartTimeSeconds) / this._closedSeconds, r >= 1 && (this._blinkingState = m.EyeState_Opening, this._stateStartTimeSeconds = this._userTimeSeconds), n = 0;
+				break;
+			case m.EyeState_Opening:
+				r = (this._userTimeSeconds - this._stateStartTimeSeconds) / this._openingSeconds, r >= 1 && (r = 1, this._blinkingState = m.EyeState_Interval, this._nextBlinkingTime = this.determinNextBlinkingTiming()), n = r;
+				break;
+			case m.EyeState_Interval:
+				this._nextBlinkingTime < this._userTimeSeconds && (this._blinkingState = m.EyeState_Closing, this._stateStartTimeSeconds = this._userTimeSeconds), n = 1;
+				break;
+			case m.EyeState_First:
+			default:
+				this._blinkingState = m.EyeState_Interval, this._nextBlinkingTime = this.determinNextBlinkingTiming(), n = 1;
+				break;
+		}
+		f.CloseIfZero || (n = -n);
+		for (let t = 0; t < this._parameterIds.length; ++t) e.setParameterValueById(this._parameterIds[t], n);
+	}
+	constructor(e) {
+		this._blinkingState = m.EyeState_First, this._nextBlinkingTime = 0, this._stateStartTimeSeconds = 0, this._blinkingIntervalSeconds = 4, this._closingSeconds = .1, this._closedSeconds = .05, this._openingSeconds = .15, this._userTimeSeconds = 0, this._parameterIds = [], e != null && (this._parameterIds = e.getEyeBlinkParameters()?.slice() ?? this._parameterIds);
+	}
+	determinNextBlinkingTiming() {
+		let e = Math.random();
+		return this._userTimeSeconds + e * (2 * this._blinkingIntervalSeconds - 1);
+	}
+}, p = f;
+p.CloseIfZero = !0;
+var m = /* @__PURE__ */ ((e) => (e[e.EyeState_First = 0] = "EyeState_First", e[e.EyeState_Interval = 1] = "EyeState_Interval", e[e.EyeState_Closing = 2] = "EyeState_Closing", e[e.EyeState_Closed = 3] = "EyeState_Closed", e[e.EyeState_Opening = 4] = "EyeState_Opening", e))(m || {}), h = .001, g = .5, _ = class e {
+	static create(t) {
+		let n = new e();
+		typeof t.FadeInTime == "number" && (n._fadeTimeSeconds = t.FadeInTime, n._fadeTimeSeconds <= 0 && (n._fadeTimeSeconds = g));
+		let r = t.Groups, i = r.length;
+		for (let e = 0; e < i; ++e) {
+			let t = r[e], i = t.length, a = 0;
+			for (let e = 0; e < i; ++e) {
+				let r = t[e], i = new ee();
+				i.partId = r.Id;
+				let o = r.Link;
+				if (o) {
+					let e = o.length;
+					for (let t = 0; t < e; ++t) {
+						let e = new ee();
+						e.partId = o[t], i.link.push(e);
+					}
+				}
+				n._partGroups.push(i), ++a;
+			}
+			n._partGroupCounts.push(a);
+		}
+		return n;
+	}
+	updateParameters(e, t) {
+		e != this._lastModel && this.reset(e), this._lastModel = e, t < 0 && (t = 0);
+		let n = 0;
+		for (let r = 0; r < this._partGroupCounts.length; r++) {
+			let i = this._partGroupCounts[r];
+			this.doFade(e, t, n, i), n += i;
+		}
+		this.copyPartOpacities(e);
+	}
+	reset(e) {
+		let t = 0;
+		for (let n = 0; n < this._partGroupCounts.length; ++n) {
+			let r = this._partGroupCounts[n];
+			for (let n = t; n < t + r; ++n) {
+				this._partGroups[n].initialize(e);
+				let r = this._partGroups[n].partIndex, i = this._partGroups[n].parameterIndex;
+				if (!(r < 0)) {
+					e.setPartOpacityByIndex(r, +(n == t)), e.setParameterValueByIndex(i, +(n == t));
+					for (let t = 0; t < this._partGroups[n].link.length; ++t) this._partGroups[n].link[t].initialize(e);
+				}
+			}
+			t += r;
+		}
+	}
+	copyPartOpacities(e) {
+		for (let t = 0; t < this._partGroups.length; ++t) {
+			let n = this._partGroups[t];
+			if (n.link.length == 0) continue;
+			let r = this._partGroups[t].partIndex, i = e.getPartOpacityByIndex(r);
+			for (let t = 0; t < n.link.length; ++t) {
+				let r = n.link[t].partIndex;
+				r < 0 || e.setPartOpacityByIndex(r, i);
+			}
+		}
+	}
+	doFade(e, t, n, r) {
+		let i = -1, a = 1, o = .5, s = .15;
+		for (let o = n; o < n + r; ++o) {
+			let n = this._partGroups[o].partIndex, r = this._partGroups[o].parameterIndex;
+			if (e.getParameterValueByIndex(r) > h) {
+				if (i >= 0) break;
+				i = o, a = e.getPartOpacityByIndex(n), a += t / this._fadeTimeSeconds, a > 1 && (a = 1);
+			}
+		}
+		i < 0 && (i = 0, a = 1);
+		for (let t = n; t < n + r; ++t) {
+			let n = this._partGroups[t].partIndex;
+			if (i == t) e.setPartOpacityByIndex(n, a);
+			else {
+				let t = e.getPartOpacityByIndex(n), r;
+				r = a < o ? a * (o - 1) / o + 1 : (1 - a) * o / (1 - o), (1 - r) * (1 - a) > s && (r = 1 - s / (1 - a)), t > r && (t = r), e.setPartOpacityByIndex(n, t);
+			}
+		}
+	}
+	constructor() {
+		this._fadeTimeSeconds = g, this._lastModel = void 0, this._partGroups = [], this._partGroupCounts = [];
+	}
+}, ee = class e {
+	constructor(e) {
+		this.parameterIndex = 0, this.partIndex = 0, this.partId = "", this.link = [], e != null && this.assignment(e);
+	}
+	assignment(e) {
+		return this.partId = e.partId, this.link = e.link.map((e) => e.clone()), this;
+	}
+	initialize(e) {
+		this.parameterIndex = e.getParameterIndex(this.partId), this.partIndex = e.getPartIndex(this.partId), e.setParameterValueByIndex(this.parameterIndex, 1);
+	}
+	clone() {
+		let t = new e();
+		return t.partId = this.partId, t.parameterIndex = this.parameterIndex, t.partIndex = this.partIndex, t.link = this.link.map((e) => e.clone()), t;
+	}
+}, v = class e {
+	constructor(e, t) {
+		this.x = e || 0, this.y = t || 0;
+	}
+	add(t) {
+		let n = new e(0, 0);
+		return n.x = this.x + t.x, n.y = this.y + t.y, n;
+	}
+	substract(t) {
+		let n = new e(0, 0);
+		return n.x = this.x - t.x, n.y = this.y - t.y, n;
+	}
+	multiply(t) {
+		let n = new e(0, 0);
+		return n.x = this.x * t.x, n.y = this.y * t.y, n;
+	}
+	multiplyByScaler(t) {
+		return this.multiply(new e(t, t));
+	}
+	division(t) {
+		let n = new e(0, 0);
+		return n.x = this.x / t.x, n.y = this.y / t.y, n;
+	}
+	divisionByScalar(t) {
+		return this.division(new e(t, t));
+	}
+	getLength() {
+		return Math.sqrt(this.x * this.x + this.y * this.y);
+	}
+	getDistanceWith(e) {
+		return Math.sqrt((this.x - e.x) * (this.x - e.x) + (this.y - e.y) * (this.y - e.y));
+	}
+	dot(e) {
+		return this.x * e.x + this.y * e.y;
+	}
+	normalize() {
+		let e = (this.x * this.x + this.y * this.y) ** .5;
+		this.x /= e, this.y /= e;
+	}
+	isEqual(e) {
+		return this.x == e.x && this.y == e.y;
+	}
+	isNotEqual(e) {
+		return !this.isEqual(e);
+	}
+}, te = class {
+	static range(e, t, n) {
+		return e < t ? e = t : e > n && (e = n), e;
+	}
+	static sin(e) {
+		return Math.sin(e);
+	}
+	static cos(e) {
+		return Math.cos(e);
+	}
+	static abs(e) {
+		return Math.abs(e);
+	}
+	static sqrt(e) {
+		return Math.sqrt(e);
+	}
+	static cbrt(e) {
+		if (e === 0) return e;
+		let t = e, n = t < 0;
+		n && (t = -t);
+		let r;
+		return t === Infinity ? r = Infinity : (r = Math.exp(Math.log(t) / 3), r = (t / (r * r) + 2 * r) / 3), n ? -r : r;
+	}
+	static getEasingSine(e) {
+		return e < 0 ? 0 : e > 1 ? 1 : .5 - .5 * this.cos(e * Math.PI);
+	}
+	static max(e, t) {
+		return e > t ? e : t;
+	}
+	static min(e, t) {
+		return e > t ? t : e;
+	}
+	static degreesToRadian(e) {
+		return e / 180 * Math.PI;
+	}
+	static radianToDegrees(e) {
+		return e * 180 / Math.PI;
+	}
+	static directionToRadian(e, t) {
+		let n = Math.atan2(t.y, t.x) - Math.atan2(e.y, e.x);
+		for (; n < -Math.PI;) n += Math.PI * 2;
+		for (; n > Math.PI;) n -= Math.PI * 2;
+		return n;
+	}
+	static directionToDegrees(e, t) {
+		let n = this.directionToRadian(e, t), r = this.radianToDegrees(n);
+		return t.x - e.x > 0 && (r = -r), r;
+	}
+	static radianToDirection(e) {
+		let t = new v();
+		return t.x = this.sin(e), t.y = this.cos(e), t;
+	}
+	static quadraticEquation(e, t, n) {
+		return this.abs(e) < te.Epsilon ? this.abs(t) < te.Epsilon ? -n : -n / t : -(t + this.sqrt(t * t - 4 * e * n)) / (2 * e);
+	}
+	static cardanoAlgorithmForBezier(e, t, n, r) {
+		if (this.sqrt(e) < te.Epsilon) return this.range(this.quadraticEquation(t, n, r), 0, 1);
+		let i = t / e, a = n / e, o = r / e, s = (3 * a - i * i) / 3, c = s / 3, l = (2 * i * i * i - 9 * i * a + 27 * o) / 27, u = l / 2, d = u * u + c * c * c, f = .5, p = f + .01;
+		if (d < 0) {
+			let e = -s / 3, t = e * e * e, n = this.sqrt(t), r = -l / (2 * n), a = this.range(r, -1, 1), o = Math.acos(a), c = 2 * this.cbrt(n), u = c * this.cos(o / 3) - i / 3;
+			if (this.abs(u - f) < p) return this.range(u, 0, 1);
+			let d = c * this.cos((o + 2 * Math.PI) / 3) - i / 3;
+			if (this.abs(d - f) < p) return this.range(d, 0, 1);
+			let m = c * this.cos((o + 4 * Math.PI) / 3) - i / 3;
+			return this.range(m, 0, 1);
+		}
+		if (d == 0) {
+			let e;
+			e = u < 0 ? this.cbrt(-u) : -this.cbrt(u);
+			let t = 2 * e - i / 3;
+			if (this.abs(t - f) < p) return this.range(t, 0, 1);
+			let n = -e - i / 3;
+			return this.range(n, 0, 1);
+		}
+		let m = this.sqrt(d), h = this.cbrt(m - u) - this.cbrt(m + u) - i / 3;
+		return this.range(h, 0, 1);
+	}
+	constructor() {}
+}, y = te;
+y.Epsilon = 1e-5;
+var b = class e {
+	constructor() {
+		this._tr = new Float32Array(16), this.loadIdentity();
+	}
+	static multiply(e, t, n) {
+		let r = new Float32Array([
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0,
+			0
+		]);
+		for (let n = 0; n < 4; ++n) for (let i = 0; i < 4; ++i) for (let a = 0; a < 4; ++a) r[i + n * 4] += e[a + n * 4] * t[i + a * 4];
+		for (let e = 0; e < 16; ++e) n[e] = r[e];
+	}
+	loadIdentity() {
+		let e = new Float32Array([
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		]);
+		this.setMatrix(e);
+	}
+	setMatrix(e) {
+		for (let t = 0; t < 16; ++t) this._tr[t] = e[t];
+	}
+	getArray() {
+		return this._tr;
+	}
+	getScaleX() {
+		return this._tr[0];
+	}
+	getScaleY() {
+		return this._tr[5];
+	}
+	getTranslateX() {
+		return this._tr[12];
+	}
+	getTranslateY() {
+		return this._tr[13];
+	}
+	transformX(e) {
+		return this._tr[0] * e + this._tr[12];
+	}
+	transformY(e) {
+		return this._tr[5] * e + this._tr[13];
+	}
+	invertTransformX(e) {
+		return (e - this._tr[12]) / this._tr[0];
+	}
+	invertTransformY(e) {
+		return (e - this._tr[13]) / this._tr[5];
+	}
+	translateRelative(t, n) {
+		let r = new Float32Array([
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			t,
+			n,
+			0,
+			1
+		]);
+		e.multiply(r, this._tr, this._tr);
+	}
+	translate(e, t) {
+		this._tr[12] = e, this._tr[13] = t;
+	}
+	translateX(e) {
+		this._tr[12] = e;
+	}
+	translateY(e) {
+		this._tr[13] = e;
+	}
+	scaleRelative(t, n) {
+		let r = new Float32Array([
+			t,
+			0,
+			0,
+			0,
+			0,
+			n,
+			0,
+			0,
+			0,
+			0,
+			1,
+			0,
+			0,
+			0,
+			0,
+			1
+		]);
+		e.multiply(r, this._tr, this._tr);
+	}
+	scale(e, t) {
+		this._tr[0] = e, this._tr[5] = t;
+	}
+	multiplyByMatrix(t) {
+		e.multiply(t.getArray(), this._tr, this._tr);
+	}
+	clone() {
+		let t = new e();
+		for (let e = 0; e < this._tr.length; e++) t._tr[e] = this._tr[e];
+		return t;
+	}
+}, ne = class {
+	initialize(e) {
+		this._model = e;
+	}
+	drawModel() {
+		this.getModel() != null && this.doDrawModel();
+	}
+	setMvpMatrix(e) {
+		this._mvpMatrix4x4.setMatrix(e.getArray());
+	}
+	getMvpMatrix() {
+		return this._mvpMatrix4x4;
+	}
+	setModelColor(e, t, n, r) {
+		e < 0 ? e = 0 : e > 1 && (e = 1), t < 0 ? t = 0 : t > 1 && (t = 1), n < 0 ? n = 0 : n > 1 && (n = 1), r < 0 ? r = 0 : r > 1 && (r = 1), this._modelColor.R = e, this._modelColor.G = t, this._modelColor.B = n, this._modelColor.A = r;
+	}
+	getModelColor() {
+		return Object.assign({}, this._modelColor);
+	}
+	setIsPremultipliedAlpha(e) {
+		this._isPremultipliedAlpha = e;
+	}
+	isPremultipliedAlpha() {
+		return this._isPremultipliedAlpha;
+	}
+	setIsCulling(e) {
+		this._isCulling = e;
+	}
+	isCulling() {
+		return this._isCulling;
+	}
+	setAnisotropy(e) {
+		this._anisortopy = e;
+	}
+	getAnisotropy() {
+		return this._anisortopy;
+	}
+	getModel() {
+		return this._model;
+	}
+	constructor() {
+		this._isCulling = !1, this._isPremultipliedAlpha = !1, this._anisortopy = 0, this._modelColor = new S(), this._mvpMatrix4x4 = new b(), this._mvpMatrix4x4.loadIdentity();
+	}
+}, x = /* @__PURE__ */ ((e) => (e[e.CubismBlendMode_Normal = 0] = "CubismBlendMode_Normal", e[e.CubismBlendMode_Additive = 1] = "CubismBlendMode_Additive", e[e.CubismBlendMode_Multiplicative = 2] = "CubismBlendMode_Multiplicative", e))(x || {}), S = class {
+	constructor() {
+		this.R = 1, this.G = 1, this.B = 1, this.A = 1;
+	}
+}, C = !1, w = !1, T = void 0, re = {
+	vertexOffset: 0,
+	vertexStep: 2
+}, E = class {
+	static startUp(e) {
+		if (C) return O("CubismFramework.startUp() is already done."), C;
+		if (Live2DCubismCore._isStarted) return C = !0, !0;
+		if (Live2DCubismCore._isStarted = !0, T = e, T && Live2DCubismCore.Logging.csmSetLogFunction(T.logFunction), C = !0, C) {
+			let e = Live2DCubismCore.Version.csmGetVersion(), t = (e & 4278190080) >> 24, n = (e & 16711680) >> 16, r = e & 65535, i = e;
+			O("Live2D Cubism Core version: {0}.{1}.{2} ({3})", ("00" + t).slice(-2), ("00" + n).slice(-2), ("0000" + r).slice(-4), i);
+		}
+		return O("CubismFramework.startUp() is complete."), C;
+	}
+	static cleanUp() {
+		C = !1, w = !1, T = void 0;
+	}
+	static initialize() {
+		if (!C) {
+			k("CubismFramework is not started.");
+			return;
+		}
+		if (w) {
+			k("CubismFramework.initialize() skipped, already initialized.");
+			return;
+		}
+		w = !0, O("CubismFramework.initialize() is complete.");
+	}
+	static dispose() {
+		if (!C) {
+			k("CubismFramework is not started.");
+			return;
+		}
+		if (!w) {
+			k("CubismFramework.dispose() skipped, not initialized.");
+			return;
+		}
+		ne.staticRelease(), w = !1, O("CubismFramework.dispose() is complete.");
+	}
+	static isStarted() {
+		return C;
+	}
+	static isInitialized() {
+		return w;
+	}
+	static coreLogFunction(e) {
+		Live2DCubismCore.Logging.csmGetLogFunction() && Live2DCubismCore.Logging.csmGetLogFunction()(e);
+	}
+	static getLoggingLevel() {
+		return T == null ? D.LogLevel_Off : T.loggingLevel;
+	}
+	constructor() {}
+}, D = /* @__PURE__ */ ((e) => (e[e.LogLevel_Verbose = 0] = "LogLevel_Verbose", e[e.LogLevel_Debug = 1] = "LogLevel_Debug", e[e.LogLevel_Info = 2] = "LogLevel_Info", e[e.LogLevel_Warning = 3] = "LogLevel_Warning", e[e.LogLevel_Error = 4] = "LogLevel_Error", e[e.LogLevel_Off = 5] = "LogLevel_Off", e))(D || {}), ie = () => {};
+function ae(e, ...t) {
+	j.print(D.LogLevel_Verbose, "[CSM][V]" + e + "\n", t);
+}
+function oe(e, ...t) {
+	j.print(D.LogLevel_Debug, "[CSM][D]" + e + "\n", t);
+}
+function O(e, ...t) {
+	j.print(D.LogLevel_Info, "[CSM][I]" + e + "\n", t);
+}
+function k(e, ...t) {
+	j.print(D.LogLevel_Warning, "[CSM][W]" + e + "\n", t);
+}
+function A(e, ...t) {
+	j.print(D.LogLevel_Error, "[CSM][E]" + e + "\n", t);
+}
+var j = class {
+	static print(e, t, n) {
+		if (e < E.getLoggingLevel()) return;
+		let r = E.coreLogFunction;
+		r && r(t.replace(/{(\d+)}/g, (e, t) => n[t]));
+	}
+	static dumpBytes(e, t, n) {
+		for (let r = 0; r < n; r++) r % 16 == 0 && r > 0 ? this.print(e, "\n") : r % 8 == 0 && r > 0 && this.print(e, "  "), this.print(e, "{0} ", [t[r] & 255]);
+		this.print(e, "\n");
+	}
+	constructor() {}
+}, se = class {
+	update() {
+		this._model.update(), this._model.drawables.resetDynamicFlags();
+	}
+	getCanvasWidth() {
+		return this._model == null ? 0 : this._model.canvasinfo.CanvasWidth / this._model.canvasinfo.PixelsPerUnit;
+	}
+	getCanvasHeight() {
+		return this._model == null ? 0 : this._model.canvasinfo.CanvasHeight / this._model.canvasinfo.PixelsPerUnit;
+	}
+	saveParameters() {
+		let e = this._model.parameters.count, t = this._savedParameters.length;
+		for (let n = 0; n < e; ++n) n < t ? this._savedParameters[n] = this._parameterValues[n] : this._savedParameters.push(this._parameterValues[n]);
+	}
+	getModel() {
+		return this._model;
+	}
+	getPartIndex(e) {
+		let t, n = this._model.parts.count;
+		for (t = 0; t < n; ++t) if (e == this._partIds[t]) return t;
+		return e in this._notExistPartId ? this._notExistPartId[e] : (t = n + this._notExistPartId.length, this._notExistPartId[e] = t, this._notExistPartOpacities[t] = 0, t);
+	}
+	getPartCount() {
+		return this._model.parts.count;
+	}
+	setPartOpacityByIndex(e, t) {
+		if (e in this._notExistPartOpacities) {
+			this._notExistPartOpacities[e] = t;
+			return;
+		}
+		0 <= e && this.getPartCount(), this._partOpacities[e] = t;
+	}
+	setPartOpacityById(e, t) {
+		let n = this.getPartIndex(e);
+		n < 0 || this.setPartOpacityByIndex(n, t);
+	}
+	getPartOpacityByIndex(e) {
+		return e in this._notExistPartOpacities ? this._notExistPartOpacities[e] : (0 <= e && this.getPartCount(), this._partOpacities[e]);
+	}
+	getPartOpacityById(e) {
+		let t = this.getPartIndex(e);
+		return t < 0 ? 0 : this.getPartOpacityByIndex(t);
+	}
+	getParameterIndex(e) {
+		let t, n = this._model.parameters.count;
+		for (t = 0; t < n; ++t) if (e == this._parameterIds[t]) return t;
+		return e in this._notExistParameterId ? this._notExistParameterId[e] : (t = this._model.parameters.count + Object.keys(this._notExistParameterId).length, this._notExistParameterId[e] = t, this._notExistParameterValues[t] = 0, t);
+	}
+	getParameterCount() {
+		return this._model.parameters.count;
+	}
+	getParameterMaximumValue(e) {
+		return this._model.parameters.maximumValues[e];
+	}
+	getParameterMinimumValue(e) {
+		return this._model.parameters.minimumValues[e];
+	}
+	getParameterDefaultValue(e) {
+		return this._model.parameters.defaultValues[e];
+	}
+	getParameterValueByIndex(e) {
+		return e in this._notExistParameterValues ? this._notExistParameterValues[e] : (0 <= e && this.getParameterCount(), this._parameterValues[e]);
+	}
+	getParameterValueById(e) {
+		let t = this.getParameterIndex(e);
+		return this.getParameterValueByIndex(t);
+	}
+	setParameterValueByIndex(e, t, n = 1) {
+		if (e in this._notExistParameterValues) {
+			this._notExistParameterValues[e] = n == 1 ? t : this._notExistParameterValues[e] * (1 - n) + t * n;
+			return;
+		}
+		0 <= e && this.getParameterCount(), this._model.parameters.maximumValues[e] < t && (t = this._model.parameters.maximumValues[e]), this._model.parameters.minimumValues[e] > t && (t = this._model.parameters.minimumValues[e]), this._parameterValues[e] = n == 1 ? t : this._parameterValues[e] = this._parameterValues[e] * (1 - n) + t * n;
+	}
+	setParameterValueById(e, t, n = 1) {
+		let r = this.getParameterIndex(e);
+		this.setParameterValueByIndex(r, t, n);
+	}
+	addParameterValueByIndex(e, t, n = 1) {
+		this.setParameterValueByIndex(e, this.getParameterValueByIndex(e) + t * n);
+	}
+	addParameterValueById(e, t, n = 1) {
+		let r = this.getParameterIndex(e);
+		this.addParameterValueByIndex(r, t, n);
+	}
+	multiplyParameterValueById(e, t, n = 1) {
+		let r = this.getParameterIndex(e);
+		this.multiplyParameterValueByIndex(r, t, n);
+	}
+	multiplyParameterValueByIndex(e, t, n = 1) {
+		this.setParameterValueByIndex(e, this.getParameterValueByIndex(e) * (1 + (t - 1) * n));
+	}
+	getDrawableIds() {
+		return this._drawableIds.slice();
+	}
+	getDrawableIndex(e) {
+		let t = this._model.drawables.count;
+		for (let n = 0; n < t; ++n) if (this._drawableIds[n] == e) return n;
+		return -1;
+	}
+	getDrawableCount() {
+		return this._model.drawables.count;
+	}
+	getDrawableId(e) {
+		return this._model.drawables.ids[e];
+	}
+	getDrawableRenderOrders() {
+		return this._model.drawables.renderOrders;
+	}
+	getDrawableTextureIndices(e) {
+		return this._model.drawables.textureIndices[e];
+	}
+	getDrawableDynamicFlagVertexPositionsDidChange(e) {
+		let t = this._model.drawables.dynamicFlags;
+		return Live2DCubismCore.Utils.hasVertexPositionsDidChangeBit(t[e]);
+	}
+	getDrawableVertexIndexCount(e) {
+		return this._model.drawables.indexCounts[e];
+	}
+	getDrawableVertexCount(e) {
+		return this._model.drawables.vertexCounts[e];
+	}
+	getDrawableVertices(e) {
+		return this.getDrawableVertexPositions(e);
+	}
+	getDrawableVertexIndices(e) {
+		return this._model.drawables.indices[e];
+	}
+	getDrawableVertexPositions(e) {
+		return this._model.drawables.vertexPositions[e];
+	}
+	getDrawableVertexUvs(e) {
+		return this._model.drawables.vertexUvs[e];
+	}
+	getDrawableOpacity(e) {
+		return this._model.drawables.opacities[e];
+	}
+	getDrawableCulling(e) {
+		let t = this._model.drawables.constantFlags;
+		return !Live2DCubismCore.Utils.hasIsDoubleSidedBit(t[e]);
+	}
+	getDrawableBlendMode(e) {
+		let t = this._model.drawables.constantFlags;
+		return Live2DCubismCore.Utils.hasBlendAdditiveBit(t[e]) ? x.CubismBlendMode_Additive : Live2DCubismCore.Utils.hasBlendMultiplicativeBit(t[e]) ? x.CubismBlendMode_Multiplicative : x.CubismBlendMode_Normal;
+	}
+	getDrawableInvertedMaskBit(e) {
+		let t = this._model.drawables.constantFlags;
+		return Live2DCubismCore.Utils.hasIsInvertedMaskBit(t[e]);
+	}
+	getDrawableMasks() {
+		return this._model.drawables.masks;
+	}
+	getDrawableMaskCounts() {
+		return this._model.drawables.maskCounts;
+	}
+	isUsingMasking() {
+		for (let e = 0; e < this._model.drawables.count; ++e) if (!(this._model.drawables.maskCounts[e] <= 0)) return !0;
+		return !1;
+	}
+	getDrawableDynamicFlagIsVisible(e) {
+		let t = this._model.drawables.dynamicFlags;
+		return Live2DCubismCore.Utils.hasIsVisibleBit(t[e]);
+	}
+	getDrawableDynamicFlagVisibilityDidChange(e) {
+		let t = this._model.drawables.dynamicFlags;
+		return Live2DCubismCore.Utils.hasVisibilityDidChangeBit(t[e]);
+	}
+	getDrawableDynamicFlagOpacityDidChange(e) {
+		let t = this._model.drawables.dynamicFlags;
+		return Live2DCubismCore.Utils.hasOpacityDidChangeBit(t[e]);
+	}
+	getDrawableDynamicFlagRenderOrderDidChange(e) {
+		let t = this._model.drawables.dynamicFlags;
+		return Live2DCubismCore.Utils.hasRenderOrderDidChangeBit(t[e]);
+	}
+	loadParameters() {
+		let e = this._model.parameters.count, t = this._savedParameters.length;
+		e > t && (e = t);
+		for (let t = 0; t < e; ++t) this._parameterValues[t] = this._savedParameters[t];
+	}
+	initialize() {
+		this._parameterValues = this._model.parameters.values, this._partOpacities = this._model.parts.opacities, this._parameterMaximumValues = this._model.parameters.maximumValues, this._parameterMinimumValues = this._model.parameters.minimumValues;
+		{
+			let e = this._model.parameters.ids, t = this._model.parameters.count;
+			for (let n = 0; n < t; ++n) this._parameterIds.push(e[n]);
+		}
+		{
+			let e = this._model.parts.ids, t = this._model.parts.count;
+			for (let n = 0; n < t; ++n) this._partIds.push(e[n]);
+		}
+		{
+			let e = this._model.drawables.ids, t = this._model.drawables.count;
+			for (let n = 0; n < t; ++n) this._drawableIds.push(e[n]);
+		}
+	}
+	constructor(e) {
+		this._model = e, this._savedParameters = [], this._parameterIds = [], this._drawableIds = [], this._partIds = [], this._notExistPartId = {}, this._notExistParameterId = {}, this._notExistParameterValues = {}, this._notExistPartOpacities = {}, this.initialize();
+	}
+	release() {
+		this._model.release(), this._model = void 0;
+	}
+}, ce = class e {
+	static create(t) {
+		let n = Live2DCubismCore.Moc.fromArrayBuffer(t);
+		if (n) return new e(n);
+		throw Error("Unknown error");
+	}
+	createModel() {
+		let e, t = Live2DCubismCore.Model.fromMoc(this._moc);
+		if (t) return e = new se(t), ++this._modelCount, e;
+		throw Error("Unknown error");
+	}
+	deleteModel(e) {
+		e != null && --this._modelCount;
+	}
+	constructor(e) {
+		this._moc = e, this._modelCount = 0;
+	}
+	release() {
+		this._moc._release(), this._moc = void 0;
+	}
+}, le = class {
+	constructor(e, t) {
+		this._json = e;
+	}
+	release() {
+		this._json = void 0;
+	}
+	getUserDataCount() {
+		return this._json.Meta.UserDataCount;
+	}
+	getTotalUserDataSize() {
+		return this._json.Meta.TotalUserDataSize;
+	}
+	getUserDataTargetType(e) {
+		return this._json.UserData[e].Target;
+	}
+	getUserDataId(e) {
+		return this._json.UserData[e].Id;
+	}
+	getUserDataValue(e) {
+		return this._json.UserData[e].Value;
+	}
+}, ue = "ArtMesh", de = class e {
+	static create(t, n) {
+		let r = new e();
+		return r.parseUserData(t, n), r;
+	}
+	getArtMeshUserDatas() {
+		return this._artMeshUserDataNode;
+	}
+	parseUserData(e, t) {
+		let n = new le(e, t), r = ue, i = n.getUserDataCount();
+		for (let e = 0; e < i; e++) {
+			let t = {
+				targetId: n.getUserDataId(e),
+				targetType: n.getUserDataTargetType(e),
+				value: n.getUserDataValue(e)
+			};
+			this._userDataNodes.push(t), t.targetType == r && this._artMeshUserDataNode.push(t);
+		}
+		n.release();
+	}
+	constructor() {
+		this._userDataNodes = [], this._artMeshUserDataNode = [];
+	}
+	release() {
+		this._userDataNodes = null;
+	}
+}, fe = class {
+	constructor() {
+		this._fadeInSeconds = -1, this._fadeOutSeconds = -1, this._weight = 1, this._offsetSeconds = 0, this._firedEventValues = [];
+	}
+	release() {
+		this._weight = 0;
+	}
+	updateParameters(e, t, n) {
+		if (!t.isAvailable() || t.isFinished()) return;
+		if (!t.isStarted()) {
+			t.setIsStarted(!0), t.setStartTime(n - this._offsetSeconds), t.setFadeInStartTime(n);
+			let e = this.getDuration();
+			t.getEndTime() < 0 && t.setEndTime(e <= 0 ? -1 : t.getStartTime() + e);
+		}
+		let r = this._weight, i = this._fadeInSeconds == 0 ? 1 : y.getEasingSine((n - t.getFadeInStartTime()) / this._fadeInSeconds), a = this._fadeOutSeconds == 0 || t.getEndTime() < 0 ? 1 : y.getEasingSine((t.getEndTime() - n) / this._fadeOutSeconds);
+		r = r * i * a, t.setState(n, r), this.doUpdateParameters(e, n, r, t), t.getEndTime() > 0 && t.getEndTime() < n && t.setIsFinished(!0);
+	}
+	setFadeInTime(e) {
+		this._fadeInSeconds = e;
+	}
+	setFadeOutTime(e) {
+		this._fadeOutSeconds = e;
+	}
+	getFadeOutTime() {
+		return this._fadeOutSeconds;
+	}
+	getFadeInTime() {
+		return this._fadeInSeconds;
+	}
+	setWeight(e) {
+		this._weight = e;
+	}
+	getWeight() {
+		return this._weight;
+	}
+	getDuration() {
+		return -1;
+	}
+	getLoopDuration() {
+		return -1;
+	}
+	setOffsetTime(e) {
+		this._offsetSeconds = e;
+	}
+	getFiredEvent(e, t) {
+		return this._firedEventValues;
+	}
+	setFinishedMotionHandler(e) {
+		this._onFinishedMotion = e;
+	}
+	getFinishedMotionHandler() {
+		return this._onFinishedMotion;
+	}
+}, pe = 1, me = class e extends fe {
+	constructor() {
+		super(), this._parameters = [];
+	}
+	static create(t) {
+		let n = new e(), r = t.FadeInTime, i = t.FadeOutTime;
+		n.setFadeInTime(r === void 0 ? pe : r), n.setFadeOutTime(i === void 0 ? pe : i);
+		let a = t.Parameters || [];
+		for (let e = 0; e < a.length; ++e) {
+			let t = a[e], r = t.Id, i = t.Value, o;
+			switch (t.Blend) {
+				case "Multiply":
+					o = M.ExpressionBlendType_Multiply;
+					break;
+				case "Overwrite":
+					o = M.ExpressionBlendType_Overwrite;
+					break;
+				default:
+					o = M.ExpressionBlendType_Add;
+					break;
+			}
+			let s = {
+				parameterId: r,
+				blendType: o,
+				value: i
+			};
+			n._parameters.push(s);
+		}
+		return n;
+	}
+	doUpdateParameters(e, t, n, r) {
+		for (let t = 0; t < this._parameters.length; ++t) {
+			let r = this._parameters[t];
+			switch (r.blendType) {
+				case M.ExpressionBlendType_Add:
+					e.addParameterValueById(r.parameterId, r.value, n);
+					break;
+				case M.ExpressionBlendType_Multiply:
+					e.multiplyParameterValueById(r.parameterId, r.value, n);
+					break;
+				case M.ExpressionBlendType_Overwrite:
+					e.setParameterValueById(r.parameterId, r.value, n);
+					break;
+			}
+		}
+	}
+}, M = /* @__PURE__ */ ((e) => (e[e.ExpressionBlendType_Add = 0] = "ExpressionBlendType_Add", e[e.ExpressionBlendType_Multiply = 1] = "ExpressionBlendType_Multiply", e[e.ExpressionBlendType_Overwrite = 2] = "ExpressionBlendType_Overwrite", e))(M || {}), he;
+((e) => {
+	e.supportMoreMaskDivisions = !0, e.setOpacityFromMotion = !1;
+})(he ||= {});
+var N = /* @__PURE__ */ ((e) => (e[e.CubismMotionCurveTarget_Model = 0] = "CubismMotionCurveTarget_Model", e[e.CubismMotionCurveTarget_Parameter = 1] = "CubismMotionCurveTarget_Parameter", e[e.CubismMotionCurveTarget_PartOpacity = 2] = "CubismMotionCurveTarget_PartOpacity", e))(N || {}), P = /* @__PURE__ */ ((e) => (e[e.CubismMotionSegmentType_Linear = 0] = "CubismMotionSegmentType_Linear", e[e.CubismMotionSegmentType_Bezier = 1] = "CubismMotionSegmentType_Bezier", e[e.CubismMotionSegmentType_Stepped = 2] = "CubismMotionSegmentType_Stepped", e[e.CubismMotionSegmentType_InverseStepped = 3] = "CubismMotionSegmentType_InverseStepped", e))(P || {}), F = class {
+	constructor(e = 0, t = 0) {
+		this.time = e, this.value = t;
+	}
+}, ge = class {
+	constructor() {
+		this.basePointIndex = 0, this.segmentType = 0;
+	}
+}, _e = class {
+	constructor() {
+		this.id = "", this.type = 0, this.segmentCount = 0, this.baseSegmentIndex = 0, this.fadeInTime = 0, this.fadeOutTime = 0;
+	}
+}, ve = class {
+	constructor() {
+		this.fireTime = 0, this.value = "";
+	}
+}, ye = class {
+	constructor() {
+		this.duration = 0, this.loop = !1, this.curveCount = 0, this.eventCount = 0, this.fps = 0, this.curves = [], this.segments = [], this.points = [], this.events = [];
+	}
+}, be = class {
+	constructor(e) {
+		this._json = e;
+	}
+	release() {
+		this._json = void 0;
+	}
+	getMotionDuration() {
+		return this._json.Meta.Duration;
+	}
+	isMotionLoop() {
+		return this._json.Meta.Loop || !1;
+	}
+	getEvaluationOptionFlag(e) {
+		return xe.EvaluationOptionFlag_AreBeziersRistricted == e ? !!this._json.Meta.AreBeziersRestricted : !1;
+	}
+	getMotionCurveCount() {
+		return this._json.Meta.CurveCount;
+	}
+	getMotionFps() {
+		return this._json.Meta.Fps;
+	}
+	getMotionTotalSegmentCount() {
+		return this._json.Meta.TotalSegmentCount;
+	}
+	getMotionTotalPointCount() {
+		return this._json.Meta.TotalPointCount;
+	}
+	getMotionFadeInTime() {
+		return this._json.Meta.FadeInTime;
+	}
+	getMotionFadeOutTime() {
+		return this._json.Meta.FadeOutTime;
+	}
+	getMotionCurveTarget(e) {
+		return this._json.Curves[e].Target;
+	}
+	getMotionCurveId(e) {
+		return this._json.Curves[e].Id;
+	}
+	getMotionCurveFadeInTime(e) {
+		return this._json.Curves[e].FadeInTime;
+	}
+	getMotionCurveFadeOutTime(e) {
+		return this._json.Curves[e].FadeOutTime;
+	}
+	getMotionCurveSegmentCount(e) {
+		return this._json.Curves[e].Segments.length;
+	}
+	getMotionCurveSegment(e, t) {
+		return this._json.Curves[e].Segments[t];
+	}
+	getEventCount() {
+		return this._json.Meta.UserDataCount || 0;
+	}
+	getTotalEventValueSize() {
+		return this._json.Meta.TotalUserDataSize;
+	}
+	getEventTime(e) {
+		return this._json.UserData[e].Time;
+	}
+	getEventValue(e) {
+		return this._json.UserData[e].Value;
+	}
+}, xe = /* @__PURE__ */ ((e) => (e[e.EvaluationOptionFlag_AreBeziersRistricted = 0] = "EvaluationOptionFlag_AreBeziersRistricted", e))(xe || {}), Se = "EyeBlink", Ce = "LipSync", we = "Model", Te = "Parameter", Ee = "PartOpacity", De = !1;
+function I(e, t, n) {
+	let r = new F();
+	return r.time = e.time + (t.time - e.time) * n, r.value = e.value + (t.value - e.value) * n, r;
+}
+function Oe(e, t) {
+	let n = (t - e[0].time) / (e[1].time - e[0].time);
+	return n < 0 && (n = 0), e[0].value + (e[1].value - e[0].value) * n;
+}
+function ke(e, t) {
+	let n = (t - e[0].time) / (e[3].time - e[0].time);
+	n < 0 && (n = 0);
+	let r = I(e[0], e[1], n), i = I(e[1], e[2], n), a = I(e[2], e[3], n);
+	return I(I(r, i, n), I(i, a, n), n).value;
+}
+function Ae(e, t) {
+	let n = t, r = e[0].time, i = e[3].time, a = e[1].time, o = e[2].time, s = i - 3 * o + 3 * a - r, c = 3 * o - 6 * a + 3 * r, l = 3 * a - 3 * r, u = r - n, d = y.cardanoAlgorithmForBezier(s, c, l, u), f = I(e[0], e[1], d), p = I(e[1], e[2], d), m = I(e[2], e[3], d);
+	return I(I(f, p, d), I(p, m, d), d).value;
+}
+function je(e, t) {
+	return e[0].value;
+}
+function Me(e, t) {
+	return e[1].value;
+}
+function Ne(e, t, n) {
+	let r = e.curves[t], i = -1, a = r.baseSegmentIndex + r.segmentCount, o = 0;
+	for (let t = r.baseSegmentIndex; t < a; ++t) if (o = e.segments[t].basePointIndex + (e.segments[t].segmentType == P.CubismMotionSegmentType_Bezier ? 3 : 1), e.points[o].time > n) {
+		i = t;
+		break;
+	}
+	if (i == -1) return e.points[o].value;
+	let s = e.segments[i];
+	return s.evaluate(e.points.slice(s.basePointIndex), n);
+}
+var Pe = class e extends fe {
+	constructor() {
+		super(), this._eyeBlinkParameterIds = [], this._lipSyncParameterIds = [], this._sourceFrameRate = 30, this._loopDurationSeconds = -1, this._isLoop = !1, this._isLoopFadeIn = !0, this._lastWeight = 0;
+	}
+	static create(t, n) {
+		let r = new e();
+		return r.parse(t), r._sourceFrameRate = r._motionData.fps, r._loopDurationSeconds = r._motionData.duration, r._onFinishedMotion = n, r;
+	}
+	doUpdateParameters(e, t, n, r) {
+		this._modelCurveIdEyeBlink ??= Se, this._modelCurveIdLipSync ??= Ce;
+		let i = t - r.getStartTime();
+		i < 0 && (i = 0);
+		let a = Number.MAX_VALUE, o = Number.MAX_VALUE, s = 0, c = 0;
+		this._eyeBlinkParameterIds.length > 64 && oe("too many eye blink targets : {0}", this._eyeBlinkParameterIds.length), this._lipSyncParameterIds.length > 64 && oe("too many lip sync targets : {0}", this._lipSyncParameterIds.length);
+		let l = this._fadeInSeconds <= 0 ? 1 : y.getEasingSine((t - r.getFadeInStartTime()) / this._fadeInSeconds), u = this._fadeOutSeconds <= 0 || r.getEndTime() < 0 ? 1 : y.getEasingSine((r.getEndTime() - t) / this._fadeOutSeconds), d, f, p, m = i;
+		if (this._isLoop) for (; m > this._motionData.duration;) m -= this._motionData.duration;
+		let h = this._motionData.curves;
+		for (f = 0; f < this._motionData.curveCount && h[f].type == N.CubismMotionCurveTarget_Model; ++f) d = Ne(this._motionData, f, m), h[f].id == this._modelCurveIdEyeBlink ? o = d : h[f].id == this._modelCurveIdLipSync && (a = d);
+		for (; f < this._motionData.curveCount && h[f].type == N.CubismMotionCurveTarget_Parameter; ++f) {
+			if (p = e.getParameterIndex(h[f].id), p == -1) continue;
+			let i = e.getParameterValueByIndex(p);
+			if (d = Ne(this._motionData, f, m), o != Number.MAX_VALUE) {
+				for (let e = 0; e < this._eyeBlinkParameterIds.length && e < 64; ++e) if (this._eyeBlinkParameterIds[e] == h[f].id) {
+					d *= o, c |= 1 << e;
+					break;
+				}
+			}
+			if (a != Number.MAX_VALUE) {
+				for (let e = 0; e < this._lipSyncParameterIds.length && e < 64; ++e) if (this._lipSyncParameterIds[e] == h[f].id) {
+					d += a, s |= 1 << e;
+					break;
+				}
+			}
+			let g;
+			if (h[f].fadeInTime < 0 && h[f].fadeOutTime < 0) g = i + (d - i) * n;
+			else {
+				let e, n;
+				e = h[f].fadeInTime < 0 ? l : h[f].fadeInTime == 0 ? 1 : y.getEasingSine((t - r.getFadeInStartTime()) / h[f].fadeInTime), n = h[f].fadeOutTime < 0 ? u : h[f].fadeOutTime == 0 || r.getEndTime() < 0 ? 1 : y.getEasingSine((r.getEndTime() - t) / h[f].fadeOutTime);
+				let a = this._weight * e * n;
+				g = i + (d - i) * a;
+			}
+			e.setParameterValueByIndex(p, g, 1);
+		}
+		if (o != Number.MAX_VALUE) for (let t = 0; t < this._eyeBlinkParameterIds.length && t < 64; ++t) {
+			let r = e.getParameterValueById(this._eyeBlinkParameterIds[t]);
+			if (c >> t & 1) continue;
+			let i = r + (o - r) * n;
+			e.setParameterValueById(this._eyeBlinkParameterIds[t], i);
+		}
+		if (a != Number.MAX_VALUE) for (let t = 0; t < this._lipSyncParameterIds.length && t < 64; ++t) {
+			let r = e.getParameterValueById(this._lipSyncParameterIds[t]);
+			if (s >> t & 1) continue;
+			let i = r + (a - r) * n;
+			e.setParameterValueById(this._lipSyncParameterIds[t], i);
+		}
+		for (; f < this._motionData.curveCount && h[f].type == N.CubismMotionCurveTarget_PartOpacity; ++f) if (d = Ne(this._motionData, f, m), he.setOpacityFromMotion) e.setPartOpacityById(h[f].id, d);
+		else {
+			if (p = e.getParameterIndex(h[f].id), p == -1) continue;
+			e.setParameterValueByIndex(p, d);
+		}
+		i >= this._motionData.duration && (this._isLoop ? (r.setStartTime(t), this._isLoopFadeIn && r.setFadeInStartTime(t)) : (this._onFinishedMotion && this._onFinishedMotion(this), r.setIsFinished(!0))), this._lastWeight = n;
+	}
+	setIsLoop(e) {
+		this._isLoop = e;
+	}
+	isLoop() {
+		return this._isLoop;
+	}
+	setIsLoopFadeIn(e) {
+		this._isLoopFadeIn = e;
+	}
+	isLoopFadeIn() {
+		return this._isLoopFadeIn;
+	}
+	getDuration() {
+		return this._isLoop ? -1 : this._loopDurationSeconds;
+	}
+	getLoopDuration() {
+		return this._loopDurationSeconds;
+	}
+	setParameterFadeInTime(e, t) {
+		let n = this._motionData.curves;
+		for (let r = 0; r < this._motionData.curveCount; ++r) if (e == n[r].id) {
+			n[r].fadeInTime = t;
+			return;
+		}
+	}
+	setParameterFadeOutTime(e, t) {
+		let n = this._motionData.curves;
+		for (let r = 0; r < this._motionData.curveCount; ++r) if (e == n[r].id) {
+			n[r].fadeOutTime = t;
+			return;
+		}
+	}
+	getParameterFadeInTime(e) {
+		let t = this._motionData.curves;
+		for (let n = 0; n < this._motionData.curveCount; ++n) if (e == t[n].id) return t[n].fadeInTime;
+		return -1;
+	}
+	getParameterFadeOutTime(e) {
+		let t = this._motionData.curves;
+		for (let n = 0; n < this._motionData.curveCount; ++n) if (e == t[n].id) return t[n].fadeOutTime;
+		return -1;
+	}
+	setEffectIds(e, t) {
+		this._eyeBlinkParameterIds = e, this._lipSyncParameterIds = t;
+	}
+	release() {
+		this._motionData = void 0;
+	}
+	parse(e) {
+		this._motionData = new ye();
+		let t = new be(e);
+		this._motionData.duration = t.getMotionDuration(), this._motionData.loop = t.isMotionLoop(), this._motionData.curveCount = t.getMotionCurveCount(), this._motionData.fps = t.getMotionFps(), this._motionData.eventCount = t.getEventCount();
+		let n = t.getEvaluationOptionFlag(xe.EvaluationOptionFlag_AreBeziersRistricted), r = t.getMotionFadeInTime(), i = t.getMotionFadeOutTime();
+		r === void 0 ? this._fadeInSeconds = 1 : this._fadeInSeconds = r < 0 ? 1 : r, i === void 0 ? this._fadeOutSeconds = 1 : this._fadeOutSeconds = i < 0 ? 1 : i, this._motionData.curves = Array.from({ length: this._motionData.curveCount }).map(() => new _e()), this._motionData.segments = Array.from({ length: t.getMotionTotalSegmentCount() }).map(() => new ge()), this._motionData.events = Array.from({ length: this._motionData.eventCount }).map(() => new ve()), this._motionData.points = [];
+		let a = 0, o = 0;
+		for (let e = 0; e < this._motionData.curveCount; ++e) {
+			let r = this._motionData.curves[e];
+			switch (t.getMotionCurveTarget(e)) {
+				case we:
+					r.type = N.CubismMotionCurveTarget_Model;
+					break;
+				case Te:
+					r.type = N.CubismMotionCurveTarget_Parameter;
+					break;
+				case Ee:
+					r.type = N.CubismMotionCurveTarget_PartOpacity;
+					break;
+				default: k("Warning : Unable to get segment type from Curve! The number of \"CurveCount\" may be incorrect!");
+			}
+			r.id = t.getMotionCurveId(e), r.baseSegmentIndex = o;
+			let i = t.getMotionCurveFadeInTime(e), s = t.getMotionCurveFadeOutTime(e);
+			r.fadeInTime = i === void 0 ? -1 : i, r.fadeOutTime = s === void 0 ? -1 : s;
+			for (let i = 0; i < t.getMotionCurveSegmentCount(e);) {
+				switch (i == 0 ? (this._motionData.segments[o].basePointIndex = a, this._motionData.points[a] = new F(t.getMotionCurveSegment(e, i), t.getMotionCurveSegment(e, i + 1)), a += 1, i += 2) : this._motionData.segments[o].basePointIndex = a - 1, t.getMotionCurveSegment(e, i)) {
+					case P.CubismMotionSegmentType_Linear:
+						this._motionData.segments[o].segmentType = P.CubismMotionSegmentType_Linear, this._motionData.segments[o].evaluate = Oe, this._motionData.points[a] = new F(t.getMotionCurveSegment(e, i + 1), t.getMotionCurveSegment(e, i + 2)), a += 1, i += 3;
+						break;
+					case P.CubismMotionSegmentType_Bezier:
+						this._motionData.segments[o].segmentType = P.CubismMotionSegmentType_Bezier, n || De ? this._motionData.segments[o].evaluate = ke : this._motionData.segments[o].evaluate = Ae, this._motionData.points[a] = new F(t.getMotionCurveSegment(e, i + 1), t.getMotionCurveSegment(e, i + 2)), this._motionData.points[a + 1] = new F(t.getMotionCurveSegment(e, i + 3), t.getMotionCurveSegment(e, i + 4)), this._motionData.points[a + 2] = new F(t.getMotionCurveSegment(e, i + 5), t.getMotionCurveSegment(e, i + 6)), a += 3, i += 7;
+						break;
+					case P.CubismMotionSegmentType_Stepped:
+						this._motionData.segments[o].segmentType = P.CubismMotionSegmentType_Stepped, this._motionData.segments[o].evaluate = je, this._motionData.points[a] = new F(t.getMotionCurveSegment(e, i + 1), t.getMotionCurveSegment(e, i + 2)), a += 1, i += 3;
+						break;
+					case P.CubismMotionSegmentType_InverseStepped:
+						this._motionData.segments[o].segmentType = P.CubismMotionSegmentType_InverseStepped, this._motionData.segments[o].evaluate = Me, this._motionData.points[a] = new F(t.getMotionCurveSegment(e, i + 1), t.getMotionCurveSegment(e, i + 2)), a += 1, i += 3;
+						break;
+				}
+				++r.segmentCount, ++o;
+			}
+			this._motionData.curves.push(r);
+		}
+		for (let e = 0; e < t.getEventCount(); ++e) this._motionData.events[e].fireTime = t.getEventTime(e), this._motionData.events[e].value = t.getEventValue(e);
+		t.release();
+	}
+	getFiredEvent(e, t) {
+		this._firedEventValues.length = 0;
+		for (let n = 0; n < this._motionData.eventCount; ++n) this._motionData.events[n].fireTime > e && this._motionData.events[n].fireTime <= t && this._firedEventValues.push(this._motionData.events[n].value);
+		return this._firedEventValues;
+	}
+}, Fe = class {
+	constructor() {
+		this._autoDelete = !1, this._available = !0, this._finished = !1, this._started = !1, this._startTimeSeconds = -1, this._fadeInStartTimeSeconds = 0, this._endTimeSeconds = -1, this._stateTimeSeconds = 0, this._stateWeight = 0, this._lastEventCheckSeconds = 0, this._motionQueueEntryHandle = this, this._fadeOutSeconds = 0, this._isTriggeredFadeOut = !1;
+	}
+	release() {
+		this._autoDelete && this._motion && this._motion.release();
+	}
+	setFadeOut(e) {
+		this._fadeOutSeconds = e, this._isTriggeredFadeOut = !0;
+	}
+	startFadeOut(e, t) {
+		let n = t + e;
+		this._isTriggeredFadeOut = !0, (this._endTimeSeconds < 0 || n < this._endTimeSeconds) && (this._endTimeSeconds = n);
+	}
+	isFinished() {
+		return this._finished;
+	}
+	isStarted() {
+		return this._started;
+	}
+	getStartTime() {
+		return this._startTimeSeconds;
+	}
+	getFadeInStartTime() {
+		return this._fadeInStartTimeSeconds;
+	}
+	getEndTime() {
+		return this._endTimeSeconds;
+	}
+	setStartTime(e) {
+		this._startTimeSeconds = e;
+	}
+	setFadeInStartTime(e) {
+		this._fadeInStartTimeSeconds = e;
+	}
+	setEndTime(e) {
+		this._endTimeSeconds = e;
+	}
+	setIsFinished(e) {
+		this._finished = e;
+	}
+	setIsStarted(e) {
+		this._started = e;
+	}
+	isAvailable() {
+		return this._available;
+	}
+	setIsAvailable(e) {
+		this._available = e;
+	}
+	setState(e, t) {
+		this._stateTimeSeconds = e, this._stateWeight = t;
+	}
+	getStateTime() {
+		return this._stateTimeSeconds;
+	}
+	getStateWeight() {
+		return this._stateWeight;
+	}
+	getLastCheckEventSeconds() {
+		return this._lastEventCheckSeconds;
+	}
+	setLastCheckEventSeconds(e) {
+		this._lastEventCheckSeconds = e;
+	}
+	isTriggeredFadeOut() {
+		return this._isTriggeredFadeOut;
+	}
+	getFadeOutSeconds() {
+		return this._fadeOutSeconds;
+	}
+}, Ie = class {
+	constructor() {
+		this._userTimeSeconds = 0, this._eventCustomData = null, this._motions = [];
+	}
+	release() {
+		for (let e = 0; e < this._motions.length; ++e) this._motions[e] && this._motions[e].release();
+		this._motions = void 0;
+	}
+	startMotion(e, t, n) {
+		if (e == null) return -1;
+		let r;
+		for (let e = 0; e < this._motions.length; ++e) r = this._motions[e], r?.setFadeOut(r._motion.getFadeOutTime());
+		return r = new Fe(), r._autoDelete = t, r._motion = e, this._motions.push(r), r._motionQueueEntryHandle;
+	}
+	isFinished() {
+		let e = 0;
+		for (; e < this._motions.length;) {
+			let t = this._motions[e];
+			if (t == null) {
+				this._motions.splice(e, 1);
+				continue;
+			}
+			if (t._motion == null) {
+				t.release(), this._motions.splice(e, 1);
+				continue;
+			}
+			if (!t.isFinished()) return !1;
+			e++;
+		}
+		return !0;
+	}
+	isFinishedByHandle(e) {
+		for (let t = 0; t < this._motions.length; t++) {
+			let n = this._motions[t];
+			if (n != null && n._motionQueueEntryHandle == e && !n.isFinished()) return !1;
+		}
+		return !0;
+	}
+	stopAllMotions() {
+		for (let e = 0; e < this._motions.length; e++) this._motions[e]?.release();
+		this._motions = [];
+	}
+	getCubismMotionQueueEntry(e) {
+		return this._motions.find((t) => t != null && t._motionQueueEntryHandle == e);
+	}
+	setEventCallback(e, t = null) {
+		this._eventCallBack = e, this._eventCustomData = t;
+	}
+	doUpdateMotion(e, t) {
+		let n = !1, r = 0;
+		for (; r < this._motions.length;) {
+			let i = this._motions[r];
+			if (i == null) {
+				this._motions.splice(r, 1);
+				continue;
+			}
+			let a = i._motion;
+			if (a == null) {
+				i.release(), this._motions.splice(r, 1);
+				continue;
+			}
+			a.updateParameters(e, i, t), n = !0;
+			let o = a.getFiredEvent(i.getLastCheckEventSeconds() - i.getStartTime(), t - i.getStartTime());
+			for (let e = 0; e < o.length; ++e) this._eventCallBack(this, o[e], this._eventCustomData);
+			i.setLastCheckEventSeconds(t), i.isFinished() ? (i.release(), this._motions.splice(r, 1)) : (i.isTriggeredFadeOut() && i.startFadeOut(i.getFadeOutSeconds(), t), r++);
+		}
+		return n;
+	}
+}, Le = -1, Re = class extends Ie {
+	constructor() {
+		super(), this._currentPriority = 0, this._reservePriority = 0;
+	}
+	getCurrentPriority() {
+		return this._currentPriority;
+	}
+	getReservePriority() {
+		return this._reservePriority;
+	}
+	setReservePriority(e) {
+		this._reservePriority = e;
+	}
+	startMotionPriority(e, t, n) {
+		return n == this._reservePriority && (this._reservePriority = 0), this._currentPriority = n, super.startMotion(e, t, this._userTimeSeconds);
+	}
+	updateMotion(e, t) {
+		this._userTimeSeconds += t;
+		let n = super.doUpdateMotion(e, this._userTimeSeconds);
+		return this.isFinished() && (this._currentPriority = 0), n;
+	}
+	reserveMotion(e) {
+		return e <= this._reservePriority || e <= this._currentPriority ? !1 : (this._reservePriority = e, !0);
+	}
+}, ze = /* @__PURE__ */ ((e) => (e[e.CubismPhysicsTargetType_Parameter = 0] = "CubismPhysicsTargetType_Parameter", e))(ze || {}), L = /* @__PURE__ */ ((e) => (e[e.CubismPhysicsSource_X = 0] = "CubismPhysicsSource_X", e[e.CubismPhysicsSource_Y = 1] = "CubismPhysicsSource_Y", e[e.CubismPhysicsSource_Angle = 2] = "CubismPhysicsSource_Angle", e))(L || {}), Be = class {
+	constructor() {
+		this.gravity = new v(0, 0), this.wind = new v(0, 0);
+	}
+}, Ve = class {
+	constructor() {
+		this.initialPosition = new v(0, 0), this.position = new v(0, 0), this.lastPosition = new v(0, 0), this.lastGravity = new v(0, 0), this.force = new v(0, 0), this.velocity = new v(0, 0);
+	}
+}, He = class {
+	constructor() {
+		this.normalizationPosition = {}, this.normalizationAngle = {};
+	}
+}, Ue = class {
+	constructor() {
+		this.source = {};
+	}
+}, We = class {
+	constructor() {
+		this.destination = {}, this.translationScale = new v(0, 0);
+	}
+}, Ge = class {
+	constructor() {
+		this.settings = [], this.inputs = [], this.outputs = [], this.particles = [], this.gravity = new v(0, 0), this.wind = new v(0, 0);
+	}
+}, Ke = class {
+	constructor(e) {
+		this._json = e;
+	}
+	release() {
+		this._json = void 0;
+	}
+	getGravity() {
+		let e = new v(0, 0);
+		return e.x = this._json.Meta.EffectiveForces.Gravity.X, e.y = this._json.Meta.EffectiveForces.Gravity.Y, e;
+	}
+	getWind() {
+		let e = new v(0, 0);
+		return e.x = this._json.Meta.EffectiveForces.Wind.X, e.y = this._json.Meta.EffectiveForces.Wind.Y, e;
+	}
+	getSubRigCount() {
+		return this._json.Meta.PhysicsSettingCount;
+	}
+	getTotalInputCount() {
+		return this._json.Meta.TotalInputCount;
+	}
+	getTotalOutputCount() {
+		return this._json.Meta.TotalOutputCount;
+	}
+	getVertexCount() {
+		return this._json.Meta.VertexCount;
+	}
+	getNormalizationPositionMinimumValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Position.Minimum;
+	}
+	getNormalizationPositionMaximumValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Position.Maximum;
+	}
+	getNormalizationPositionDefaultValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Position.Default;
+	}
+	getNormalizationAngleMinimumValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Angle.Minimum;
+	}
+	getNormalizationAngleMaximumValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Angle.Maximum;
+	}
+	getNormalizationAngleDefaultValue(e) {
+		return this._json.PhysicsSettings[e].Normalization.Angle.Default;
+	}
+	getInputCount(e) {
+		return this._json.PhysicsSettings[e].Input.length;
+	}
+	getInputWeight(e, t) {
+		return this._json.PhysicsSettings[e].Input[t].Weight;
+	}
+	getInputReflect(e, t) {
+		return this._json.PhysicsSettings[e].Input[t].Reflect;
+	}
+	getInputType(e, t) {
+		return this._json.PhysicsSettings[e].Input[t].Type;
+	}
+	getInputSourceId(e, t) {
+		return this._json.PhysicsSettings[e].Input[t].Source.Id;
+	}
+	getOutputCount(e) {
+		return this._json.PhysicsSettings[e].Output.length;
+	}
+	getOutputVertexIndex(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].VertexIndex;
+	}
+	getOutputAngleScale(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].Scale;
+	}
+	getOutputWeight(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].Weight;
+	}
+	getOutputDestinationId(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].Destination.Id;
+	}
+	getOutputType(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].Type;
+	}
+	getOutputReflect(e, t) {
+		return this._json.PhysicsSettings[e].Output[t].Reflect;
+	}
+	getParticleCount(e) {
+		return this._json.PhysicsSettings[e].Vertices.length;
+	}
+	getParticleMobility(e, t) {
+		return this._json.PhysicsSettings[e].Vertices[t].Mobility;
+	}
+	getParticleDelay(e, t) {
+		return this._json.PhysicsSettings[e].Vertices[t].Delay;
+	}
+	getParticleAcceleration(e, t) {
+		return this._json.PhysicsSettings[e].Vertices[t].Acceleration;
+	}
+	getParticleRadius(e, t) {
+		return this._json.PhysicsSettings[e].Vertices[t].Radius;
+	}
+	getParticlePosition(e, t) {
+		let n = new v(0, 0);
+		return n.x = this._json.PhysicsSettings[e].Vertices[t].Position.X, n.y = this._json.PhysicsSettings[e].Vertices[t].Position.Y, n;
+	}
+}, qe = "X", Je = "Y", Ye = "Angle", Xe = 5, Ze = 100, Qe = .001, $e = class e {
+	static create(t) {
+		let n = new e();
+		return n.parse(t), n._physicsRig.gravity.y = 0, n;
+	}
+	evaluate(e, t) {
+		let n, r, i, a, o = new v(), s, c, l, u, d, f, p, m;
+		d = e.getModel().parameters.values, f = e.getModel().parameters.maximumValues, p = e.getModel().parameters.minimumValues, m = e.getModel().parameters.defaultValues;
+		for (let h = 0; h < this._physicsRig.subRigCount; ++h) {
+			n = { angle: 0 }, o.x = 0, o.y = 0, s = this._physicsRig.settings[h], c = this._physicsRig.inputs.slice(s.baseInputIndex), l = this._physicsRig.outputs.slice(s.baseOutputIndex), u = this._physicsRig.particles.slice(s.baseParticleIndex);
+			for (let t = 0; t < s.inputCount; ++t) r = c[t].weight / Ze, c[t].sourceParameterIndex == -1 && (c[t].sourceParameterIndex = e.getParameterIndex(c[t].source.id)), c[t].getNormalizedParameterValue(o, n, d[c[t].sourceParameterIndex], p[c[t].sourceParameterIndex], f[c[t].sourceParameterIndex], m[c[t].sourceParameterIndex], s.normalizationPosition, s.normalizationAngle, c[t].reflect, r);
+			i = y.degreesToRadian(-n.angle), o.x = o.x * y.cos(i) - o.y * y.sin(i), o.y = o.x * y.sin(i) + o.y * y.cos(i), ft(u, s.particleCount, o, n.angle, this._options.wind, Qe * s.normalizationPosition.maximum, t, Xe);
+			for (let t = 0; t < s.outputCount; ++t) {
+				let n = l[t].vertexIndex;
+				if (n < 1 || n >= s.particleCount) break;
+				l[t].destinationParameterIndex == -1 && (l[t].destinationParameterIndex = e.getParameterIndex(l[t].destination.id));
+				let r = new v();
+				r.x = u[n].position.x - u[n - 1].position.x, r.y = u[n].position.y - u[n - 1].position.y, a = l[t].getValue(r, u, n, l[t].reflect, this._options.gravity);
+				let i = l[t].destinationParameterIndex, o = !Float32Array.prototype.slice && "subarray" in Float32Array.prototype ? JSON.parse(JSON.stringify(d.subarray(i))) : d.slice(i);
+				pt(o, p[i], f[i], a, l[t]);
+				for (let e = i, t = 0; e < d.length; e++, t++) d[e] = o[t];
+			}
+		}
+	}
+	setOptions(e) {
+		this._options = e;
+	}
+	getOption() {
+		return this._options;
+	}
+	constructor() {
+		this._options = new et(), this._options.gravity.y = -1, this._options.gravity.x = 0, this._options.wind.x = 0, this._options.wind.y = 0;
+	}
+	release() {
+		this._physicsRig = void 0;
+	}
+	parse(e) {
+		this._physicsRig = new Ge();
+		let t = new Ke(e);
+		this._physicsRig.gravity = t.getGravity(), this._physicsRig.wind = t.getWind(), this._physicsRig.subRigCount = t.getSubRigCount();
+		let n = 0, r = 0, i = 0;
+		for (let e = 0; e < this._physicsRig.subRigCount; ++e) {
+			let a = new He();
+			a.normalizationPosition.minimum = t.getNormalizationPositionMinimumValue(e), a.normalizationPosition.maximum = t.getNormalizationPositionMaximumValue(e), a.normalizationPosition.defalut = t.getNormalizationPositionDefaultValue(e), a.normalizationAngle.minimum = t.getNormalizationAngleMinimumValue(e), a.normalizationAngle.maximum = t.getNormalizationAngleMaximumValue(e), a.normalizationAngle.defalut = t.getNormalizationAngleDefaultValue(e), a.inputCount = t.getInputCount(e), a.baseInputIndex = n, n += a.inputCount;
+			for (let n = 0; n < a.inputCount; ++n) {
+				let r = new Ue();
+				switch (r.sourceParameterIndex = -1, r.weight = t.getInputWeight(e, n), r.reflect = t.getInputReflect(e, n), t.getInputType(e, n)) {
+					case qe:
+						r.type = L.CubismPhysicsSource_X, r.getNormalizedParameterValue = tt;
+						break;
+					case Je:
+						r.type = L.CubismPhysicsSource_Y, r.getNormalizedParameterValue = nt;
+						break;
+					case Ye:
+						r.type = L.CubismPhysicsSource_Angle, r.getNormalizedParameterValue = rt;
+						break;
+				}
+				r.source.targetType = ze.CubismPhysicsTargetType_Parameter, r.source.id = t.getInputSourceId(e, n), this._physicsRig.inputs.push(r);
+			}
+			a.outputCount = t.getOutputCount(e), a.baseOutputIndex = r, r += a.outputCount;
+			for (let n = 0; n < a.outputCount; ++n) {
+				let r = new We();
+				switch (r.destinationParameterIndex = -1, r.vertexIndex = t.getOutputVertexIndex(e, n), r.angleScale = t.getOutputAngleScale(e, n), r.weight = t.getOutputWeight(e, n), r.destination.targetType = ze.CubismPhysicsTargetType_Parameter, r.destination.id = t.getOutputDestinationId(e, n), t.getOutputType(e, n)) {
+					case qe:
+						r.type = L.CubismPhysicsSource_X, r.getValue = it, r.getScale = lt;
+						break;
+					case Je:
+						r.type = L.CubismPhysicsSource_Y, r.getValue = at, r.getScale = ut;
+						break;
+					case Ye:
+						r.type = L.CubismPhysicsSource_Angle, r.getValue = ot, r.getScale = dt;
+						break;
+				}
+				r.reflect = t.getOutputReflect(e, n), this._physicsRig.outputs.push(r);
+			}
+			a.particleCount = t.getParticleCount(e), a.baseParticleIndex = i, i += a.particleCount;
+			for (let n = 0; n < a.particleCount; ++n) {
+				let r = new Ve();
+				r.mobility = t.getParticleMobility(e, n), r.delay = t.getParticleDelay(e, n), r.acceleration = t.getParticleAcceleration(e, n), r.radius = t.getParticleRadius(e, n), r.position = t.getParticlePosition(e, n), this._physicsRig.particles.push(r);
+			}
+			this._physicsRig.settings.push(a);
+		}
+		this.initialize(), t.release();
+	}
+	initialize() {
+		let e, t, n;
+		for (let r = 0; r < this._physicsRig.subRigCount; ++r) {
+			t = this._physicsRig.settings[r], e = this._physicsRig.particles.slice(t.baseParticleIndex), e[0].initialPosition = new v(0, 0), e[0].lastPosition = new v(e[0].initialPosition.x, e[0].initialPosition.y), e[0].lastGravity = new v(0, -1), e[0].lastGravity.y *= -1, e[0].velocity = new v(0, 0), e[0].force = new v(0, 0);
+			for (let r = 1; r < t.particleCount; ++r) n = new v(0, 0), n.y = e[r].radius, e[r].initialPosition = new v(e[r - 1].initialPosition.x + n.x, e[r - 1].initialPosition.y + n.y), e[r].position = new v(e[r].initialPosition.x, e[r].initialPosition.y), e[r].lastPosition = new v(e[r].initialPosition.x, e[r].initialPosition.y), e[r].lastGravity = new v(0, -1), e[r].lastGravity.y *= -1, e[r].velocity = new v(0, 0), e[r].force = new v(0, 0);
+		}
+	}
+}, et = class {
+	constructor() {
+		this.gravity = new v(0, 0), this.wind = new v(0, 0);
+	}
+};
+function tt(e, t, n, r, i, a, o, s, c, l) {
+	e.x += mt(n, r, i, a, o.minimum, o.maximum, o.defalut, c) * l;
+}
+function nt(e, t, n, r, i, a, o, s, c, l) {
+	e.y += mt(n, r, i, a, o.minimum, o.maximum, o.defalut, c) * l;
+}
+function rt(e, t, n, r, i, a, o, s, c, l) {
+	t.angle += mt(n, r, i, a, s.minimum, s.maximum, s.defalut, c) * l;
+}
+function it(e, t, n, r, i) {
+	let a = e.x;
+	return r && (a *= -1), a;
+}
+function at(e, t, n, r, i) {
+	let a = e.y;
+	return r && (a *= -1), a;
+}
+function ot(e, t, n, r, i) {
+	let a;
+	return i = n >= 2 ? t[n - 1].position.substract(t[n - 2].position) : i.multiplyByScaler(-1), a = y.directionToRadian(i, e), r && (a *= -1), a;
+}
+function st(e, t) {
+	return Math.abs(Math.max(e, t) - Math.min(e, t));
+}
+function ct(e, t) {
+	return Math.min(e, t) + st(e, t) / 2;
+}
+function lt(e, t) {
+	return e.x;
+}
+function ut(e, t) {
+	return e.y;
+}
+function dt(e, t) {
+	return t;
+}
+function ft(e, t, n, r, i, a, o, s) {
+	let c, l, u, d, f = new v(0, 0), p = new v(0, 0), m = new v(0, 0), h = new v(0, 0);
+	e[0].position = new v(n.x, n.y), c = y.degreesToRadian(r), d = y.radianToDirection(c), d.normalize();
+	for (let n = 1; n < t; ++n) e[n].force = d.multiplyByScaler(e[n].acceleration).add(i), e[n].lastPosition = new v(e[n].position.x, e[n].position.y), l = e[n].delay * o * 30, f = e[n].position.substract(e[n - 1].position), u = y.directionToRadian(e[n].lastGravity, d) / s, f.x = y.cos(u) * f.x - f.y * y.sin(u), f.y = y.sin(u) * f.x + f.y * y.cos(u), e[n].position = e[n - 1].position.add(f), p = e[n].velocity.multiplyByScaler(l), m = e[n].force.multiplyByScaler(l).multiplyByScaler(l), e[n].position = e[n].position.add(p).add(m), h = e[n].position.substract(e[n - 1].position), h.normalize(), e[n].position = e[n - 1].position.add(h.multiplyByScaler(e[n].radius)), y.abs(e[n].position.x) < a && (e[n].position.x = 0), l != 0 && (e[n].velocity = e[n].position.substract(e[n].lastPosition), e[n].velocity = e[n].velocity.divisionByScalar(l), e[n].velocity = e[n].velocity.multiplyByScaler(e[n].mobility)), e[n].force = new v(0, 0), e[n].lastGravity = new v(d.x, d.y);
+}
+function pt(e, t, n, r, i) {
+	let a, o, s;
+	a = i.getScale(i.translationScale, i.angleScale), o = r * a, o < t ? (o < i.valueBelowMinimum && (i.valueBelowMinimum = o), o = t) : o > n && (o > i.valueExceededMaximum && (i.valueExceededMaximum = o), o = n), s = i.weight / Ze, s >= 1 || (o = e[0] * (1 - s) + o * s), e[0] = o;
+}
+function mt(e, t, n, r, i, a, o, s) {
+	let c = 0, l = y.max(n, t);
+	l < e && (e = l);
+	let u = y.min(n, t);
+	u > e && (e = u);
+	let d = y.min(i, a), f = y.max(i, a), p = o, m = ct(u, l), h = e - m;
+	switch (Math.sign(h)) {
+		case 1: {
+			let e = f - p, t = l - m;
+			t != 0 && (c = e / t * h, c += p);
+			break;
+		}
+		case -1: {
+			let e = d - p, t = u - m;
+			t != 0 && (c = e / t * h, c += p);
+			break;
+		}
+		case 0:
+			c = p;
+			break;
+	}
+	return s ? c : c * -1;
+}
+var ht = class {
+	constructor(e = 0, t = 0, n = 0, r = 0) {
+		this.x = e, this.y = t, this.width = n, this.height = r;
+	}
+	getCenterX() {
+		return this.x + .5 * this.width;
+	}
+	getCenterY() {
+		return this.y + .5 * this.height;
+	}
+	getRight() {
+		return this.x + this.width;
+	}
+	getBottom() {
+		return this.y + this.height;
+	}
+	setRect(e) {
+		this.x = e.x, this.y = e.y, this.width = e.width, this.height = e.height;
+	}
+	expand(e, t) {
+		this.x -= e, this.y -= t, this.width += e * 2, this.height += t * 2;
+	}
+}, gt = 4, _t = 10, vt, R, yt, bt = class {
+	getChannelFlagAsColor(e) {
+		return this._channelColors[e];
+	}
+	getMaskRenderTexture() {
+		let e = 0;
+		if (this._maskTexture && this._maskTexture.texture != 0 && (this._maskTexture.frameNo = this._currentFrameNo, e = this._maskTexture.texture), e == 0) {
+			let t = this._clippingMaskBufferSize;
+			this._colorBuffer = this.gl.createTexture(), this.gl.bindTexture(this.gl.TEXTURE_2D, this._colorBuffer), this.gl.texImage2D(this.gl.TEXTURE_2D, 0, this.gl.RGBA, t, t, 0, this.gl.RGBA, this.gl.UNSIGNED_BYTE, null), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_S, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_WRAP_T, this.gl.CLAMP_TO_EDGE), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MIN_FILTER, this.gl.LINEAR), this.gl.texParameteri(this.gl.TEXTURE_2D, this.gl.TEXTURE_MAG_FILTER, this.gl.LINEAR), this.gl.bindTexture(this.gl.TEXTURE_2D, null), e = this.gl.createFramebuffer(), this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, e), this.gl.framebufferTexture2D(this.gl.FRAMEBUFFER, this.gl.COLOR_ATTACHMENT0, this.gl.TEXTURE_2D, this._colorBuffer, 0), this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, yt), this._maskTexture = new xt(this._currentFrameNo, e);
+		}
+		return e;
+	}
+	setGL(e) {
+		this.gl = e;
+	}
+	calcClippedDrawTotalBounds(e, t) {
+		let n = Number.MAX_VALUE, r = Number.MAX_VALUE, i = Number.MIN_VALUE, a = Number.MIN_VALUE, o = t._clippedDrawableIndexList.length;
+		for (let s = 0; s < o; s++) {
+			let o = t._clippedDrawableIndexList[s], c = e.getDrawableVertexCount(o), l = e.getDrawableVertices(o), u = Number.MAX_VALUE, d = Number.MAX_VALUE, f = Number.MIN_VALUE, p = Number.MIN_VALUE, m = c * re.vertexStep;
+			for (let e = re.vertexOffset; e < m; e += re.vertexStep) {
+				let t = l[e], n = l[e + 1];
+				t < u && (u = t), t > f && (f = t), n < d && (d = n), n > p && (p = n);
+			}
+			if (u != Number.MAX_VALUE) if (u < n && (n = u), d < r && (r = d), f > i && (i = f), p > a && (a = p), n == Number.MAX_VALUE) t._allClippedDrawRect.x = 0, t._allClippedDrawRect.y = 0, t._allClippedDrawRect.width = 0, t._allClippedDrawRect.height = 0, t._isUsing = !1;
+			else {
+				t._isUsing = !0;
+				let e = i - n, o = a - r;
+				t._allClippedDrawRect.x = n, t._allClippedDrawRect.y = r, t._allClippedDrawRect.width = e, t._allClippedDrawRect.height = o;
+			}
+		}
+	}
+	constructor() {
+		this._maskRenderTexture = null, this._colorBuffer = null, this._currentFrameNo = 0, this._clippingMaskBufferSize = 256, this._clippingContextListForMask = [], this._clippingContextListForDraw = [], this._channelColors = [], this._tmpBoundsOnModel = new ht(), this._tmpMatrix = new b(), this._tmpMatrixForMask = new b(), this._tmpMatrixForDraw = new b();
+		let e = new S();
+		e.R = 1, e.G = 0, e.B = 0, e.A = 0, this._channelColors.push(e), e = new S(), e.R = 0, e.G = 1, e.B = 0, e.A = 0, this._channelColors.push(e), e = new S(), e.R = 0, e.G = 0, e.B = 1, e.A = 0, this._channelColors.push(e), e = new S(), e.R = 0, e.G = 0, e.B = 0, e.A = 1, this._channelColors.push(e);
+	}
+	release() {
+		var e, t, n;
+		let r = this;
+		for (let t = 0; t < this._clippingContextListForMask.length; t++) this._clippingContextListForMask[t] && ((e = this._clippingContextListForMask[t]) == null || e.release());
+		r._clippingContextListForMask = void 0, r._clippingContextListForDraw = void 0, this._maskTexture && ((t = this.gl) == null || t.deleteFramebuffer(this._maskTexture.texture), r._maskTexture = void 0), r._channelColors = void 0, (n = this.gl) == null || n.deleteTexture(this._colorBuffer), this._colorBuffer = null;
+	}
+	initialize(e, t, n, r) {
+		for (let e = 0; e < t; e++) {
+			if (r[e] <= 0) {
+				this._clippingContextListForDraw.push(null);
+				continue;
+			}
+			let t = this.findSameClip(n[e], r[e]);
+			t ?? (t = new St(this, n[e], r[e]), this._clippingContextListForMask.push(t)), t.addClippedDrawable(e), this._clippingContextListForDraw.push(t);
+		}
+	}
+	setupClippingContext(e, t) {
+		this._currentFrameNo++;
+		let n = 0;
+		for (let t = 0; t < this._clippingContextListForMask.length; t++) {
+			let r = this._clippingContextListForMask[t];
+			this.calcClippedDrawTotalBounds(e, r), r._isUsing && n++;
+		}
+		if (n > 0) {
+			this.gl.viewport(0, 0, this._clippingMaskBufferSize, this._clippingMaskBufferSize), this._maskRenderTexture = this.getMaskRenderTexture(), t.getMvpMatrix(), t.preDraw(), this.setupLayoutBounds(n), this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, this._maskRenderTexture), this.gl.clearColor(1, 1, 1, 1), this.gl.clear(this.gl.COLOR_BUFFER_BIT);
+			for (let n = 0; n < this._clippingContextListForMask.length; n++) {
+				let r = this._clippingContextListForMask[n], i = r._allClippedDrawRect, a = r._layoutBounds, o = .05;
+				this._tmpBoundsOnModel.setRect(i), this._tmpBoundsOnModel.expand(i.width * o, i.height * o);
+				let s = a.width / this._tmpBoundsOnModel.width, c = a.height / this._tmpBoundsOnModel.height;
+				this._tmpMatrix.loadIdentity(), this._tmpMatrix.translateRelative(-1, -1), this._tmpMatrix.scaleRelative(2, 2), this._tmpMatrix.translateRelative(a.x, a.y), this._tmpMatrix.scaleRelative(s, c), this._tmpMatrix.translateRelative(-this._tmpBoundsOnModel.x, -this._tmpBoundsOnModel.y), this._tmpMatrixForMask.setMatrix(this._tmpMatrix.getArray()), this._tmpMatrix.loadIdentity(), this._tmpMatrix.translateRelative(a.x, a.y), this._tmpMatrix.scaleRelative(s, c), this._tmpMatrix.translateRelative(-this._tmpBoundsOnModel.x, -this._tmpBoundsOnModel.y), this._tmpMatrixForDraw.setMatrix(this._tmpMatrix.getArray()), r._matrixForMask.setMatrix(this._tmpMatrixForMask.getArray()), r._matrixForDraw.setMatrix(this._tmpMatrixForDraw.getArray());
+				let l = r._clippingIdCount;
+				for (let n = 0; n < l; n++) {
+					let i = r._clippingIdList[n];
+					e.getDrawableDynamicFlagVertexPositionsDidChange(i) && (t.setIsCulling(e.getDrawableCulling(i) != 0), t.setClippingContextBufferForMask(r), t.drawMesh(e.getDrawableTextureIndices(i), e.getDrawableVertexIndexCount(i), e.getDrawableVertexCount(i), e.getDrawableVertexIndices(i), e.getDrawableVertices(i), e.getDrawableVertexUvs(i), e.getDrawableOpacity(i), x.CubismBlendMode_Normal, !1));
+				}
+			}
+			this.gl.bindFramebuffer(this.gl.FRAMEBUFFER, yt), t.setClippingContextBufferForMask(null), this.gl.viewport(R[0], R[1], R[2], R[3]);
+		}
+	}
+	findSameClip(e, t) {
+		for (let n = 0; n < this._clippingContextListForMask.length; n++) {
+			let r = this._clippingContextListForMask[n], i = r._clippingIdCount;
+			if (i != t) continue;
+			let a = 0;
+			for (let t = 0; t < i; t++) {
+				let n = r._clippingIdList[t];
+				for (let t = 0; t < i; t++) if (e[t] == n) {
+					a++;
+					break;
+				}
+			}
+			if (a == i) return r;
+		}
+		return null;
+	}
+	setupLayoutBounds(e) {
+		let t = e / gt, n = e % gt;
+		t = ~~t, n = ~~n;
+		let r = 0;
+		for (let e = 0; e < gt; e++) {
+			let i = t + +(e < n);
+			if (i != 0) if (i == 1) {
+				let t = this._clippingContextListForMask[r++];
+				t._layoutChannelNo = e, t._layoutBounds.x = 0, t._layoutBounds.y = 0, t._layoutBounds.width = 1, t._layoutBounds.height = 1;
+			} else if (i == 2) for (let t = 0; t < i; t++) {
+				let n = t % 2;
+				n = ~~n;
+				let i = this._clippingContextListForMask[r++];
+				i._layoutChannelNo = e, i._layoutBounds.x = n * .5, i._layoutBounds.y = 0, i._layoutBounds.width = .5, i._layoutBounds.height = 1;
+			}
+			else if (i <= 4) for (let t = 0; t < i; t++) {
+				let n = t % 2, i = t / 2;
+				n = ~~n, i = ~~i;
+				let a = this._clippingContextListForMask[r++];
+				a._layoutChannelNo = e, a._layoutBounds.x = n * .5, a._layoutBounds.y = i * .5, a._layoutBounds.width = .5, a._layoutBounds.height = .5;
+			}
+			else if (i <= 9) for (let t = 0; t < i; t++) {
+				let n = t % 3, i = t / 3;
+				n = ~~n, i = ~~i;
+				let a = this._clippingContextListForMask[r++];
+				a._layoutChannelNo = e, a._layoutBounds.x = n / 3, a._layoutBounds.y = i / 3, a._layoutBounds.width = 1 / 3, a._layoutBounds.height = 1 / 3;
+			}
+			else if (he.supportMoreMaskDivisions && i <= 16) for (let t = 0; t < i; t++) {
+				let n = t % 4, i = t / 4;
+				n = ~~n, i = ~~i;
+				let a = this._clippingContextListForMask[r++];
+				a._layoutChannelNo = e, a._layoutBounds.x = n / 4, a._layoutBounds.y = i / 4, a._layoutBounds.width = 1 / 4, a._layoutBounds.height = 1 / 4;
+			}
+			else A("not supported mask count : {0}", i);
+		}
+	}
+	getColorBuffer() {
+		return this._colorBuffer;
+	}
+	getClippingContextListForDraw() {
+		return this._clippingContextListForDraw;
+	}
+	setClippingMaskBufferSize(e) {
+		this._clippingMaskBufferSize = e;
+	}
+	getClippingMaskBufferSize() {
+		return this._clippingMaskBufferSize;
+	}
+}, xt = class {
+	constructor(e, t) {
+		this.frameNo = e, this.texture = t;
+	}
+}, St = class {
+	constructor(e, t, n) {
+		this._isUsing = !1, this._owner = e, this._clippingIdList = t, this._clippingIdCount = n, this._allClippedDrawRect = new ht(), this._layoutBounds = new ht(), this._clippedDrawableIndexList = [], this._matrixForMask = new b(), this._matrixForDraw = new b();
+	}
+	release() {
+		let e = this;
+		e._layoutBounds = void 0, e._allClippedDrawRect = void 0, e._clippedDrawableIndexList = void 0;
+	}
+	addClippedDrawable(e) {
+		this._clippedDrawableIndexList.push(e);
+	}
+	getClippingManager() {
+		return this._owner;
+	}
+	setGl(e) {
+		this._owner.setGL(e);
+	}
+}, z = class e {
+	static getInstance() {
+		return vt ??= new e(), vt;
+	}
+	static deleteInstance() {
+		vt &&= (vt.release(), void 0);
+	}
+	constructor() {
+		this._shaderSets = [];
+	}
+	release() {
+		this.releaseShaderProgram();
+	}
+	setupShaderProgram(e, t, n, r, i, a, o, s, c, l, u, d, f) {
+		u || A("NoPremultipliedAlpha is not allowed"), this._shaderSets.length == 0 && this.generateShaders();
+		let p, m, h, g, _ = e.getClippingContextBufferForMask();
+		if (_ != null) {
+			let e = this._shaderSets[B.ShaderNames_SetupMask];
+			this.gl.useProgram(e.shaderProgram), this.gl.activeTexture(this.gl.TEXTURE0), this.gl.bindTexture(this.gl.TEXTURE_2D, t), this.gl.uniform1i(e.samplerTexture0Location, 0), o.vertex ??= this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, o.vertex), this.gl.bufferData(this.gl.ARRAY_BUFFER, r, this.gl.DYNAMIC_DRAW), this.gl.enableVertexAttribArray(e.attributePositionLocation), this.gl.vertexAttribPointer(e.attributePositionLocation, 2, this.gl.FLOAT, !1, 0, 0), o.uv ??= this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, o.uv), this.gl.bufferData(this.gl.ARRAY_BUFFER, a, this.gl.DYNAMIC_DRAW), this.gl.enableVertexAttribArray(e.attributeTexCoordLocation), this.gl.vertexAttribPointer(e.attributeTexCoordLocation, 2, this.gl.FLOAT, !1, 0, 0);
+			let n = _._layoutChannelNo, i = _.getClippingManager().getChannelFlagAsColor(n);
+			this.gl.uniform4f(e.uniformChannelFlagLocation, i.R, i.G, i.B, i.A), this.gl.uniformMatrix4fv(e.uniformClipMatrixLocation, !1, _._matrixForMask.getArray());
+			let s = _._layoutBounds;
+			this.gl.uniform4f(e.uniformBaseColorLocation, s.x * 2 - 1, s.y * 2 - 1, s.getRight() * 2 - 1, s.getBottom() * 2 - 1), p = this.gl.ZERO, m = this.gl.ONE_MINUS_SRC_COLOR, h = this.gl.ZERO, g = this.gl.ONE_MINUS_SRC_ALPHA;
+		} else {
+			let n = e.getClippingContextBufferForDraw(), i = n == null ? 0 : f ? 2 : 1, s;
+			switch (c) {
+				case x.CubismBlendMode_Normal:
+				default:
+					s = this._shaderSets[B.ShaderNames_NormalPremultipliedAlpha + i], p = this.gl.ONE, m = this.gl.ONE_MINUS_SRC_ALPHA, h = this.gl.ONE, g = this.gl.ONE_MINUS_SRC_ALPHA;
+					break;
+				case x.CubismBlendMode_Additive:
+					s = this._shaderSets[B.ShaderNames_AddPremultipliedAlpha + i], p = this.gl.ONE, m = this.gl.ONE, h = this.gl.ZERO, g = this.gl.ONE;
+					break;
+				case x.CubismBlendMode_Multiplicative:
+					s = this._shaderSets[B.ShaderNames_MultPremultipliedAlpha + i], p = this.gl.DST_COLOR, m = this.gl.ONE_MINUS_SRC_ALPHA, h = this.gl.ZERO, g = this.gl.ONE;
+					break;
+			}
+			if (this.gl.useProgram(s.shaderProgram), o.vertex ??= this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, o.vertex), this.gl.bufferData(this.gl.ARRAY_BUFFER, r, this.gl.DYNAMIC_DRAW), this.gl.enableVertexAttribArray(s.attributePositionLocation), this.gl.vertexAttribPointer(s.attributePositionLocation, 2, this.gl.FLOAT, !1, 0, 0), o.uv ??= this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, o.uv), this.gl.bufferData(this.gl.ARRAY_BUFFER, a, this.gl.DYNAMIC_DRAW), this.gl.enableVertexAttribArray(s.attributeTexCoordLocation), this.gl.vertexAttribPointer(s.attributeTexCoordLocation, 2, this.gl.FLOAT, !1, 0, 0), n != null) {
+				this.gl.activeTexture(this.gl.TEXTURE1);
+				let e = n.getClippingManager().getColorBuffer();
+				this.gl.bindTexture(this.gl.TEXTURE_2D, e), this.gl.uniform1i(s.samplerTexture1Location, 1), this.gl.uniformMatrix4fv(s.uniformClipMatrixLocation, !1, n._matrixForDraw.getArray());
+				let t = n._layoutChannelNo, r = n.getClippingManager().getChannelFlagAsColor(t);
+				this.gl.uniform4f(s.uniformChannelFlagLocation, r.R, r.G, r.B, r.A);
+			}
+			this.gl.activeTexture(this.gl.TEXTURE0), this.gl.bindTexture(this.gl.TEXTURE_2D, t), this.gl.uniform1i(s.samplerTexture0Location, 0), this.gl.uniformMatrix4fv(s.uniformMatrixLocation, !1, d.getArray()), this.gl.uniform4f(s.uniformBaseColorLocation, l.R, l.G, l.B, l.A);
+		}
+		o.index ??= this.gl.createBuffer(), this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, o.index), this.gl.bufferData(this.gl.ELEMENT_ARRAY_BUFFER, i, this.gl.DYNAMIC_DRAW), this.gl.blendFuncSeparate(p, m, h, g);
+	}
+	releaseShaderProgram() {
+		for (let e = 0; e < this._shaderSets.length; e++) this.gl.deleteProgram(this._shaderSets[e].shaderProgram), this._shaderSets[e].shaderProgram = 0;
+		this._shaderSets = [];
+	}
+	generateShaders() {
+		for (let e = 0; e < _t; e++) this._shaderSets.push({});
+		this._shaderSets[0].shaderProgram = this.loadShaderProgram(Ct, wt), this._shaderSets[1].shaderProgram = this.loadShaderProgram(Tt, Dt), this._shaderSets[2].shaderProgram = this.loadShaderProgram(Et, Ot), this._shaderSets[3].shaderProgram = this.loadShaderProgram(Et, kt), this._shaderSets[4].shaderProgram = this._shaderSets[1].shaderProgram, this._shaderSets[5].shaderProgram = this._shaderSets[2].shaderProgram, this._shaderSets[6].shaderProgram = this._shaderSets[3].shaderProgram, this._shaderSets[7].shaderProgram = this._shaderSets[1].shaderProgram, this._shaderSets[8].shaderProgram = this._shaderSets[2].shaderProgram, this._shaderSets[9].shaderProgram = this._shaderSets[3].shaderProgram, this._shaderSets[0].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[0].shaderProgram, "a_position"), this._shaderSets[0].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[0].shaderProgram, "a_texCoord"), this._shaderSets[0].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[0].shaderProgram, "s_texture0"), this._shaderSets[0].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[0].shaderProgram, "u_clipMatrix"), this._shaderSets[0].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[0].shaderProgram, "u_channelFlag"), this._shaderSets[0].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[0].shaderProgram, "u_baseColor"), this._shaderSets[1].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[1].shaderProgram, "a_position"), this._shaderSets[1].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[1].shaderProgram, "a_texCoord"), this._shaderSets[1].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[1].shaderProgram, "s_texture0"), this._shaderSets[1].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[1].shaderProgram, "u_matrix"), this._shaderSets[1].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[1].shaderProgram, "u_baseColor"), this._shaderSets[2].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[2].shaderProgram, "a_position"), this._shaderSets[2].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[2].shaderProgram, "a_texCoord"), this._shaderSets[2].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "s_texture0"), this._shaderSets[2].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "s_texture1"), this._shaderSets[2].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "u_matrix"), this._shaderSets[2].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "u_clipMatrix"), this._shaderSets[2].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "u_channelFlag"), this._shaderSets[2].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[2].shaderProgram, "u_baseColor"), this._shaderSets[3].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[3].shaderProgram, "a_position"), this._shaderSets[3].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[3].shaderProgram, "a_texCoord"), this._shaderSets[3].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "s_texture0"), this._shaderSets[3].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "s_texture1"), this._shaderSets[3].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "u_matrix"), this._shaderSets[3].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "u_clipMatrix"), this._shaderSets[3].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "u_channelFlag"), this._shaderSets[3].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[3].shaderProgram, "u_baseColor"), this._shaderSets[4].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[4].shaderProgram, "a_position"), this._shaderSets[4].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[4].shaderProgram, "a_texCoord"), this._shaderSets[4].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[4].shaderProgram, "s_texture0"), this._shaderSets[4].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[4].shaderProgram, "u_matrix"), this._shaderSets[4].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[4].shaderProgram, "u_baseColor"), this._shaderSets[5].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[5].shaderProgram, "a_position"), this._shaderSets[5].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[5].shaderProgram, "a_texCoord"), this._shaderSets[5].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "s_texture0"), this._shaderSets[5].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "s_texture1"), this._shaderSets[5].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "u_matrix"), this._shaderSets[5].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "u_clipMatrix"), this._shaderSets[5].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "u_channelFlag"), this._shaderSets[5].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[5].shaderProgram, "u_baseColor"), this._shaderSets[6].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[6].shaderProgram, "a_position"), this._shaderSets[6].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[6].shaderProgram, "a_texCoord"), this._shaderSets[6].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "s_texture0"), this._shaderSets[6].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "s_texture1"), this._shaderSets[6].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "u_matrix"), this._shaderSets[6].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "u_clipMatrix"), this._shaderSets[6].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "u_channelFlag"), this._shaderSets[6].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[6].shaderProgram, "u_baseColor"), this._shaderSets[7].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[7].shaderProgram, "a_position"), this._shaderSets[7].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[7].shaderProgram, "a_texCoord"), this._shaderSets[7].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[7].shaderProgram, "s_texture0"), this._shaderSets[7].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[7].shaderProgram, "u_matrix"), this._shaderSets[7].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[7].shaderProgram, "u_baseColor"), this._shaderSets[8].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[8].shaderProgram, "a_position"), this._shaderSets[8].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[8].shaderProgram, "a_texCoord"), this._shaderSets[8].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "s_texture0"), this._shaderSets[8].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "s_texture1"), this._shaderSets[8].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "u_matrix"), this._shaderSets[8].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "u_clipMatrix"), this._shaderSets[8].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "u_channelFlag"), this._shaderSets[8].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[8].shaderProgram, "u_baseColor"), this._shaderSets[9].attributePositionLocation = this.gl.getAttribLocation(this._shaderSets[9].shaderProgram, "a_position"), this._shaderSets[9].attributeTexCoordLocation = this.gl.getAttribLocation(this._shaderSets[9].shaderProgram, "a_texCoord"), this._shaderSets[9].samplerTexture0Location = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "s_texture0"), this._shaderSets[9].samplerTexture1Location = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "s_texture1"), this._shaderSets[9].uniformMatrixLocation = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "u_matrix"), this._shaderSets[9].uniformClipMatrixLocation = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "u_clipMatrix"), this._shaderSets[9].uniformChannelFlagLocation = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "u_channelFlag"), this._shaderSets[9].uniformBaseColorLocation = this.gl.getUniformLocation(this._shaderSets[9].shaderProgram, "u_baseColor");
+	}
+	loadShaderProgram(e, t) {
+		let n = this.gl.createProgram(), r = this.compileShaderSource(this.gl.VERTEX_SHADER, e);
+		if (!r) return A("Vertex shader compile error!"), 0;
+		let i = this.compileShaderSource(this.gl.FRAGMENT_SHADER, t);
+		return i ? (this.gl.attachShader(n, r), this.gl.attachShader(n, i), this.gl.linkProgram(n), this.gl.getProgramParameter(n, this.gl.LINK_STATUS) ? (this.gl.deleteShader(r), this.gl.deleteShader(i), n) : (A("Failed to link program: {0}", n), this.gl.deleteShader(r), this.gl.deleteShader(i), n && this.gl.deleteProgram(n), 0)) : (A("Vertex shader compile error!"), 0);
+	}
+	compileShaderSource(e, t) {
+		let n = t, r = this.gl.createShader(e);
+		return this.gl.shaderSource(r, n), this.gl.compileShader(r), r || A("Shader compile log: {0} ", this.gl.getShaderInfoLog(r)), this.gl.getShaderParameter(r, this.gl.COMPILE_STATUS) ? r : (this.gl.deleteShader(r), null);
+	}
+	setGl(e) {
+		this.gl = e;
+	}
+}, B = /* @__PURE__ */ ((e) => (e[e.ShaderNames_SetupMask = 0] = "ShaderNames_SetupMask", e[e.ShaderNames_NormalPremultipliedAlpha = 1] = "ShaderNames_NormalPremultipliedAlpha", e[e.ShaderNames_NormalMaskedPremultipliedAlpha = 2] = "ShaderNames_NormalMaskedPremultipliedAlpha", e[e.ShaderNames_NomralMaskedInvertedPremultipliedAlpha = 3] = "ShaderNames_NomralMaskedInvertedPremultipliedAlpha", e[e.ShaderNames_AddPremultipliedAlpha = 4] = "ShaderNames_AddPremultipliedAlpha", e[e.ShaderNames_AddMaskedPremultipliedAlpha = 5] = "ShaderNames_AddMaskedPremultipliedAlpha", e[e.ShaderNames_AddMaskedPremultipliedAlphaInverted = 6] = "ShaderNames_AddMaskedPremultipliedAlphaInverted", e[e.ShaderNames_MultPremultipliedAlpha = 7] = "ShaderNames_MultPremultipliedAlpha", e[e.ShaderNames_MultMaskedPremultipliedAlpha = 8] = "ShaderNames_MultMaskedPremultipliedAlpha", e[e.ShaderNames_MultMaskedPremultipliedAlphaInverted = 9] = "ShaderNames_MultMaskedPremultipliedAlphaInverted", e))(B || {}), Ct = "attribute vec4     a_position;attribute vec2     a_texCoord;varying vec2       v_texCoord;varying vec4       v_myPos;uniform mat4       u_clipMatrix;void main(){   gl_Position = u_clipMatrix * a_position;   v_myPos = u_clipMatrix * a_position;   v_texCoord = a_texCoord;   v_texCoord.y = 1.0 - v_texCoord.y;}", wt = "precision mediump float;varying vec2       v_texCoord;varying vec4       v_myPos;uniform vec4       u_baseColor;uniform vec4       u_channelFlag;uniform sampler2D  s_texture0;void main(){   float isInside =        step(u_baseColor.x, v_myPos.x/v_myPos.w)       * step(u_baseColor.y, v_myPos.y/v_myPos.w)       * step(v_myPos.x/v_myPos.w, u_baseColor.z)       * step(v_myPos.y/v_myPos.w, u_baseColor.w);   gl_FragColor = u_channelFlag * texture2D(s_texture0, v_texCoord).a * isInside;}", Tt = "attribute vec4     a_position;attribute vec2     a_texCoord;varying vec2       v_texCoord;uniform mat4       u_matrix;void main(){   gl_Position = u_matrix * a_position;   v_texCoord = a_texCoord;   v_texCoord.y = 1.0 - v_texCoord.y;}", Et = "attribute vec4     a_position;attribute vec2     a_texCoord;varying vec2       v_texCoord;varying vec4       v_clipPos;uniform mat4       u_matrix;uniform mat4       u_clipMatrix;void main(){   gl_Position = u_matrix * a_position;   v_clipPos = u_clipMatrix * a_position;   v_texCoord = a_texCoord;   v_texCoord.y = 1.0 - v_texCoord.y;}", Dt = "precision mediump float;varying vec2       v_texCoord;uniform vec4       u_baseColor;uniform sampler2D  s_texture0;void main(){   gl_FragColor = texture2D(s_texture0 , v_texCoord) * u_baseColor;}", Ot = "precision mediump float;varying vec2       v_texCoord;varying vec4       v_clipPos;uniform vec4       u_baseColor;uniform vec4       u_channelFlag;uniform sampler2D  s_texture0;uniform sampler2D  s_texture1;void main(){   vec4 col_formask = texture2D(s_texture0 , v_texCoord) * u_baseColor;   vec4 clipMask = (1.0 - texture2D(s_texture1, v_clipPos.xy / v_clipPos.w)) * u_channelFlag;   float maskVal = clipMask.r + clipMask.g + clipMask.b + clipMask.a;   col_formask = col_formask * maskVal;   gl_FragColor = col_formask;}", kt = "precision mediump float;varying vec2 v_texCoord;varying vec4 v_clipPos;uniform sampler2D s_texture0;uniform sampler2D s_texture1;uniform vec4 u_channelFlag;uniform vec4 u_baseColor;void main(){vec4 col_formask = texture2D(s_texture0, v_texCoord) * u_baseColor;vec4 clipMask = (1.0 - texture2D(s_texture1, v_clipPos.xy / v_clipPos.w)) * u_channelFlag;float maskVal = clipMask.r + clipMask.g + clipMask.b + clipMask.a;col_formask = col_formask * (1.0 - maskVal);gl_FragColor = col_formask;}", At = class extends ne {
+	constructor() {
+		super(), this._clippingContextBufferForMask = null, this._clippingContextBufferForDraw = null, this._clippingManager = new bt(), this.firstDraw = !0, this._textures = {}, this._sortedDrawableIndexList = [], this._bufferData = {
+			vertex: null,
+			uv: null,
+			index: null
+		};
+	}
+	initialize(e) {
+		e.isUsingMasking() && (this._clippingManager = new bt(), this._clippingManager.initialize(e, e.getDrawableCount(), e.getDrawableMasks(), e.getDrawableMaskCounts()));
+		for (let t = e.getDrawableCount() - 1; t >= 0; t--) this._sortedDrawableIndexList[t] = 0;
+		super.initialize(e);
+	}
+	bindTexture(e, t) {
+		this._textures[e] = t;
+	}
+	getBindedTextures() {
+		return this._textures;
+	}
+	setClippingMaskBufferSize(e) {
+		this._clippingManager.release(), this._clippingManager = new bt(), this._clippingManager.setClippingMaskBufferSize(e), this._clippingManager.initialize(this.getModel(), this.getModel().getDrawableCount(), this.getModel().getDrawableMasks(), this.getModel().getDrawableMaskCounts());
+	}
+	getClippingMaskBufferSize() {
+		return this._clippingManager.getClippingMaskBufferSize();
+	}
+	release() {
+		var e, t, n;
+		let r = this;
+		this._clippingManager.release(), r._clippingManager = void 0, (e = this.gl) == null || e.deleteBuffer(this._bufferData.vertex), this._bufferData.vertex = null, (t = this.gl) == null || t.deleteBuffer(this._bufferData.uv), this._bufferData.uv = null, (n = this.gl) == null || n.deleteBuffer(this._bufferData.index), this._bufferData.index = null, r._bufferData = void 0, r._textures = void 0;
+	}
+	doDrawModel() {
+		this.preDraw(), this._clippingManager != null && this._clippingManager.setupClippingContext(this.getModel(), this);
+		let e = this.getModel().getDrawableCount(), t = this.getModel().getDrawableRenderOrders();
+		for (let n = 0; n < e; ++n) {
+			let e = t[n];
+			this._sortedDrawableIndexList[e] = n;
+		}
+		for (let t = 0; t < e; ++t) {
+			let e = this._sortedDrawableIndexList[t];
+			this.getModel().getDrawableDynamicFlagIsVisible(e) && (this.setClippingContextBufferForDraw(this._clippingManager == null ? null : this._clippingManager.getClippingContextListForDraw()[e]), this.setIsCulling(this.getModel().getDrawableCulling(e)), this.drawMesh(this.getModel().getDrawableTextureIndices(e), this.getModel().getDrawableVertexIndexCount(e), this.getModel().getDrawableVertexCount(e), this.getModel().getDrawableVertexIndices(e), this.getModel().getDrawableVertices(e), this.getModel().getDrawableVertexUvs(e), this.getModel().getDrawableOpacity(e), this.getModel().getDrawableBlendMode(e), this.getModel().getDrawableInvertedMaskBit(e)));
+		}
+	}
+	drawMesh(e, t, n, r, i, a, o, s, c) {
+		this.isCulling() ? this.gl.enable(this.gl.CULL_FACE) : this.gl.disable(this.gl.CULL_FACE), this.gl.frontFace(this.gl.CCW);
+		let l = this.getModelColor();
+		this.getClippingContextBufferForMask() ?? (l.A *= o, this.isPremultipliedAlpha() && (l.R *= l.A, l.G *= l.A, l.B *= l.A));
+		let u = null;
+		this._textures[e] != null && (u = this._textures[e]), z.getInstance().setupShaderProgram(this, u, n, i, r, a, this._bufferData, o, s, l, this.isPremultipliedAlpha(), this.getMvpMatrix(), c), this.gl.drawElements(this.gl.TRIANGLES, t, this.gl.UNSIGNED_SHORT, 0), this.gl.useProgram(null), this.setClippingContextBufferForDraw(null), this.setClippingContextBufferForMask(null);
+	}
+	static doStaticRelease() {
+		z.deleteInstance();
+	}
+	setRenderState(e, t) {
+		yt = e, R = t;
+	}
+	preDraw() {
+		this.firstDraw && (this.firstDraw = !1, this._anisortopy = this.gl.getExtension("EXT_texture_filter_anisotropic") || this.gl.getExtension("WEBKIT_EXT_texture_filter_anisotropic") || this.gl.getExtension("MOZ_EXT_texture_filter_anisotropic")), this.gl.disable(this.gl.SCISSOR_TEST), this.gl.disable(this.gl.STENCIL_TEST), this.gl.disable(this.gl.DEPTH_TEST), this.gl.frontFace(this.gl.CW), this.gl.enable(this.gl.BLEND), this.gl.colorMask(!0, !0, !0, !0), this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null), this.gl.bindBuffer(this.gl.ELEMENT_ARRAY_BUFFER, null);
+	}
+	setClippingContextBufferForMask(e) {
+		this._clippingContextBufferForMask = e;
+	}
+	getClippingContextBufferForMask() {
+		return this._clippingContextBufferForMask;
+	}
+	setClippingContextBufferForDraw(e) {
+		this._clippingContextBufferForDraw = e;
+	}
+	getClippingContextBufferForDraw() {
+		return this._clippingContextBufferForDraw;
+	}
+	startUp(e) {
+		this.gl = e, this._clippingManager.setGL(e), z.getInstance().setGl(e);
+	}
+};
+ne.staticRelease = () => {
+	At.doStaticRelease();
+};
+var jt = class {
+	constructor(e) {
+		this.groups = e.Groups, this.hitAreas = e.HitAreas, this.layout = e.Layout, this.moc = e.FileReferences.Moc, this.expressions = e.FileReferences.Expressions, this.motions = e.FileReferences.Motions, this.textures = e.FileReferences.Textures, this.physics = e.FileReferences.Physics, this.pose = e.FileReferences.Pose;
+	}
+	getEyeBlinkParameters() {
+		return this.groups?.find((e) => e.Name === "EyeBlink")?.Ids;
+	}
+	getLipSyncParameters() {
+		return this.groups?.find((e) => e.Name === "LipSync")?.Ids;
+	}
+}, Mt = "HitArea", Nt = "Head", Pt = "Body", Ft = "Parts01Core", It = "Parts01Arm_", Lt = "Parts01ArmL_", Rt = "Parts01ArmR_", zt = "ParamAngleX", Bt = "ParamAngleY", Vt = "ParamAngleZ", Ht = "ParamEyeLOpen", Ut = "ParamEyeLSmile", Wt = "ParamEyeROpen", Gt = "ParamEyeRSmile", Kt = "ParamEyeBallX", qt = "ParamEyeBallY", Jt = "ParamEyeBallForm", Yt = "ParamBrowLY", Xt = "ParamBrowRY", Zt = "ParamBrowLX", Qt = "ParamBrowRX", $t = "ParamBrowLAngle", en = "ParamBrowRAngle", tn = "ParamBrowLForm", nn = "ParamBrowRForm", rn = "ParamMouthForm", an = "ParamMouthOpenY", on = "ParamCheek", sn = "ParamBodyAngleX", cn = "ParamBodyAngleY", ln = "ParamBodyAngleZ", un = "ParamBreath", dn = "ParamArmLA", fn = "ParamArmRA", pn = "ParamArmLB", mn = "ParamArmRB", hn = "ParamHandL", gn = "ParamHandR", _n = "ParamHairFront", vn = "ParamHairSide", yn = "ParamHairBack", bn = "ParamHairFluffy", xn = "ParamShoulderY", Sn = "ParamBustX", Cn = "ParamBustY", wn = "ParamBaseX", Tn = "ParamBaseY", En = "NONE:", Dn = 2, On = 2, V;
+((e) => {
+	e.LOG_LEVEL_VERBOSE = 0, e.LOG_LEVEL_WARNING = 1, e.LOG_LEVEL_ERROR = 2, e.LOG_LEVEL_NONE = 999, e.logLevel = e.LOG_LEVEL_WARNING, e.sound = !0, e.motionSync = !0, e.motionFadingDuration = 500, e.idleMotionFadingDuration = 2e3, e.expressionFadingDuration = 500, e.preserveExpressionOnMotion = !0, e.cubism4 = he;
+})(V ||= {});
+var kn = "0.4.0", H = {
+	log(e, ...t) {
+		V.logLevel <= V.LOG_LEVEL_VERBOSE && console.log(`[${e}]`, ...t);
+	},
+	warn(e, ...t) {
+		V.logLevel <= V.LOG_LEVEL_WARNING && console.warn(`[${e}]`, ...t);
+	},
+	error(e, ...t) {
+		V.logLevel <= V.LOG_LEVEL_ERROR && console.error(`[${e}]`, ...t);
+	}
+};
+function An(e, t, n) {
+	return e < t ? t : e > n ? n : e;
+}
+function jn(e, t) {
+	return Math.random() * (t - e) + e;
+}
+function Mn(e, t, n, r, i) {
+	let a = t[r];
+	a !== null && typeof a === e && (n[i] = a);
+}
+function Nn(e, t, n, r, i) {
+	let a = t[r];
+	Array.isArray(a) && (n[i] = a.filter((t) => t !== null && typeof t === e));
+}
+function Pn(e, t) {
+	t.forEach((t) => {
+		Object.getOwnPropertyNames(t.prototype).forEach((n) => {
+			n !== "constructor" && Object.defineProperty(e.prototype, n, Object.getOwnPropertyDescriptor(t.prototype, n));
+		});
+	});
+}
+function Fn(e) {
+	let t = e.lastIndexOf("/");
+	return t != -1 && (e = e.slice(0, t)), t = e.lastIndexOf("/"), t !== -1 && (e = e.slice(t + 1)), e;
+}
+function In(e, t) {
+	let n = e.indexOf(t);
+	n !== -1 && e.splice(n, 1);
+}
+var Ln = class extends o.default {
+	constructor(e, t) {
+		super(), this.expressions = [], this.reserveExpressionIndex = -1, this.destroyed = !1, this.settings = e, this.tag = `ExpressionManager(${e.name})`;
+	}
+	init() {
+		this.defaultExpression = this.createExpression({}, void 0), this.currentExpression = this.defaultExpression, this.stopAllExpressions();
+	}
+	loadExpression(e) {
+		return l(this, null, function* () {
+			if (!this.definitions[e]) {
+				H.warn(this.tag, `Undefined expression at [${e}]`);
+				return;
+			}
+			if (this.expressions[e] === null) {
+				H.warn(this.tag, `Cannot set expression at [${e}] because it's already failed in loading.`);
+				return;
+			}
+			if (this.expressions[e]) return this.expressions[e];
+			let t = yield this._loadExpression(e);
+			return this.expressions[e] = t, t;
+		});
+	}
+	_loadExpression(e) {
+		throw Error("Not implemented.");
+	}
+	setRandomExpression() {
+		return l(this, null, function* () {
+			if (this.definitions.length) {
+				let e = [];
+				for (let t = 0; t < this.definitions.length; t++) this.expressions[t] !== null && this.expressions[t] !== this.currentExpression && t !== this.reserveExpressionIndex && e.push(t);
+				if (e.length) {
+					let t = Math.floor(Math.random() * e.length);
+					return this.setExpression(t);
+				}
+			}
+			return !1;
+		});
+	}
+	resetExpression() {
+		this._setExpression(this.defaultExpression);
+	}
+	restoreExpression() {
+		this._setExpression(this.currentExpression);
+	}
+	setExpression(e) {
+		return l(this, null, function* () {
+			if (typeof e != "number" && (e = this.getExpressionIndex(e)), !(e > -1 && e < this.definitions.length) || e === this.expressions.indexOf(this.currentExpression)) return !1;
+			this.reserveExpressionIndex = e;
+			let t = yield this.loadExpression(e);
+			return !t || this.reserveExpressionIndex !== e ? !1 : (this.reserveExpressionIndex = -1, this.currentExpression = t, this._setExpression(t), !0);
+		});
+	}
+	update(e, t) {
+		return this.isFinished() ? !1 : this.updateParameters(e, t);
+	}
+	destroy() {
+		this.destroyed = !0, this.emit("destroy");
+		let e = this;
+		e.definitions = void 0, e.expressions = void 0;
+	}
+}, Rn = .01, zn = 40 / 7.5, Bn = 1 / (.15 * 1e3), Vn = class {
+	constructor() {
+		this.targetX = 0, this.targetY = 0, this.x = 0, this.y = 0, this.vx = 0, this.vy = 0;
+	}
+	focus(e, t, n = !1) {
+		this.targetX = An(e, -1, 1), this.targetY = An(t, -1, 1), n && (this.x = this.targetX, this.y = this.targetY);
+	}
+	update(e) {
+		let t = this.targetX - this.x, n = this.targetY - this.y;
+		if (Math.abs(t) < Rn && Math.abs(n) < Rn) return;
+		let r = Math.sqrt(c(t, 2) + c(n, 2)), i = zn / (1e3 / e), a = t / r * i - this.vx, o = n / r * i - this.vy, s = Math.sqrt(c(a, 2) + c(o, 2)), l = i * Bn * e;
+		s > l && (a *= l / s, o *= l / s), this.vx += a, this.vy += o;
+		let u = Math.sqrt(c(this.vx, 2) + c(this.vy, 2)), d = .5 * (Math.sqrt(c(l, 2) + 8 * l * r) - l);
+		u > d && (this.vx *= d / u, this.vy *= d / u), this.x += this.vx, this.y += this.vy;
+	}
+}, Hn = class {
+	constructor(e) {
+		this.json = e;
+		let t = e.url;
+		if (typeof t != "string") throw TypeError("The `url` field in settings JSON must be defined as a string.");
+		this.url = t, this.name = Fn(this.url);
+	}
+	resolveURL(e) {
+		return i.resolve(this.url, e);
+	}
+	replaceFiles(e) {
+		this.moc = e(this.moc, "moc"), this.pose !== void 0 && (this.pose = e(this.pose, "pose")), this.physics !== void 0 && (this.physics = e(this.physics, "physics"));
+		for (let t = 0; t < this.textures.length; t++) this.textures[t] = e(this.textures[t], `textures[${t}]`);
+	}
+	getDefinedFiles() {
+		let e = [];
+		return this.replaceFiles((t) => (e.push(t), t)), e;
+	}
+	validateFiles(e) {
+		let t = (t, n) => {
+			let r = this.resolveURL(t);
+			if (!e.includes(r)) {
+				if (n) throw Error(`File "${t}" is defined in settings, but doesn't exist in given files`);
+				return !1;
+			}
+			return !0;
+		};
+		return [this.moc, ...this.textures].forEach((e) => t(e, !0)), this.getDefinedFiles().filter((e) => t(e, !1));
+	}
+}, Un = /* @__PURE__ */ ((e) => (e[e.NONE = 0] = "NONE", e[e.IDLE = 1] = "IDLE", e[e.NORMAL = 2] = "NORMAL", e[e.FORCE = 3] = "FORCE", e))(Un || {}), Wn = class {
+	constructor() {
+		this.debug = !1, this.currentPriority = 0, this.reservePriority = 0;
+	}
+	reserve(e, t, n) {
+		if (n <= 0) return H.log(this.tag, "Cannot start a motion with MotionPriority.NONE."), !1;
+		if (e === this.currentGroup && t === this.currentIndex) return H.log(this.tag, "Motion is already playing.", this.dump(e, t)), !1;
+		if (e === this.reservedGroup && t === this.reservedIndex || e === this.reservedIdleGroup && t === this.reservedIdleIndex) return H.log(this.tag, "Motion is already reserved.", this.dump(e, t)), !1;
+		if (n === 1) {
+			if (this.currentPriority !== 0) return H.log(this.tag, "Cannot start idle motion because another motion is playing.", this.dump(e, t)), !1;
+			if (this.reservedIdleGroup !== void 0) return H.log(this.tag, "Cannot start idle motion because another idle motion has reserved.", this.dump(e, t)), !1;
+			this.setReservedIdle(e, t);
+		} else {
+			if (n < 3) {
+				if (n <= this.currentPriority) return H.log(this.tag, "Cannot start motion because another motion is playing as an equivalent or higher priority.", this.dump(e, t)), !1;
+				if (n <= this.reservePriority) return H.log(this.tag, "Cannot start motion because another motion has reserved as an equivalent or higher priority.", this.dump(e, t)), !1;
+			}
+			this.setReserved(e, t, n);
+		}
+		return !0;
+	}
+	start(e, t, n, r) {
+		if (r === 1) {
+			if (this.setReservedIdle(void 0, void 0), this.currentPriority !== 0) return H.log(this.tag, "Cannot start idle motion because another motion is playing.", this.dump(t, n)), !1;
+		} else {
+			if (t !== this.reservedGroup || n !== this.reservedIndex) return H.log(this.tag, "Cannot start motion because another motion has taken the place.", this.dump(t, n)), !1;
+			this.setReserved(void 0, void 0, 0);
+		}
+		return e ? (this.setCurrent(t, n, r), !0) : !1;
+	}
+	complete() {
+		this.setCurrent(void 0, void 0, 0);
+	}
+	setCurrent(e, t, n) {
+		this.currentPriority = n, this.currentGroup = e, this.currentIndex = t;
+	}
+	setReserved(e, t, n) {
+		this.reservePriority = n, this.reservedGroup = e, this.reservedIndex = t;
+	}
+	setReservedIdle(e, t) {
+		this.reservedIdleGroup = e, this.reservedIdleIndex = t;
+	}
+	isActive(e, t) {
+		return e === this.currentGroup && t === this.currentIndex || e === this.reservedGroup && t === this.reservedIndex || e === this.reservedIdleGroup && t === this.reservedIdleIndex;
+	}
+	reset() {
+		this.setCurrent(void 0, void 0, 0), this.setReserved(void 0, void 0, 0), this.setReservedIdle(void 0, void 0);
+	}
+	shouldRequestIdleMotion() {
+		return this.currentGroup === void 0 && this.reservedIdleGroup === void 0;
+	}
+	shouldOverrideExpression() {
+		return !V.preserveExpressionOnMotion && this.currentPriority > 1;
+	}
+	dump(e, t) {
+		return this.debug ? `
+<Requested> group = "${e}", index = ${t}
+` + [
+			"currentPriority",
+			"reservePriority",
+			"currentGroup",
+			"currentIndex",
+			"reservedGroup",
+			"reservedIndex",
+			"reservedIdleGroup",
+			"reservedIdleIndex"
+		].map((e) => "[" + e + "] " + this[e]).join("\n") : "";
+	}
+}, Gn = "SoundManager", Kn = .5, U = class {
+	static get volume() {
+		return this._volume;
+	}
+	static set volume(e) {
+		this._volume = (e > 1 ? 1 : e < 0 ? 0 : e) || 0, this.audios.forEach((e) => e.volume = this._volume);
+	}
+	static add(e, t, n) {
+		let r = new Audio(e);
+		return r.volume = this._volume, r.preload = "auto", r.addEventListener("ended", () => {
+			this.dispose(r), t?.();
+		}), r.addEventListener("error", (t) => {
+			this.dispose(r), H.warn(Gn, `Error occurred on "${e}"`, t.error), n?.(t.error);
+		}), this.audios.push(r), r;
+	}
+	static play(e) {
+		return new Promise((t, n) => {
+			var r;
+			(r = e.play()) == null || r.catch((t) => {
+				e.dispatchEvent(new ErrorEvent("error", { error: t })), n(t);
+			}), e.readyState === e.HAVE_ENOUGH_DATA ? t() : e.addEventListener("canplaythrough", t);
+		});
+	}
+	static dispose(e) {
+		e.pause(), e.removeAttribute("src"), In(this.audios, e);
+	}
+	static destroy() {
+		for (let e = this.audios.length - 1; e >= 0; e--) this.dispose(this.audios[e]);
+	}
+};
+U.audios = [], U._volume = Kn;
+var qn = /* @__PURE__ */ ((e) => (e.ALL = "ALL", e.IDLE = "IDLE", e.NONE = "NONE", e))(qn || {}), Jn = class extends o.default {
+	constructor(e, t) {
+		super(), this.motionGroups = {}, this.state = new Wn(), this.playing = !1, this.destroyed = !1, this.settings = e, this.tag = `MotionManager(${e.name})`, this.state.tag = this.tag;
+	}
+	init(e) {
+		e?.idleMotionGroup && (this.groups.idle = e.idleMotionGroup), this.setupMotions(e), this.stopAllMotions();
+	}
+	setupMotions(e) {
+		for (let e of Object.keys(this.definitions)) this.motionGroups[e] = [];
+		let t;
+		switch (e?.motionPreload) {
+			case "NONE": return;
+			case "ALL":
+				t = Object.keys(this.definitions);
+				break;
+			default:
+				t = [this.groups.idle];
+				break;
+		}
+		for (let e of t) if (this.definitions[e]) for (let t = 0; t < this.definitions[e].length; t++) this.loadMotion(e, t).then();
+	}
+	loadMotion(e, t) {
+		return l(this, null, function* () {
+			if (!this.definitions[e]?.[t]) {
+				H.warn(this.tag, `Undefined motion at "${e}"[${t}]`);
+				return;
+			}
+			if (this.motionGroups[e][t] === null) {
+				H.warn(this.tag, `Cannot start motion at "${e}"[${t}] because it's already failed in loading.`);
+				return;
+			}
+			if (this.motionGroups[e][t]) return this.motionGroups[e][t];
+			let n = yield this._loadMotion(e, t);
+			if (!this.destroyed) return this.motionGroups[e][t] = n ?? null, n;
+		});
+	}
+	_loadMotion(e, t) {
+		throw Error("Not implemented.");
+	}
+	startMotion(e, t) {
+		return l(this, arguments, function* (e, t, n = Un.NORMAL) {
+			if (!this.state.reserve(e, t, n)) return !1;
+			let r = this.definitions[e]?.[t];
+			if (!r) return !1;
+			this.currentAudio && U.dispose(this.currentAudio);
+			let i;
+			if (V.sound) {
+				let e = this.getSoundFile(r);
+				if (e) try {
+					i = U.add(this.settings.resolveURL(e), () => this.currentAudio = void 0, () => this.currentAudio = void 0), this.currentAudio = i;
+				} catch (t) {
+					H.warn(this.tag, "Failed to create audio", e, t);
+				}
+			}
+			let a = yield this.loadMotion(e, t);
+			if (i) {
+				let e = U.play(i).catch((e) => H.warn(this.tag, "Failed to play audio", i.src, e));
+				V.motionSync && (yield e);
+			}
+			return this.state.start(a, e, t, n) ? (H.log(this.tag, "Start motion:", this.getMotionName(r)), this.emit("motionStart", e, t, i), this.state.shouldOverrideExpression() && this.expressionManager && this.expressionManager.resetExpression(), this.playing = !0, this._startMotion(a), !0) : (i && (U.dispose(i), this.currentAudio = void 0), !1);
+		});
+	}
+	startRandomMotion(e, t) {
+		return l(this, null, function* () {
+			let n = this.definitions[e];
+			if (n?.length) {
+				let r = [];
+				for (let t = 0; t < n.length; t++) this.motionGroups[e][t] !== null && !this.state.isActive(e, t) && r.push(t);
+				if (r.length) {
+					let n = Math.floor(Math.random() * r.length);
+					return this.startMotion(e, r[n], t);
+				}
+			}
+			return !1;
+		});
+	}
+	stopAllMotions() {
+		this._stopAllMotions(), this.state.reset(), this.currentAudio &&= (U.dispose(this.currentAudio), void 0);
+	}
+	update(e, t) {
+		var n;
+		return this.isFinished() && (this.playing && (this.playing = !1, this.emit("motionFinish")), this.state.shouldOverrideExpression() && ((n = this.expressionManager) == null || n.restoreExpression()), this.state.complete(), this.state.shouldRequestIdleMotion() && this.startRandomMotion(this.groups.idle, Un.IDLE)), this.updateParameters(e, t);
+	}
+	destroy() {
+		var e;
+		this.destroyed = !0, this.emit("destroy"), this.stopAllMotions(), (e = this.expressionManager) == null || e.destroy();
+		let t = this;
+		t.definitions = void 0, t.motionGroups = void 0;
+	}
+}, Yn = {
+	x: 0,
+	y: 0,
+	width: 0,
+	height: 0
+}, Xn = class extends o.default {
+	constructor() {
+		super(...arguments), this.focusController = new Vn(), this.originalWidth = 0, this.originalHeight = 0, this.width = 0, this.height = 0, this.localTransform = new n(), this.drawingMatrix = new n(), this.hitAreas = {}, this.textureFlipY = !1, this.viewport = [
+			0,
+			0,
+			0,
+			0
+		], this.destroyed = !1;
+	}
+	init() {
+		this.setupLayout(), this.setupHitAreas();
+	}
+	setupLayout() {
+		let e = this, t = this.getSize();
+		e.originalWidth = t[0], e.originalHeight = t[1];
+		let n = Object.assign({
+			width: 2,
+			height: 2
+		}, this.getLayout());
+		this.localTransform.scale(n.width / 2, n.height / 2), e.width = this.originalWidth * this.localTransform.a, e.height = this.originalHeight * this.localTransform.d;
+		let r = n.x !== void 0 && n.x - n.width / 2 || n.centerX !== void 0 && n.centerX || n.left !== void 0 && n.left - n.width / 2 || n.right !== void 0 && n.right + n.width / 2 || 0, i = n.y !== void 0 && n.y - n.height / 2 || n.centerY !== void 0 && n.centerY || n.top !== void 0 && n.top - n.height / 2 || n.bottom !== void 0 && n.bottom + n.height / 2 || 0;
+		this.localTransform.translate(this.width * r, -this.height * i);
+	}
+	setupHitAreas() {
+		let e = this.getHitAreaDefs().filter((e) => e.index >= 0);
+		for (let t of e) this.hitAreas[t.name] = t;
+	}
+	hitTest(e, t) {
+		return Object.keys(this.hitAreas).filter((n) => this.isHit(n, e, t));
+	}
+	isHit(e, t, n) {
+		if (!this.hitAreas[e]) return !1;
+		let r = this.hitAreas[e].index, i = this.getDrawableBounds(r, Yn);
+		return i.x <= t && t <= i.x + i.width && i.y <= n && n <= i.y + i.height;
+	}
+	getDrawableBounds(e, t) {
+		let n = this.getDrawableVertices(e), r = n[0], i = n[0], a = n[1], o = n[1];
+		for (let e = 0; e < n.length; e += 2) {
+			let t = n[e], s = n[e + 1];
+			r = Math.min(t, r), i = Math.max(t, i), a = Math.min(s, a), o = Math.max(s, o);
+		}
+		return t ??= {}, t.x = r, t.y = a, t.width = i - r, t.height = o - a, t;
+	}
+	updateTransform(e) {
+		this.drawingMatrix.copyFrom(e).append(this.localTransform);
+	}
+	update(e, t) {
+		this.focusController.update(e);
+	}
+	destroy() {
+		this.destroyed = !0, this.emit("destroy"), this.motionManager.destroy(), this.motionManager = void 0;
+	}
+}, Zn = "XHRLoader", Qn = class extends Error {
+	constructor(e, t, n, r = !1) {
+		super(e), this.url = t, this.status = n, this.aborted = r;
+	}
+}, W = class {
+	static createXHR(e, t, n, r, i) {
+		let a = new XMLHttpRequest();
+		if (W.allXhrSet.add(a), e) {
+			let t = W.xhrMap.get(e);
+			t ? t.add(a) : (t = /* @__PURE__ */ new Set([a]), W.xhrMap.set(e, t)), e.listeners("destroy").includes(W.cancelXHRs) || e.once("destroy", W.cancelXHRs);
+		}
+		return a.open("GET", t), a.responseType = n, a.onload = () => {
+			(a.status === 200 || a.status === 0) && a.response ? r(a.response) : a.onerror();
+		}, a.onerror = () => {
+			H.warn(Zn, `Failed to load resource as ${a.responseType} (Status ${a.status}): ${t}`), i(new Qn("Network error.", t, a.status));
+		}, a.onabort = () => i(new Qn("Aborted.", t, a.status, !0)), a.onloadend = () => {
+			var t;
+			W.allXhrSet.delete(a), e && ((t = W.xhrMap.get(e)) == null || t.delete(a));
+		}, a;
+	}
+	static cancelXHRs() {
+		var e;
+		(e = W.xhrMap.get(this)) == null || e.forEach((e) => {
+			e.abort(), W.allXhrSet.delete(e);
+		}), W.xhrMap.delete(this);
+	}
+	static release() {
+		W.allXhrSet.forEach((e) => e.abort()), W.allXhrSet.clear(), W.xhrMap = /* @__PURE__ */ new WeakMap();
+	}
+}, $n = W;
+$n.xhrMap = /* @__PURE__ */ new WeakMap(), $n.allXhrSet = /* @__PURE__ */ new Set(), $n.loader = (e, t) => new Promise((t, n) => {
+	W.createXHR(e.target, e.settings ? e.settings.resolveURL(e.url) : e.url, e.type, (n) => {
+		e.result = n, t();
+	}, n).send();
+});
+function er(e, t) {
+	let n = -1;
+	return r(0);
+	function r(i, a) {
+		if (a) return Promise.reject(a);
+		if (i <= n) return Promise.reject(/* @__PURE__ */ Error("next() called multiple times"));
+		n = i;
+		let o = e[i];
+		if (!o) return Promise.resolve();
+		try {
+			return Promise.resolve(o(t, r.bind(null, i + 1)));
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	}
+}
+var G = class {
+	static load(e) {
+		return er(this.middlewares, e).then(() => e.result);
+	}
+};
+G.middlewares = [$n.loader];
+function tr(e, t = {}) {
+	let n = { resourceOptions: { crossorigin: t.crossOrigin } };
+	if (s.fromURL) return s.fromURL(e, n).catch((e) => {
+		if (e instanceof Error) throw e;
+		let t = /* @__PURE__ */ Error("Texture loading error");
+		throw t.event = e, t;
+	});
+	n.resourceOptions.autoLoad = !1;
+	let r = s.from(e, n);
+	if (r.baseTexture.valid) return Promise.resolve(r);
+	let i = r.baseTexture.resource;
+	return i._live2d_load ??= new Promise((e, t) => {
+		let n = (e) => {
+			i.source.removeEventListener("error", n);
+			let r = /* @__PURE__ */ Error("Texture loading error");
+			r.event = e, t(r);
+		};
+		i.source.addEventListener("error", n), i.load().then(() => e(r)).catch(n);
+	}), i._live2d_load;
+}
+var nr = "Live2DFactory", rr = (e, t) => l(void 0, null, function* () {
+	if (typeof e.source == "string") {
+		let t = yield G.load({
+			url: e.source,
+			type: "json",
+			target: e.live2dModel
+		});
+		t.url = e.source, e.source = t, e.live2dModel.emit("settingsJSONLoaded", t);
+	}
+	return t();
+}), ir = (e, t) => l(void 0, null, function* () {
+	if (e.source instanceof Hn) return e.settings = e.source, t();
+	if (typeof e.source == "object") {
+		let n = q.findRuntime(e.source);
+		if (n) {
+			let r = n.createModelSettings(e.source);
+			return e.settings = r, e.live2dModel.emit("settingsLoaded", r), t();
+		}
+	}
+	throw TypeError("Unknown settings format.");
+}), ar = (e, t) => {
+	if (e.settings) {
+		let n = q.findRuntime(e.settings);
+		if (n) return n.ready().then(t);
+	}
+	return t();
+}, or = (e, t) => l(void 0, null, function* () {
+	yield t();
+	let n = e.internalModel;
+	if (n) {
+		let t = e.settings, r = q.findRuntime(t);
+		if (r) {
+			let i = [];
+			t.pose && i.push(G.load({
+				settings: t,
+				url: t.pose,
+				type: "json",
+				target: n
+			}).then((t) => {
+				n.pose = r.createPose(n.coreModel, t), e.live2dModel.emit("poseLoaded", n.pose);
+			}).catch((t) => {
+				e.live2dModel.emit("poseLoadError", t), H.warn(nr, "Failed to load pose.", t);
+			})), t.physics && i.push(G.load({
+				settings: t,
+				url: t.physics,
+				type: "json",
+				target: n
+			}).then((t) => {
+				n.physics = r.createPhysics(n.coreModel, t), e.live2dModel.emit("physicsLoaded", n.physics);
+			}).catch((t) => {
+				e.live2dModel.emit("physicsLoadError", t), H.warn(nr, "Failed to load physics.", t);
+			})), i.length && (yield Promise.all(i));
+		}
+	}
+}), sr = (e, t) => l(void 0, null, function* () {
+	if (e.settings) {
+		let n = e.live2dModel, r = e.settings.textures.map((t) => tr(e.settings.resolveURL(t), { crossOrigin: e.options.crossOrigin }));
+		if (yield t(), e.internalModel) n.internalModel = e.internalModel, n.emit("modelLoaded", e.internalModel);
+		else throw TypeError("Missing internal model.");
+		n.textures = yield Promise.all(r), n.emit("textureLoaded", n.textures);
+	} else throw TypeError("Missing settings.");
+}), cr = (e, t) => l(void 0, null, function* () {
+	let n = e.settings;
+	if (n instanceof Hn) {
+		let r = q.findRuntime(n);
+		if (!r) throw TypeError("Unknown model settings.");
+		let i = yield G.load({
+			settings: n,
+			url: n.moc,
+			type: "arraybuffer",
+			target: e.live2dModel
+		});
+		if (!r.isValidMoc(i)) throw Error("Invalid moc data");
+		let a = r.createCoreModel(i);
+		return e.internalModel = r.createInternalModel(a, n, e.options), t();
+	}
+	throw TypeError("Missing settings.");
+}), K = class {
+	static registerRuntime(e) {
+		K.runtimes.push(e), K.runtimes.sort((e, t) => t.version - e.version);
+	}
+	static findRuntime(e) {
+		for (let t of K.runtimes) if (t.test(e)) return t;
+	}
+	static setupLive2DModel(e, t, n) {
+		return l(this, null, function* () {
+			let r = new Promise((t) => e.once("textureLoaded", t)), i = new Promise((t) => e.once("modelLoaded", t)), a = Promise.all([r, i]).then(() => e.emit("ready"));
+			yield er(K.live2DModelMiddlewares, {
+				live2dModel: e,
+				source: t,
+				options: n || {}
+			}), yield a, e.emit("load");
+		});
+	}
+	static loadMotion(e, t, n) {
+		let r = (r) => e.emit("motionLoadError", t, n, r);
+		try {
+			let i = e.definitions[t]?.[n];
+			if (!i) return Promise.resolve(void 0);
+			e.listeners("destroy").includes(K.releaseTasks) || e.once("destroy", K.releaseTasks);
+			let a = K.motionTasksMap.get(e);
+			a || (a = {}, K.motionTasksMap.set(e, a));
+			let o = a[t];
+			o || (o = [], a[t] = o);
+			let s = e.getMotionFile(i);
+			return o[n] ?? (o[n] = G.load({
+				url: s,
+				settings: e.settings,
+				type: e.motionDataType,
+				target: e
+			}).then((r) => {
+				let a = K.motionTasksMap.get(e)?.[t];
+				a && delete a[n];
+				let o = e.createMotion(r, t, i);
+				return e.emit("motionLoaded", t, n, o), o;
+			}).catch((t) => {
+				H.warn(e.tag, `Failed to load motion: ${s}
+`, t), r(t);
+			})), o[n];
+		} catch (i) {
+			H.warn(e.tag, `Failed to load motion at "${t}"[${n}]
+`, i), r(i);
+		}
+		return Promise.resolve(void 0);
+	}
+	static loadExpression(e, t) {
+		let n = (n) => e.emit("expressionLoadError", t, n);
+		try {
+			let r = e.definitions[t];
+			if (!r) return Promise.resolve(void 0);
+			e.listeners("destroy").includes(K.releaseTasks) || e.once("destroy", K.releaseTasks);
+			let i = K.expressionTasksMap.get(e);
+			i || (i = [], K.expressionTasksMap.set(e, i));
+			let a = e.getExpressionFile(r);
+			return i[t] ?? (i[t] = G.load({
+				url: a,
+				settings: e.settings,
+				type: "json",
+				target: e
+			}).then((n) => {
+				let i = K.expressionTasksMap.get(e);
+				i && delete i[t];
+				let a = e.createExpression(n, r);
+				return e.emit("expressionLoaded", t, a), a;
+			}).catch((t) => {
+				H.warn(e.tag, `Failed to load expression: ${a}
+`, t), n(t);
+			})), i[t];
+		} catch (r) {
+			H.warn(e.tag, `Failed to load expression at [${t}]
+`, r), n(r);
+		}
+		return Promise.resolve(void 0);
+	}
+	static releaseTasks() {
+		this instanceof Jn ? K.motionTasksMap.delete(this) : K.expressionTasksMap.delete(this);
+	}
+}, q = K;
+q.runtimes = [], q.urlToJSON = rr, q.jsonToSettings = ir, q.waitUntilReady = ar, q.setupOptionals = or, q.setupEssentials = sr, q.createInternalModel = cr, q.live2DModelMiddlewares = [
+	rr,
+	ir,
+	ar,
+	or,
+	sr,
+	cr
+], q.motionTasksMap = /* @__PURE__ */ new WeakMap(), q.expressionTasksMap = /* @__PURE__ */ new WeakMap(), Jn.prototype._loadMotion = function(e, t) {
+	return q.loadMotion(this, e, t);
+}, Ln.prototype._loadExpression = function(e) {
+	return q.loadExpression(this, e);
+};
+var lr = class {
+	constructor() {
+		this._autoInteract = !1;
+	}
+	get autoInteract() {
+		return this._autoInteract;
+	}
+	set autoInteract(e) {
+		e !== this._autoInteract && (e ? this.on("pointertap", ur, this) : this.off("pointertap", ur, this), this._autoInteract = e);
+	}
+	registerInteraction(e) {
+		e !== this.interactionManager && (this.unregisterInteraction(), this._autoInteract && e && (this.interactionManager = e, e.on("pointermove", dr, this)));
+	}
+	unregisterInteraction() {
+		var e;
+		this.interactionManager &&= ((e = this.interactionManager) == null || e.off("pointermove", dr, this), void 0);
+	}
+};
+function ur(e) {
+	this.tap(e.data.global.x, e.data.global.y);
+}
+function dr(e) {
+	this.focus(e.data.global.x, e.data.global.y);
+}
+var fr = class extends t {}, J = new e(), pr = new n(), Y, mr = class extends a {
+	constructor(e) {
+		super(), this.tag = "Live2DModel(uninitialized)", this.textures = [], this.transform = new fr(), this.anchor = new r(this.onAnchorChange, this, 0, 0), this.glContextID = -1, this.elapsedTime = performance.now(), this.deltaTime = 0, this._autoUpdate = !1, this.once("modelLoaded", () => this.init(e));
+	}
+	static from(e, t) {
+		let n = new this(t);
+		return q.setupLive2DModel(n, e, t).then(() => n);
+	}
+	static fromSync(e, t) {
+		let n = new this(t);
+		return q.setupLive2DModel(n, e, t).then(t?.onLoad).catch(t?.onError), n;
+	}
+	static registerTicker(e) {
+		Y = e;
+	}
+	get autoUpdate() {
+		return this._autoUpdate;
+	}
+	set autoUpdate(e) {
+		Y ||= window.PIXI?.Ticker, e ? this._destroyed || (Y ? (Y.shared.add(this.onTickerUpdate, this), this._autoUpdate = !0) : H.warn(this.tag, "No Ticker registered, please call Live2DModel.registerTicker(Ticker).")) : (Y?.shared.remove(this.onTickerUpdate, this), this._autoUpdate = !1);
+	}
+	init(e) {
+		this.tag = `Live2DModel(${this.internalModel.settings.name})`;
+		let t = Object.assign({
+			autoUpdate: !0,
+			autoInteract: !0
+		}, e);
+		t.autoInteract && (this.interactive = !0), this.autoInteract = t.autoInteract, this.autoUpdate = t.autoUpdate;
+	}
+	onAnchorChange() {
+		this.pivot.set(this.anchor.x * this.internalModel.width, this.anchor.y * this.internalModel.height);
+	}
+	motion(e, t, n) {
+		return t === void 0 ? this.internalModel.motionManager.startRandomMotion(e, n) : this.internalModel.motionManager.startMotion(e, t, n);
+	}
+	expression(e) {
+		return this.internalModel.motionManager.expressionManager ? e === void 0 ? this.internalModel.motionManager.expressionManager.setRandomExpression() : this.internalModel.motionManager.expressionManager.setExpression(e) : Promise.resolve(!1);
+	}
+	focus(e, t, n = !1) {
+		J.x = e, J.y = t, this.toModelPosition(J, J, !0);
+		let r = J.x / this.internalModel.originalWidth * 2 - 1, i = J.y / this.internalModel.originalHeight * 2 - 1, a = Math.atan2(i, r);
+		this.internalModel.focusController.focus(Math.cos(a), -Math.sin(a), n);
+	}
+	tap(e, t) {
+		let n = this.hitTest(e, t);
+		n.length && (H.log(this.tag, "Hit", n), this.emit("hit", n));
+	}
+	hitTest(e, t) {
+		return J.x = e, J.y = t, this.toModelPosition(J, J), this.internalModel.hitTest(J.x, J.y);
+	}
+	toModelPosition(e, t = e.clone(), n) {
+		return n || (this._recursivePostUpdateTransform(), this.parent ? this.displayObjectUpdateTransform() : (this.parent = this._tempDisplayObjectParent, this.displayObjectUpdateTransform(), this.parent = null)), this.transform.worldTransform.applyInverse(e, t), this.internalModel.localTransform.applyInverse(t, t), t;
+	}
+	containsPoint(e) {
+		return this.getBounds(!0).contains(e.x, e.y);
+	}
+	_calculateBounds() {
+		this._bounds.addFrame(this.transform, 0, 0, this.internalModel.width, this.internalModel.height);
+	}
+	onTickerUpdate() {
+		this.update(Y.shared.deltaMS);
+	}
+	update(e) {
+		this.deltaTime += e, this.elapsedTime += e;
+	}
+	_render(e) {
+		this.registerInteraction(e.plugins.interaction), e.batch.reset(), e.geometry.reset(), e.shader.reset(), e.state.reset();
+		let t = !1;
+		this.glContextID !== e.CONTEXT_UID && (this.glContextID = e.CONTEXT_UID, this.internalModel.updateWebGLContext(e.gl, this.glContextID), t = !0);
+		for (let n = 0; n < this.textures.length; n++) {
+			let r = this.textures[n];
+			r.valid && ((t || !r.baseTexture._glTextures[this.glContextID]) && (e.gl.pixelStorei(WebGLRenderingContext.UNPACK_FLIP_Y_WEBGL, this.internalModel.textureFlipY), e.texture.bind(r.baseTexture, 0)), this.internalModel.bindTexture(n, r.baseTexture._glTextures[this.glContextID].texture), r.baseTexture.touched = e.textureGC.count);
+		}
+		let n = e.framebuffer.viewport;
+		this.internalModel.viewport = [
+			n.x,
+			n.y,
+			n.width,
+			n.height
+		], this.deltaTime &&= (this.internalModel.update(this.deltaTime, this.elapsedTime), 0);
+		let r = pr.copyFrom(e.globalUniforms.uniforms.projectionMatrix).append(this.worldTransform);
+		this.internalModel.updateTransform(r), this.internalModel.draw(e.gl), e.state.reset(), e.texture.reset();
+	}
+	destroy(e) {
+		this.emit("destroy"), this.autoUpdate = !1, this.unregisterInteraction(), e?.texture && this.textures.forEach((t) => t.destroy(e.baseTexture)), this.internalModel.destroy(), super.destroy(e);
+	}
+};
+Pn(mr, [lr]);
+var X = class {
+	static resolveURL(e, t) {
+		let n = X.filesMap[e]?.[t];
+		if (n === void 0) throw Error("Cannot find this file from uploaded files: " + t);
+		return n;
+	}
+	static upload(e, t) {
+		return l(this, null, function* () {
+			let n = {};
+			for (let r of t.getDefinedFiles()) {
+				let a = decodeURI(i.resolve(t.url, r)), o = e.find((e) => e.webkitRelativePath === a);
+				o && (n[r] = URL.createObjectURL(o));
+			}
+			X.filesMap[t._objectURL] = n;
+		});
+	}
+	static createSettings(e) {
+		return l(this, null, function* () {
+			let t = e.find((e) => e.name.endsWith("model.json") || e.name.endsWith("model3.json"));
+			if (!t) throw TypeError("Settings file not found");
+			let n = yield X.readText(t), r = JSON.parse(n);
+			r.url = t.webkitRelativePath;
+			let i = q.findRuntime(r);
+			if (!i) throw Error("Unknown settings JSON");
+			let a = i.createModelSettings(r);
+			return a._objectURL = URL.createObjectURL(t), a;
+		});
+	}
+	static readText(e) {
+		return l(this, null, function* () {
+			return new Promise((t, n) => {
+				let r = new FileReader();
+				r.onload = () => t(r.result), r.onerror = n, r.readAsText(e, "utf8");
+			});
+		});
+	}
+}, hr = X;
+hr.filesMap = {}, hr.factory = (e, t) => l(void 0, null, function* () {
+	if (Array.isArray(e.source) && e.source[0] instanceof File) {
+		let t = e.source, n = t.settings;
+		if (!n) n = yield X.createSettings(t);
+		else if (!n._objectURL) throw Error("\"_objectURL\" must be specified in ModelSettings");
+		n.validateFiles(t.map((e) => encodeURI(e.webkitRelativePath))), yield X.upload(t, n), n.resolveURL = function(e) {
+			return X.resolveURL(this._objectURL, e);
+		}, e.source = n, e.live2dModel.once("modelLoaded", (e) => {
+			e.once("destroy", function() {
+				let e = this.settings._objectURL;
+				if (URL.revokeObjectURL(e), X.filesMap[e]) for (let t of Object.values(X.filesMap[e])) URL.revokeObjectURL(t);
+				delete X.filesMap[e];
+			});
+		});
+	}
+	return t();
+}), q.live2DModelMiddlewares.unshift(hr.factory);
+var Z = class {
+	static unzip(e, t) {
+		return l(this, null, function* () {
+			let n = yield Z.getFilePaths(e), r = [];
+			for (let e of t.getDefinedFiles()) {
+				let a = decodeURI(i.resolve(t.url, e));
+				n.includes(a) && r.push(a);
+			}
+			let a = yield Z.getFiles(e, r);
+			for (let e = 0; e < a.length; e++) {
+				let t = r[e], n = a[e];
+				Object.defineProperty(n, "webkitRelativePath", { value: t });
+			}
+			return a;
+		});
+	}
+	static createSettings(e) {
+		return l(this, null, function* () {
+			let t = (yield Z.getFilePaths(e)).find((e) => e.endsWith("model.json") || e.endsWith("model3.json"));
+			if (!t) throw Error("Settings file not found");
+			let n = yield Z.readText(e, t);
+			if (!n) throw Error("Empty settings file: " + t);
+			let r = JSON.parse(n);
+			r.url = t;
+			let i = q.findRuntime(r);
+			if (!i) throw Error("Unknown settings JSON");
+			return i.createModelSettings(r);
+		});
+	}
+	static zipReader(e, t) {
+		return l(this, null, function* () {
+			throw Error("Not implemented");
+		});
+	}
+	static getFilePaths(e) {
+		return l(this, null, function* () {
+			throw Error("Not implemented");
+		});
+	}
+	static getFiles(e, t) {
+		return l(this, null, function* () {
+			throw Error("Not implemented");
+		});
+	}
+	static readText(e, t) {
+		return l(this, null, function* () {
+			throw Error("Not implemented");
+		});
+	}
+	static releaseReader(e) {}
+}, Q = Z;
+if (Q.ZIP_PROTOCOL = "zip://", Q.uid = 0, Q.factory = (e, t) => l(void 0, null, function* () {
+	let n = e.source, r, i, a;
+	if (typeof n == "string" && (n.endsWith(".zip") || n.startsWith(Z.ZIP_PROTOCOL)) ? (r = n.startsWith(Z.ZIP_PROTOCOL) ? n.slice(Z.ZIP_PROTOCOL.length) : n, i = yield G.load({
+		url: r,
+		type: "blob",
+		target: e.live2dModel
+	})) : Array.isArray(n) && n.length === 1 && n[0] instanceof File && n[0].name.endsWith(".zip") && (i = n[0], r = URL.createObjectURL(i), a = n.settings), i) {
+		if (!i.size) throw Error("Empty zip file");
+		let t = yield Z.zipReader(i, r);
+		a ||= yield Z.createSettings(t), a._objectURL = Z.ZIP_PROTOCOL + Z.uid + "/" + a.url;
+		let n = yield Z.unzip(t, a);
+		n.settings = a, e.source = n, r.startsWith("blob:") && e.live2dModel.once("modelLoaded", (e) => {
+			e.once("destroy", function() {
+				URL.revokeObjectURL(r);
+			});
+		}), Z.releaseReader(t);
+	}
+	return t();
+}), q.live2DModelMiddlewares.unshift(Q.factory), !window.Live2DCubismCore) throw Error("Could not find Cubism 4 runtime. This plugin requires live2dcubismcore.js to be loaded.");
+var gr = class extends Ln {
+	constructor(e, t) {
+		super(e, t), this.queueManager = new Ie(), this.definitions = e.expressions ?? [], this.init();
+	}
+	isFinished() {
+		return this.queueManager.isFinished();
+	}
+	getExpressionIndex(e) {
+		return this.definitions.findIndex((t) => t.Name === e);
+	}
+	getExpressionFile(e) {
+		return e.File;
+	}
+	createExpression(e, t) {
+		return me.create(e);
+	}
+	_setExpression(e) {
+		return this.queueManager.startMotion(e, !1, performance.now());
+	}
+	stopAllExpressions() {
+		this.queueManager.stopAllMotions();
+	}
+	updateParameters(e, t) {
+		return this.queueManager.doUpdateMotion(e, t);
+	}
+}, $ = class e extends Hn {
+	constructor(t) {
+		if (super(t), !e.isValidJSON(t)) throw TypeError("Invalid JSON.");
+		Object.assign(this, new jt(t));
+	}
+	static isValidJSON(e) {
+		return !!e?.FileReferences && typeof e.FileReferences.Moc == "string" && e.FileReferences.Textures?.length > 0 && e.FileReferences.Textures.every((e) => typeof e == "string");
+	}
+	replaceFiles(e) {
+		if (super.replaceFiles(e), this.motions) for (let [t, n] of Object.entries(this.motions)) for (let r = 0; r < n.length; r++) n[r].File = e(n[r].File, `motions.${t}[${r}].File`), n[r].Sound !== void 0 && (n[r].Sound = e(n[r].Sound, `motions.${t}[${r}].Sound`));
+		if (this.expressions) for (let t = 0; t < this.expressions.length; t++) this.expressions[t].File = e(this.expressions[t].File, `expressions[${t}].File`);
+	}
+};
+Pn($, [jt]);
+var _r = class extends Jn {
+	constructor(e, t) {
+		super(e, t), this.groups = { idle: "Idle" }, this.motionDataType = "json", this.queueManager = new Ie(), this.definitions = e.motions ?? {}, this.eyeBlinkIds = e.getEyeBlinkParameters() || [], this.lipSyncIds = e.getLipSyncParameters() || [], this.init(t);
+	}
+	init(e) {
+		super.init(e), this.settings.expressions && (this.expressionManager = new gr(this.settings, e)), this.queueManager.setEventCallback((e, t, n) => {
+			this.emit("motion:" + t);
+		});
+	}
+	isFinished() {
+		return this.queueManager.isFinished();
+	}
+	_startMotion(e, t) {
+		return e.setFinishedMotionHandler(t), this.queueManager.stopAllMotions(), this.queueManager.startMotion(e, !1, performance.now());
+	}
+	_stopAllMotions() {
+		this.queueManager.stopAllMotions();
+	}
+	createMotion(e, t, n) {
+		let r = Pe.create(e), i = new be(e), a = (t === this.groups.idle ? V.idleMotionFadingDuration : V.motionFadingDuration) / 1e3;
+		return i.getMotionFadeInTime() === void 0 && r.setFadeInTime(n.FadeInTime > 0 ? n.FadeInTime : a), i.getMotionFadeOutTime() === void 0 && r.setFadeOutTime(n.FadeOutTime > 0 ? n.FadeOutTime : a), r.setEffectIds(this.eyeBlinkIds, this.lipSyncIds), r;
+	}
+	getMotionFile(e) {
+		return e.File;
+	}
+	getMotionName(e) {
+		return e.File;
+	}
+	getSoundFile(e) {
+		return e.Sound;
+	}
+	updateParameters(e, t) {
+		return this.queueManager.doUpdateMotion(e, t);
+	}
+	destroy() {
+		super.destroy(), this.queueManager.release(), this.queueManager = void 0;
+	}
+}, vr = new b(), yr = class extends Xn {
+	constructor(e, t, r) {
+		super(), this.lipSync = !0, this.breath = u.create(), this.renderer = new At(), this.idParamAngleX = zt, this.idParamAngleY = Bt, this.idParamAngleZ = Vt, this.idParamEyeBallX = Kt, this.idParamEyeBallY = qt, this.idParamBodyAngleX = sn, this.idParamBreath = un, this.pixelsPerUnit = 1, this.centeringTransform = new n(), this.coreModel = e, this.settings = t, this.motionManager = new _r(t, r), this.init();
+	}
+	init() {
+		super.init(), this.settings.getEyeBlinkParameters()?.length > 0 && (this.eyeBlink = p.create(this.settings)), this.breath.setParameters([
+			new d(this.idParamAngleX, 0, 15, 6.5345, .5),
+			new d(this.idParamAngleY, 0, 8, 3.5345, .5),
+			new d(this.idParamAngleZ, 0, 10, 5.5345, .5),
+			new d(this.idParamBodyAngleX, 0, 4, 15.5345, .5),
+			new d(this.idParamBreath, 0, .5, 3.2345, .5)
+		]), this.renderer.initialize(this.coreModel), this.renderer.setIsPremultipliedAlpha(!0);
+	}
+	getSize() {
+		return [this.coreModel.getModel().canvasinfo.CanvasWidth, this.coreModel.getModel().canvasinfo.CanvasHeight];
+	}
+	getLayout() {
+		let e = {};
+		if (this.settings.layout) for (let t of Object.keys(this.settings.layout)) {
+			let n = t.charAt(0).toLowerCase() + t.slice(1);
+			e[n] = this.settings.layout[t];
+		}
+		return e;
+	}
+	setupLayout() {
+		super.setupLayout(), this.pixelsPerUnit = this.coreModel.getModel().canvasinfo.PixelsPerUnit, this.centeringTransform.scale(this.pixelsPerUnit, this.pixelsPerUnit).translate(this.originalWidth / 2, this.originalHeight / 2);
+	}
+	updateWebGLContext(e, t) {
+		this.renderer.firstDraw = !0, this.renderer._bufferData = {
+			vertex: null,
+			uv: null,
+			index: null
+		}, this.renderer.startUp(e), this.renderer._clippingManager._currentFrameNo = t, this.renderer._clippingManager._maskTexture = void 0, z.getInstance()._shaderSets = [];
+	}
+	bindTexture(e, t) {
+		this.renderer.bindTexture(e, t);
+	}
+	getHitAreaDefs() {
+		return this.settings.hitAreas?.map((e) => ({
+			id: e.Id,
+			name: e.Name,
+			index: this.coreModel.getDrawableIndex(e.Id)
+		})) ?? [];
+	}
+	getDrawableIDs() {
+		return this.coreModel.getDrawableIds();
+	}
+	getDrawableIndex(e) {
+		return this.coreModel.getDrawableIndex(e);
+	}
+	getDrawableVertices(e) {
+		if (typeof e == "string" && (e = this.coreModel.getDrawableIndex(e), e === -1)) throw TypeError("Unable to find drawable ID: " + e);
+		let t = this.coreModel.getDrawableVertices(e).slice();
+		for (let e = 0; e < t.length; e += 2) t[e] = t[e] * this.pixelsPerUnit + this.originalWidth / 2, t[e + 1] = -t[e + 1] * this.pixelsPerUnit + this.originalHeight / 2;
+		return t;
+	}
+	updateTransform(e) {
+		this.drawingMatrix.copyFrom(this.centeringTransform).prepend(this.localTransform).prepend(e);
+	}
+	update(e, t) {
+		var n, r, i, a;
+		super.update(e, t), e /= 1e3, t /= 1e3;
+		let o = this.coreModel;
+		this.emit("beforeMotionUpdate");
+		let s = this.motionManager.update(this.coreModel, t);
+		this.emit("afterMotionUpdate"), o.saveParameters(), (n = this.motionManager.expressionManager) == null || n.update(o, t), s || (r = this.eyeBlink) == null || r.updateParameters(o, e), this.updateFocus(), this.updateNaturalMovements(e * 1e3, t * 1e3), (i = this.physics) == null || i.evaluate(o, e), (a = this.pose) == null || a.updateParameters(o, e), this.emit("beforeModelUpdate"), o.update(), o.loadParameters();
+	}
+	updateFocus() {
+		this.coreModel.addParameterValueById(this.idParamEyeBallX, this.focusController.x), this.coreModel.addParameterValueById(this.idParamEyeBallY, this.focusController.y), this.coreModel.addParameterValueById(this.idParamAngleX, this.focusController.x * 30), this.coreModel.addParameterValueById(this.idParamAngleY, this.focusController.y * 30), this.coreModel.addParameterValueById(this.idParamAngleZ, this.focusController.x * this.focusController.y * -30), this.coreModel.addParameterValueById(this.idParamBodyAngleX, this.focusController.x * 10);
+	}
+	updateNaturalMovements(e, t) {
+		var n;
+		(n = this.breath) == null || n.updateParameters(this.coreModel, e / 1e3);
+	}
+	draw(e) {
+		let t = this.drawingMatrix, n = vr.getArray();
+		n[0] = t.a, n[1] = t.b, n[4] = -t.c, n[5] = -t.d, n[12] = t.tx, n[13] = t.ty, this.renderer.setMvpMatrix(vr), this.renderer.setRenderState(e.getParameter(e.FRAMEBUFFER_BINDING), this.viewport), this.renderer.drawModel();
+	}
+	destroy() {
+		super.destroy(), this.renderer.release(), this.coreModel.release(), this.renderer = void 0, this.coreModel = void 0;
+	}
+}, br, xr = 20;
+function Sr() {
+	return E.isStarted() ? Promise.resolve() : (br ??= new Promise((e, t) => {
+		function n() {
+			try {
+				Cr(), e();
+			} catch (e) {
+				if (xr--, xr < 0) {
+					let n = /* @__PURE__ */ Error("Failed to start up Cubism 4 framework.");
+					n.cause = e, t(n);
+					return;
+				}
+				H.log("Cubism4", "Startup failed, retrying 10ms later..."), setTimeout(n, 10);
+			}
+		}
+		n();
+	}), br);
+}
+function Cr(e) {
+	e = Object.assign({
+		logFunction: console.log,
+		loggingLevel: D.LogLevel_Verbose
+	}, e), E.startUp(e), E.initialize();
+}
+q.registerRuntime({
+	version: 4,
+	ready: Sr,
+	test(e) {
+		return e instanceof $ || $.isValidJSON(e);
+	},
+	isValidMoc(e) {
+		if (e.byteLength < 4) return !1;
+		let t = new Int8Array(e, 0, 4);
+		return String.fromCharCode(...t) === "MOC3";
+	},
+	createModelSettings(e) {
+		return new $(e);
+	},
+	createCoreModel(e) {
+		let t = ce.create(e);
+		try {
+			let e = t.createModel();
+			return e.__moc = t, e;
+		} catch (e) {
+			try {
+				t.release();
+			} catch {}
+			throw e;
+		}
+	},
+	createInternalModel(e, t, n) {
+		let r = new yr(e, t, n), i = e;
+		return i.__moc && (r.__moc = i.__moc, delete i.__moc, r.once("destroy", wr)), r;
+	},
+	createPhysics(e, t) {
+		return $e.create(t);
+	},
+	createPose(e, t) {
+		return _.create(t);
+	}
+});
+function wr() {
+	var e;
+	(e = this.__moc) == null || e.release();
+}
+//#endregion
+export { fe as ACubismMotion, d as BreathParameterData, ie as CSM_ASSERT, re as Constant, gr as Cubism4ExpressionManager, yr as Cubism4InternalModel, $ as Cubism4ModelSettings, _r as Cubism4MotionManager, x as CubismBlendMode, u as CubismBreath, St as CubismClippingContext, bt as CubismClippingManager_WebGL, he as CubismConfig, j as CubismDebug, me as CubismExpressionMotion, p as CubismEyeBlink, E as CubismFramework, oe as CubismLogDebug, A as CubismLogError, O as CubismLogInfo, ae as CubismLogVerbose, k as CubismLogWarning, y as CubismMath, b as CubismMatrix44, ce as CubismMoc, se as CubismModel, jt as CubismModelSettingsJson, de as CubismModelUserData, le as CubismModelUserDataJson, Pe as CubismMotion, _e as CubismMotionCurve, N as CubismMotionCurveTarget, ye as CubismMotionData, ve as CubismMotionEvent, be as CubismMotionJson, Re as CubismMotionManager, F as CubismMotionPoint, Fe as CubismMotionQueueEntry, Ie as CubismMotionQueueManager, ge as CubismMotionSegment, P as CubismMotionSegmentType, $e as CubismPhysics, Ue as CubismPhysicsInput, Ke as CubismPhysicsJson, We as CubismPhysicsOutput, Ve as CubismPhysicsParticle, Ge as CubismPhysicsRig, L as CubismPhysicsSource, He as CubismPhysicsSubRig, ze as CubismPhysicsTargetType, _ as CubismPose, xt as CubismRenderTextureResource, ne as CubismRenderer, At as CubismRenderer_WebGL, z as CubismShader_WebGL, S as CubismTextureColor, v as CubismVector2, xe as EvaluationOptionFlag, M as ExpressionBlendType, Ln as ExpressionManager, m as EyeState, hr as FileLoader, Vn as FocusController, Pt as HitAreaBody, Nt as HitAreaHead, Mt as HitAreaPrefix, lr as InteractionMixin, Xn as InternalModel, Le as InvalidMotionQueueEntryHandleValue, On as LOGICAL_HEIGHT, Dn as LOGICAL_WIDTH, q as Live2DFactory, G as Live2DLoader, mr as Live2DModel, fr as Live2DTransform, D as LogLevel, Hn as ModelSettings, Jn as MotionManager, qn as MotionPreloadStrategy, Un as MotionPriority, Wn as MotionState, et as Options, zt as ParamAngleX, Bt as ParamAngleY, Vt as ParamAngleZ, dn as ParamArmLA, pn as ParamArmLB, fn as ParamArmRA, mn as ParamArmRB, wn as ParamBaseX, Tn as ParamBaseY, sn as ParamBodyAngleX, cn as ParamBodyAngleY, ln as ParamBodyAngleZ, un as ParamBreath, $t as ParamBrowLAngle, tn as ParamBrowLForm, Zt as ParamBrowLX, Yt as ParamBrowLY, en as ParamBrowRAngle, nn as ParamBrowRForm, Qt as ParamBrowRX, Xt as ParamBrowRY, Sn as ParamBustX, Cn as ParamBustY, on as ParamCheek, Jt as ParamEyeBallForm, Kt as ParamEyeBallX, qt as ParamEyeBallY, Ht as ParamEyeLOpen, Ut as ParamEyeLSmile, Wt as ParamEyeROpen, Gt as ParamEyeRSmile, yn as ParamHairBack, bn as ParamHairFluffy, _n as ParamHairFront, vn as ParamHairSide, hn as ParamHandL, gn as ParamHandR, rn as ParamMouthForm, an as ParamMouthOpenY, En as ParamNONE, xn as ParamShoulderY, ee as PartData, Lt as PartsArmLPrefix, It as PartsArmPrefix, Rt as PartsArmRPrefix, Ft as PartsIdCore, Be as PhysicsJsonEffectiveForces, B as ShaderNames, U as SoundManager, kn as VERSION, $n as XHRLoader, Q as ZipLoader, Pn as applyMixins, An as clamp, V as config, Nn as copyArray, Mn as copyProperty, ht as csmRect, Sr as cubism4Ready, Fn as folderName, kt as fragmentShaderSrcMaskInvertedPremultipliedAlpha, Ot as fragmentShaderSrcMaskPremultipliedAlpha, Dt as fragmentShaderSrcPremultipliedAlpha, wt as fragmentShaderSrcsetupMask, H as logger, jn as rand, In as remove, Cr as startUpCubism4, Tt as vertexShaderSrc, Et as vertexShaderSrcMasked, Ct as vertexShaderSrcSetupMask };