@nodecraft/rendermite 1.5.0 → 1.6.1

package/dist/model-bytecode-gWy5_uCj.js

@@ -0,0 +1,742 @@
+import { t as parseClassFile } from "./classfile-Bo7FUrrD.js";
+import { i as mergeModels, r as cubesOf, t as buildsOwnMesh } from "./merge-NDYxpmL8.js";
+//#region src/entities/model-bytecode.ts
+/**
+* Abstract interpretation of a boxy-model builder, enough to recover the geometry.
+*
+* The whole premise of the entity-geometry extractor: entity models are Java code, but the code is a
+* straight line of constant-argument calls into a tiny builder vocabulary. Vanilla 1.17+ builds a
+* `MeshDefinition` of `PartDefinition`s from `CubeListBuilder`s; pre-1.17 vanilla and most mods poke
+* `ModelRenderer`-alikes directly. Both are the same eight operations.
+*
+* Calls are classified by **descriptor shape, not class name**. That is what makes one interpreter
+* cover obfuscated vanilla (`fyp.a(FFFFFF)Lfyp;`) and a mod shipping its own copy of the API
+* (`AdvancedModelBox.addBox(FFFFFFFZ)V`) without a mapping file or a per-mod table.
+*
+* Conditionals are taken and recorded. A model builder's branches are all on a constructor argument —
+* a `CubeDeformation`, a baby-variant flag — so every arm builds a real shape and the fall-through is
+* one of them; the note says so. A *loop* is refused outright, because following it would emit the
+* same boxes twice or spin, and a wrong shape is worse than a recorded gap.
+*/
+/** Argument slot count and shape of a descriptor's parameter list. */
+function parseDescriptor(descriptor) {
+	const args = [];
+	let at = 1;
+	while (descriptor[at] !== ")") {
+		const start = at;
+		while (descriptor[at] === "[") at++;
+		if (descriptor[at] === "L") at = descriptor.indexOf(";", at) + 1;
+		else at++;
+		args.push(descriptor.slice(start, at));
+	}
+	return {
+		args,
+		returns: descriptor.slice(at + 1)
+	};
+}
+const NUMERIC = /* @__PURE__ */ new Set([
+	"F",
+	"D",
+	"I",
+	"J",
+	"S",
+	"B",
+	"C"
+]);
+/** Every entity sheet is a power of two, at least 16 in each direction. A texture offset rarely is. */
+function isSheetSize(width, height) {
+	const power = (value) => value >= 16 && (value & value - 1) === 0;
+	return power(width) && power(height);
+}
+/** `ldc`, `ldc_w`, `ldc2_w`: a constant, narrow or wide index. */
+const LOAD_CONSTANT = /* @__PURE__ */ new Set([
+	18,
+	19,
+	20
+]);
+/** `lconst_0`/`lconst_1` and `dconst_0`/`dconst_1`, which push 0 and 1. */
+const LONG_OR_DOUBLE_CONSTANT = /* @__PURE__ */ new Set([
+	9,
+	10,
+	14,
+	15
+]);
+/** Every `return` that ends a method, with or without a value. */
+const RETURNS = /* @__PURE__ */ new Set([
+	172,
+	173,
+	174,
+	175,
+	176,
+	177
+]);
+/**
+* Every array load: reading back an element of an array the builder filled. All eight, because
+* missing one costs a whole model — `daload` alone was the ender dragon.
+*/
+const ARRAY_LOADS = /* @__PURE__ */ new Set([
+	46,
+	47,
+	48,
+	49,
+	50,
+	51,
+	52,
+	53
+]);
+/** Every array store, the mirror of `ARRAY_LOADS`: `dastore` alone was the silverfish. */
+const ARRAY_STORES = /* @__PURE__ */ new Set([
+	79,
+	80,
+	81,
+	82,
+	83,
+	84,
+	85,
+	86
+]);
+/** The four invoke forms. `invokeinterface` carries two extra bytes; `invokestatic` has no receiver. */
+const INVOKES = /* @__PURE__ */ new Set([
+	182,
+	183,
+	184,
+	185
+]);
+/** Field names a model writes its texture dimensions to, across the eras and the loader APIs. */
+const TEXTURE_WIDTH_FIELDS = /* @__PURE__ */ new Set(["texWidth", "textureWidth"]);
+const TEXTURE_HEIGHT_FIELDS = /* @__PURE__ */ new Set(["texHeight", "textureHeight"]);
+/** Deep enough for `<init>` → `super()` → `super()` and the static factories that mirror it. */
+const MAX_INLINE_DEPTH = 5;
+/** Frames per method. A model spends a handful; the cap is there so a strange jar cannot spend all day. */
+const INLINE_BUDGET = 96;
+/** How far up a hierarchy to look for an inherited method, which is as deep as a model hierarchy goes. */
+const MAX_METHOD_HOPS = 6;
+function newShared(resolve) {
+	return {
+		handles: [],
+		fields: /* @__PURE__ */ new Map(),
+		notes: [],
+		textureSize: [64, 32],
+		branched: false,
+		nextHandle: 1,
+		resolve,
+		budget: INLINE_BUDGET
+	};
+}
+/** The method a call names, looked up where the JVM would look: the owner, then up its ancestors. */
+function findMethod(resolve, owner, name, descriptor) {
+	let at = owner;
+	for (let hops = 0; at && hops < MAX_METHOD_HOPS; hops++) {
+		const classFile = resolve(at);
+		if (!classFile) return null;
+		const method = classFile.methods.find((candidate) => candidate.name === name && candidate.descriptor === descriptor && candidate.code);
+		if (method?.code) return {
+			code: method.code,
+			classFile
+		};
+		at = classFile.superClass;
+	}
+	return null;
+}
+var Interpreter = class Interpreter {
+	stack = [];
+	locals = /* @__PURE__ */ new Map();
+	shared;
+	depth;
+	/** What this frame returned, for the caller that inlined it. */
+	returned = null;
+	constructor(shared, depth = 0) {
+		this.shared = shared;
+		this.depth = depth;
+	}
+	handle() {
+		const created = {
+			id: this.shared.nextHandle++,
+			cubes: [],
+			children: [],
+			pendingUv: [0, 0],
+			pendingInflate: 0,
+			pendingMirror: false
+		};
+		this.shared.handles.push(created);
+		return created;
+	}
+	/** Puts the receiver and arguments where the callee's bytecode reads them; longs take two slots. */
+	seed(receiver, descriptor, args) {
+		let slot = 0;
+		if (receiver) this.locals.set(slot++, receiver);
+		for (const [index, shape] of parseDescriptor(descriptor).args.entries()) {
+			this.locals.set(slot, args[index] ?? { kind: "unknown" });
+			slot += shape === "J" || shape === "D" ? 2 : 1;
+		}
+	}
+	/**
+	* Interprets a call into the model's own code, with the arguments it was actually given.
+	*
+	* This is what makes an inherited part come out right. `CowModel` calls `super(12, 0)` and the legs
+	* it inherits are `addBox(-2, 0, -2, 4, cubeHeight, 4)`: without the 12 they are boxes of height
+	* zero, and a cow with four invisible legs looks exactly like a bug in the mesher.
+	*
+	* Restricted to model code on purpose. The builder API is in the same jar, and `CubeListBuilder`
+	* must keep its abstract treatment rather than being followed into.
+	*/
+	inline(owner, name, descriptor, receiver, args) {
+		if (this.depth >= MAX_INLINE_DEPTH || this.shared.budget <= 0) return null;
+		const target = findMethod(this.shared.resolve, owner, name, descriptor);
+		if (!target) return null;
+		this.shared.budget--;
+		const frame = new Interpreter(this.shared, this.depth + 1);
+		frame.seed(receiver, descriptor, args);
+		return frame.run(target.code, target.classFile) ? frame.returned : null;
+	}
+	pop() {
+		return this.stack.pop() ?? { kind: "unknown" };
+	}
+	number(value) {
+		return value.kind === "number" ? value.value : 0;
+	}
+	/**
+	* Applies one call. Everything is decided by the descriptor: how many arguments to take, whether
+	* there is a receiver, and which of the builder operations the shape corresponds to.
+	*/
+	call(owner, name, descriptor, hasReceiver) {
+		const { args, returns } = parseDescriptor(descriptor);
+		const taken = [];
+		for (let index = args.length - 1; index >= 0; index--) taken.unshift(this.pop());
+		const receiver = hasReceiver ? this.pop() : null;
+		const target = receiver?.kind === "object" ? receiver.handle : null;
+		const numbers = taken.map((value) => this.number(value));
+		const floats = args.filter((arg) => NUMERIC.has(arg)).length;
+		if (args.length === 2 && args.every((arg) => arg === "I") && target) {
+			const known = taken.every((value) => value.kind === "number");
+			if (known && target.uvFromConstructor && isSheetSize(numbers[0], numbers[1])) this.shared.textureSize = [numbers[0], numbers[1]];
+			else if (known) target.pendingUv = [numbers[0], numbers[1]];
+			this.push(returns === "V" ? null : receiver);
+			return;
+		}
+		const named = args[0] === "Ljava/lang/String;" && floats >= 6 && args.length >= 7 && NUMERIC.has(args[6]);
+		const first = named ? 1 : 0;
+		if (target && (named || floats >= 6 && args.length >= 6 && NUMERIC.has(args[0]) && NUMERIC.has(args[5]))) {
+			const extra = args.slice(first + 6);
+			target.cubes.push({
+				origin: [
+					numbers[first],
+					numbers[first + 1],
+					numbers[first + 2]
+				],
+				size: [
+					numbers[first + 3],
+					numbers[first + 4],
+					numbers[first + 5]
+				],
+				uv: [...target.pendingUv],
+				inflate: extra.some((arg) => NUMERIC.has(arg)) ? this.number(taken[first + 6]) : target.pendingInflate,
+				mirror: target.pendingMirror || extra.includes("Z") && this.number(taken[args.length - 1]) === 1
+			});
+			this.push(returns === "V" ? null : receiver);
+			return;
+		}
+		if (args.length === 3 && args.every((arg) => NUMERIC.has(arg))) {
+			if (target) {
+				target.pivot = [
+					numbers[0],
+					numbers[1],
+					numbers[2]
+				];
+				this.push(returns === "V" ? null : receiver);
+			} else {
+				const pose = this.handle();
+				pose.pivot = [
+					numbers[0],
+					numbers[1],
+					numbers[2]
+				];
+				this.push({
+					kind: "object",
+					handle: pose
+				});
+			}
+			return;
+		}
+		if (args.length === 6 && args.every((arg) => NUMERIC.has(arg)) && !target) {
+			const pose = this.handle();
+			pose.pivot = [
+				numbers[0],
+				numbers[1],
+				numbers[2]
+			];
+			pose.rotation = [
+				numbers[3],
+				numbers[4],
+				numbers[5]
+			];
+			this.push({
+				kind: "object",
+				handle: pose
+			});
+			return;
+		}
+		if (args.length === 3 && args[0] === "Ljava/lang/String;" && taken[1].kind === "object") {
+			const child = this.handle();
+			child.name = taken[0].kind === "string" ? taken[0].value : `part${child.id}`;
+			const builder = taken[1].handle;
+			const pose = taken[2].kind === "object" ? taken[2].handle : null;
+			child.cubes = [...builder.cubes];
+			child.pivot = pose?.pivot ?? [
+				0,
+				0,
+				0
+			];
+			child.rotation = pose?.rotation ?? [
+				0,
+				0,
+				0
+			];
+			builder.consumed = true;
+			if (pose) pose.consumed = true;
+			if (target) {
+				const existing = target.children.findIndex((sibling) => sibling.name === child.name);
+				if (existing === -1) target.children.push(child);
+				else {
+					target.children[existing].consumed = true;
+					target.children[existing] = child;
+				}
+			} else child.orphaned = true;
+			this.push({
+				kind: "object",
+				handle: child
+			});
+			return;
+		}
+		const lambda = taken.find((value) => value.kind === "lambda");
+		if (lambda?.kind === "lambda" && receiver?.kind === "object" && taken.length === 1) {
+			const applied = this.inline(lambda.owner, lambda.name, lambda.descriptor, null, [receiver]);
+			this.push(returns === "V" ? null : applied ?? receiver);
+			return;
+		}
+		if (args.length === 1 && args[0] === "Ljava/lang/String;" && returns.startsWith("L") && target) {
+			const name_ = taken[0].kind === "string" ? taken[0].value : "";
+			const found = target.children.find((child) => child.name === name_);
+			if (found) this.push({
+				kind: "object",
+				handle: found
+			});
+			else {
+				const child = this.handle();
+				child.name = name_ || `part${child.id}`;
+				target.children.push(child);
+				this.push({
+					kind: "object",
+					handle: child
+				});
+			}
+			return;
+		}
+		if (args.length === 1 && args[0].startsWith("L") && target && taken[0].kind === "object" && (taken[0].handle.cubes.length > 0 || taken[0].handle.children.length > 0)) {
+			target.children.push(taken[0].handle);
+			this.push(returns === "V" ? null : receiver);
+			return;
+		}
+		const objects = taken.filter((value) => value.kind === "object");
+		if (!target && objects.length === 1 && taken.length - objects.length === args.length - 1 && args.length >= 2 && args.slice(1).every((arg) => NUMERIC.has(arg))) {
+			if (args.length === 3) this.shared.textureSize = [numbers[1], numbers[2]];
+			this.push(objects[0]);
+			return;
+		}
+		if (args.length === 1 && args[0] === "Z" && target) {
+			target.pendingMirror = this.number(taken[0]) === 1;
+			this.push(returns === "V" ? null : receiver);
+			return;
+		}
+		if (args.length === 0 && returns.startsWith("L")) {
+			if (target) {
+				target.isRoot = true;
+				this.push(receiver);
+				return;
+			}
+			const built = this.inline(owner, name, descriptor, null, taken);
+			this.push(built ?? {
+				kind: "object",
+				handle: this.handle()
+			});
+			return;
+		}
+		const inlined = this.inline(owner, name, descriptor, receiver, taken);
+		this.push(returns === "V" ? null : inlined ?? { kind: "unknown" });
+	}
+	push(value) {
+		if (value) this.stack.push(value);
+	}
+	/** Runs one method's code. Returns false when it hit something it will not guess at. */
+	run(code, constants) {
+		let at = 0;
+		while (at < code.length) {
+			const op = code[at++];
+			switch (true) {
+				case op === 1:
+					this.push({ kind: "unknown" });
+					break;
+				case op >= 2 && op <= 8:
+					this.push({
+						kind: "number",
+						value: op - 3
+					});
+					break;
+				case LONG_OR_DOUBLE_CONSTANT.has(op):
+					this.push({
+						kind: "number",
+						value: op === 10 || op === 15 ? 1 : 0
+					});
+					break;
+				case op >= 11 && op <= 13:
+					this.push({
+						kind: "number",
+						value: op - 11
+					});
+					break;
+				case op === 16:
+					this.push({
+						kind: "number",
+						value: code[at++] << 24 >> 24
+					});
+					break;
+				case op === 17:
+					this.push({
+						kind: "number",
+						value: (code[at] << 8 | code[at + 1]) << 16 >> 16
+					});
+					at += 2;
+					break;
+				case LOAD_CONSTANT.has(op): {
+					let index;
+					if (op === 18) index = code[at++];
+					else {
+						index = code[at] << 8 | code[at + 1];
+						at += 2;
+					}
+					const value = constants.literal(index);
+					if (typeof value === "string") this.push({
+						kind: "string",
+						value
+					});
+					else if (typeof value === "number") this.push({
+						kind: "number",
+						value
+					});
+					else if (typeof value === "bigint") this.push({
+						kind: "number",
+						value: Number(value)
+					});
+					else this.push({ kind: "unknown" });
+					break;
+				}
+				case op >= 21 && op <= 25:
+					this.push(this.locals.get(code[at++]) ?? { kind: "unknown" });
+					break;
+				case op >= 26 && op <= 45:
+					this.push(this.locals.get((op - 26) % 4) ?? { kind: "unknown" });
+					break;
+				case op >= 54 && op <= 58:
+					this.locals.set(code[at++], this.pop());
+					break;
+				case op >= 59 && op <= 78:
+					this.locals.set((op - 59) % 4, this.pop());
+					break;
+				case ARRAY_LOADS.has(op): {
+					this.pop();
+					const array = this.pop();
+					this.push(array.kind === "array" ? array.items[0] ?? { kind: "unknown" } : { kind: "unknown" });
+					break;
+				}
+				case op >= 120 && op <= 131:
+					this.pop();
+					this.pop();
+					this.push({
+						kind: "number",
+						value: 0
+					});
+					break;
+				case op === 193:
+					at += 2;
+					this.pop();
+					this.push({
+						kind: "number",
+						value: 0
+					});
+					break;
+				case op === 191: return true;
+				case op === 190:
+					this.pop();
+					this.push({
+						kind: "number",
+						value: 0
+					});
+					break;
+				case ARRAY_STORES.has(op): {
+					const value = this.pop();
+					this.pop();
+					const array = this.pop();
+					if (array.kind === "array") array.items.push(value);
+					break;
+				}
+				case op === 87:
+					this.pop();
+					break;
+				case op === 88:
+					this.pop();
+					this.pop();
+					break;
+				case op === 89: {
+					const top = this.pop();
+					this.push(top);
+					this.push(top);
+					break;
+				}
+				case op === 90: {
+					const top = this.pop();
+					const under = this.pop();
+					this.push(top);
+					this.push(under);
+					this.push(top);
+					break;
+				}
+				case op >= 96 && op <= 111: {
+					const right = this.number(this.pop());
+					const left = this.number(this.pop());
+					const operate = [
+						() => left + right,
+						() => left - right,
+						() => left * right,
+						() => left / right
+					][Math.floor((op - 96) / 4)];
+					this.push({
+						kind: "number",
+						value: operate()
+					});
+					break;
+				}
+				case op >= 112 && op <= 115: {
+					const right = this.number(this.pop());
+					const left = this.number(this.pop());
+					this.push({
+						kind: "number",
+						value: right === 0 ? 0 : left % right
+					});
+					break;
+				}
+				case op >= 116 && op <= 119:
+					this.push({
+						kind: "number",
+						value: -this.number(this.pop())
+					});
+					break;
+				case op >= 133 && op <= 147: break;
+				case op === 132:
+					at += 2;
+					break;
+				case RETURNS.has(op):
+					if (op !== 177) this.returned = this.pop();
+					return true;
+				case op === 178:
+					at += 2;
+					this.push({ kind: "unknown" });
+					break;
+				case op === 179:
+					at += 2;
+					this.pop();
+					break;
+				case op === 180: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					this.pop();
+					const reference = constants.reference(index);
+					this.push(this.shared.fields.get(reference?.name ?? "") ?? { kind: "unknown" });
+					break;
+				}
+				case op === 181: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					const value = this.pop();
+					this.pop();
+					const reference = constants.reference(index);
+					if (reference) {
+						const previous = this.shared.fields.get(reference.name);
+						if (previous?.kind === "object" && value.kind === "object" && previous.handle !== value.handle) previous.handle.consumed = true;
+						this.shared.fields.set(reference.name, value);
+						if (value.kind === "object" && !value.handle.name) value.handle.name = reference.name;
+						if (TEXTURE_WIDTH_FIELDS.has(reference.name)) this.shared.textureSize[0] = this.number(value);
+						else if (TEXTURE_HEIGHT_FIELDS.has(reference.name)) this.shared.textureSize[1] = this.number(value);
+					}
+					break;
+				}
+				case INVOKES.has(op): {
+					const index = code[at] << 8 | code[at + 1];
+					at += 2;
+					if (op === 185) at += 2;
+					const reference = constants.reference(index);
+					if (!reference) break;
+					if (op === 183 && reference.name === "<init>") {
+						const { args } = parseDescriptor(reference.descriptor);
+						const taken = [];
+						for (let count = 0; count < args.length; count++) taken.unshift(this.pop());
+						const objectRef = this.pop();
+						if (objectRef.kind === "object" && args.length >= 2 && args.at(-1) === "I" && args.at(-2) === "I") {
+							objectRef.handle.pendingUv = [this.number(taken[args.length - 2]), this.number(taken[args.length - 1])];
+							objectRef.handle.uvFromConstructor = true;
+						}
+						this.inline(reference.owner, reference.name, reference.descriptor, objectRef, taken);
+						break;
+					}
+					this.call(reference.owner, reference.name, reference.descriptor, op !== 184);
+					break;
+				}
+				case op === 187:
+					at += 2;
+					this.push({
+						kind: "object",
+						handle: this.handle()
+					});
+					break;
+				case op === 188:
+					at += 1;
+					this.pop();
+					this.push({
+						kind: "array",
+						items: []
+					});
+					break;
+				case op === 189:
+					at += 2;
+					this.pop();
+					this.push({
+						kind: "array",
+						items: []
+					});
+					break;
+				case op === 192:
+					at += 2;
+					break;
+				case op === 186: {
+					const index = code[at] << 8 | code[at + 1];
+					at += 4;
+					const reference = constants.reference(index);
+					const { args, returns } = reference ? parseDescriptor(reference.descriptor) : {
+						args: [],
+						returns: "V"
+					};
+					for (let count = 0; count < args.length; count++) this.pop();
+					const target = constants.lambdaTarget(index);
+					this.push(returns === "V" ? null : target ? {
+						kind: "lambda",
+						...target
+					} : { kind: "unknown" });
+					break;
+				}
+				case op >= 153 && op <= 166: {
+					const comparisons = op >= 159 ? 2 : 1;
+					for (let count = 0; count < comparisons; count++) this.pop();
+					at += 2;
+					this.shared.branched = true;
+					break;
+				}
+				case op === 198 || op === 199:
+					at += 2;
+					this.pop();
+					this.shared.branched = true;
+					break;
+				case op === 167: {
+					const offset = (code[at] << 8 | code[at + 1]) << 16 >> 16;
+					if (offset <= 0) {
+						this.shared.notes.push("backward goto: the builder loops, so its geometry is not recoverable");
+						return false;
+					}
+					at += offset - 1;
+					this.shared.branched = true;
+					break;
+				}
+				case op >= 148 && op <= 152:
+					this.pop();
+					this.pop();
+					this.push({
+						kind: "number",
+						value: 0
+					});
+					break;
+				default:
+					this.shared.notes.push(`unsupported opcode 0x${op.toString(16)} at ${at - 1}`);
+					return false;
+			}
+		}
+		return true;
+	}
+};
+/** Turns a handle tree into the exported shape. */
+function toPart(handle) {
+	return {
+		name: handle.name ?? `part${handle.id}`,
+		pivot: handle.pivot ?? [
+			0,
+			0,
+			0
+		],
+		rotation: handle.rotation ?? [
+			0,
+			0,
+			0
+		],
+		cubes: handle.cubes,
+		children: handle.children.map((child) => toPart(child))
+	};
+}
+function extractModel(bytes, following) {
+	const classFile = parseClassFile(bytes);
+	const notes = [];
+	const candidates = [];
+	const outward = following?.isModelCode ?? true;
+	const own = (internalName) => {
+		if (internalName === classFile.thisClass) return classFile;
+		return outward ? following?.resolve(internalName) ?? null : null;
+	};
+	for (const method of classFile.methods) {
+		if (!method.code) continue;
+		const shared = newShared(own);
+		let ok;
+		try {
+			ok = new Interpreter(shared).run(method.code, classFile);
+		} catch (err) {
+			notes.push(`${method.name}: ${err.message}`);
+			continue;
+		}
+		if (!ok) notes.push(`${method.name}: ${shared.notes.join("; ")}`);
+		const adopted = new Set(shared.handles.flatMap((handle) => handle.children));
+		const roots = shared.handles.filter((handle) => !adopted.has(handle) && !handle.consumed && (handle.cubes.length > 0 || handle.children.length > 0));
+		if (roots.length === 0) continue;
+		const orphans = roots.filter((root) => root.orphaned).length;
+		const model = {
+			textureSize: shared.textureSize,
+			parts: roots.map((root) => toPart(root)),
+			notes: [
+				...shared.notes,
+				...orphans > 0 ? [`${orphans} disconnected roots: built for a parent in another class, so each sits at the model origin`] : [],
+				...shared.branched ? ["a conditional was taken; the shape is one of the variants this builder makes"] : []
+			]
+		};
+		candidates.push({
+			model,
+			ownMesh: buildsOwnMesh(model),
+			cubes: cubesOf(model)
+		});
+	}
+	const byCubes = candidates.filter((candidate) => candidate.cubes > 0).toSorted((left, right) => right.cubes - left.cubes);
+	const base = byCubes.find((candidate) => candidate.ownMesh) ?? byCubes[0];
+	if (!base) return {
+		textureSize: [64, 32],
+		parts: [],
+		notes
+	};
+	let model = base.model;
+	for (const helper of byCubes) if (helper !== base && !helper.ownMesh) model = mergeModels(model, helper.model);
+	return model;
+}
+//#endregion
+export { extractModel as t };