@ringozz/godot 4.7.1-555 → 4.7.1-562

package/README.md

@@ -97,7 +97,7 @@ function Foo() {
 </Suspense>
 ```
 
-Each extension maps to its Godot class (source assets only — `gltf`/`tscn`/`obj` → `PackedScene`, `jpg`/`jpeg`/`png`/`webp` → `CompressedTexture2D`, `svg` → `Texture2D`, `exr`/`hdr` → `TextureLayered`, `wav` → `AudioStreamWAV`, `ogg` → `AudioStreamOggVorbis`, `mp3` → `AudioStreamMP3`, `tres` → `Resource`, `po` → `Translation`), declared in `src/assets.d.ts`. Imported products (`.scn`/`.ctex`) are never imported directly.
+Each extension maps to its Godot class (source assets only — `gltf`/`tscn`/`obj` → `PackedScene`, `jpg`/`jpeg`/`png`/`webp` → `CompressedTexture2D`, `svg` → `Texture2D`, `exr`/`hdr` → `TextureLayered`, `wav` → `AudioStreamWAV`, `ogg` → `AudioStreamOggVorbis`, `mp3` → `AudioStreamMP3`, `ttf`/`otf` → `FontFile`, `tres` → `Resource`, `po` → `Translation`), declared in `src/assets.d.ts`. Imported products (`.scn`/`.ctex`) are never imported directly.
 
 Textures are shared only through Godot's `ResourceLoader` path cache. The glTF import pipeline may produce per-scene texture instances (same `res://` path, separate objects), so don't assume two scenes referencing the same image share one texture object.
 
@@ -116,7 +116,7 @@ initDebug();
 - `find(pattern?, type?)` returns a JS array of nodes matching a name glob and/or class (`$.find('*', 'RigidBody3D')` lists all physics bodies).
 - `$.tree` is the live `SceneTree`; `$.paused = true` freezes the scene tree for inspection; `$.paused = false` resumes.
 
-`initDebug` also registers an `uncaughtException` handler that keeps the process alive, polyfills `DOMRect` (not defined in Bun, needed by `getBoundingClientRect()`), and adds `getBoundingClientRect()` to `CanvasItem`/`Node3D`.
+`initDebug` also registers an `uncaughtException` handler that keeps the process alive, polyfills `DOMRect` (not defined in Bun, needed by `getBoundingClientRect()`), and adds `getBoundingClientRect()` to `CanvasItem`/`Node3D` (Node3D covers descendant meshes; returns CSS-pixel coordinates).
 
 ## Notes
 

package/gen/classes/DisplayServer.ts

@@ -729,7 +729,7 @@ export class DisplayServer extends GodotVar {
     static screenGetDpi(screen?: number /* = -1 */): number { return _C($(), 10248, screen) as number; }
 
     /**
-     * Returns the scale factor of the specified screen by index. Returns `1.0` if `screen` is invalid.
+     * Returns the scale factor of the specified screen by index. Returns `1.0` if `screen` is invalid. See also {@link screenGetMaxScale}.
      * **Note:** One of the following constants can be used as `screen`: {@link SCREEN_OF_MAIN_WINDOW}, {@link SCREEN_PRIMARY}, {@link SCREEN_WITH_MOUSE_FOCUS}, or {@link SCREEN_WITH_KEYBOARD_FOCUS}.
      * **Note:** On macOS, the returned value is `2.0` for hiDPI (Retina) screens, and `1.0` for all other cases.
      * **Note:** On Linux (Wayland), the returned value is accurate only when `screen` is {@link SCREEN_OF_MAIN_WINDOW}. Due to API limitations, passing a direct index will return a rounded-up integer, if the screen has a fractional scale (e.g. `1.25` would get rounded up to `2.0`).
@@ -743,9 +743,8 @@ export class DisplayServer extends GodotVar {
     static isTouchscreenAvailable(): boolean { return _C($(), 8369) as boolean; }
 
     /**
-     * Returns the greatest scale factor of all screens.
-     * **Note:** On macOS returned value is `2.0` if there is at least one hiDPI (Retina) screen in the system, and `1.0` in all other cases.
-     * **Note:** This method is implemented only on macOS.
+     * Returns the greatest scale factor of all screens. See also {@link screenGetScale}.
+     * **Note:** On macOS, the returned value is `2.0` if there is at least one hiDPI (Retina) screen in the system, and `1.0` in all other cases.
      */
     static screenGetMaxScale(): number { return _C($(), 10253) as number; }
 

package/gen/classes/Light3D.ts

@@ -296,12 +296,14 @@ export const BakeMode = {
      */
     BAKE_DISABLED: 0,
     /**
-     * Light is taken into account in static baking ({@link VoxelGI}, {@link LightmapGI}, SDFGI ({@link Environment.sdfgiEnabled})). The light can be moved around or modified, but its global illumination will not update in real-time. This is suitable for subtle changes (such as flickering torches), but generally not large changes such as toggling a light on and off.
+     * Light is taken into account in static baking ({@link VoxelGI}, {@link LightmapGI}, SDFGI ({@link Environment.sdfgiEnabled})). The light can be moved around or modified, but its global illumination will not update in real-time.
      * **Note:** The light is not baked in {@link LightmapGI} if {@link editorOnly} is `true`.
+     * **Note:** When using {@link LightmapGI}, both the direct and indirect light are baked. Since direct light is baked, the light doesn't display a specular lobe on static lightmapped meshes. Shadows on static lightmapped meshes will also look less detailed, but the light still casts shadows that can be displayed on dynamic objects. Since real-time light computations are skipped on static lightmapped meshes, this bake mode improves runtime performance compared to {@link BAKE_DYNAMIC} and {@link BAKE_DISABLED}.
      */
     BAKE_STATIC: 1,
     /**
-     * Light is taken into account in dynamic baking ({@link VoxelGI} and SDFGI ({@link Environment.sdfgiEnabled}) only). The light can be moved around or modified with global illumination updating in real-time. The light's global illumination appearance will be slightly different compared to {@link BAKE_STATIC}. This has a greater performance cost compared to {@link BAKE_STATIC}. When using SDFGI, the update speed of dynamic lights is affected by {@link ProjectSettings.rendering/globalIllumination/sdfgi/framesToUpdateLights}.
+     * Light is taken into account in dynamic baking ({@link VoxelGI} and SDFGI ({@link Environment.sdfgiEnabled})). The light can be moved around or modified with global illumination updating in real-time. The light's global illumination appearance will be slightly different compared to {@link BAKE_STATIC}. This has a greater performance cost compared to {@link BAKE_STATIC}. When using SDFGI, the update speed of dynamic lights is affected by {@link ProjectSettings.rendering/globalIllumination/sdfgi/framesToUpdateLights}.
+     * **Note:** When using {@link LightmapGI}, the light's indirect light is baked, but direct light and shadows remain real-time. This mode allows performing *subtle* changes to a light's color, energy, and position while still looking fairly correct. For example, you can use this to create flickering static torches that have their indirect light baked.
      */
     BAKE_DYNAMIC: 2,
 } as const;

package/gen/classes/RandomNumberGenerator.ts

@@ -48,9 +48,9 @@ export class RandomNumberGenerator extends RefCounted {
     randiRange(from: number, to: number): number { return _C(this, 9725, from, to) as number; }
 
     /**
-     * Returns a random integer between `0` and the size of the array that is passed as a parameter. Each value in the array should be a floating-point number that represents the relative likelihood that it will be returned as an index. A higher value means the value is more likely to be returned as an index, while a value of `0` means it will never be returned as an index.
+     * Returns a random integer between `0` and the size of the array that is passed as a parameter. Each value in the array should be a non-negative floating-point number that represents the relative likelihood that it will be returned as an index. A higher value means the value is more likely to be returned as an index, while a value of `0` means it will never be returned as an index.
      * For example, if {@link code skip-lint}{@link 0.5, 1, 1, 2} is passed as a parameter, then the method is twice as likely to return `3` (the index of the value `2`) and twice as unlikely to return `0` (the index of the value `0.5`) compared to the indices `1` and `2`.
-     * Prints an error and returns `-1` if the array is empty.
+     * Prints an error and returns `-1` if the array is empty or contains any negative values.
      *
      *
      * ```gdscript

package/gen/heap-types/GodotArray.ts

@@ -6,7 +6,10 @@ import type { Callable, StringName, Variant } from './index.ts';
 
 /** Godot's Array type — lazy, indexed container. */
 export class GodotArray<T = any> extends GodotVar implements Iterable<T> {
-    constructor(...args: any[]) { super(28, ...args); }
+    constructor(from?: Iterable<T>) {
+        super(28);
+        if (from != null) for (const x of from) _C(this, 9630, x);
+    }
 
     get length(): number { return _C(this, 13608) as number; }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ringozz/godot",
   "author": "Vladimir Davidovich",
-  "version": "4.7.1-555",
+  "version": "4.7.1-562",
   "description": "Node-API bindings for Godot Engine — call Godot classes from JavaScript",
   "publishConfig": {
     "access": "public"
@@ -32,16 +32,16 @@
   "godot": {
     "version_major": 4,
     "version_minor": 7,
-    "version_patch": 1,
+    "version_patch": 2,
     "version_status": "stable",
     "version_build": "official",
-    "version_full_name": "Godot Engine v4.7.1.stable.official",
+    "version_full_name": "Godot Engine v4.7.2.stable.official",
     "precision": "single"
   },
   "optionalDependencies": {
-    "@ringozz/godot-macos-arm64": "^4.7.1-555",
-    "@ringozz/godot-windows-x86_64": "^4.7.1-555",
-    "@ringozz/godot-web-wasm32": "^4.7.1-555"
+    "@ringozz/godot-macos-arm64": "^4.7.1-562",
+    "@ringozz/godot-windows-x86_64": "^4.7.1-562",
+    "@ringozz/godot-web-wasm32": "^4.7.1-562"
   },
   "peerDependencies": {
     "@types/bun": "*"

package/src/assets.d.ts

@@ -101,6 +101,20 @@ declare module '*.wav' {
 	export const materialize: Promise<unknown>;
 }
 
+declare module '*.ttf' {
+	import type { FontFile } from '@ringozz/godot/FontFile';
+	const asset: Promise<FontFile>;
+	export default asset;
+	export const materialize: Promise<unknown>;
+}
+
+declare module '*.otf' {
+	import type { FontFile } from '@ringozz/godot/FontFile';
+	const asset: Promise<FontFile>;
+	export default asset;
+	export const materialize: Promise<unknown>;
+}
+
 declare module '*.ogg' {
 	import type { AudioStreamOggVorbis } from '@ringozz/godot/AudioStreamOggVorbis';
 	const asset: Promise<AudioStreamOggVorbis>;

package/src/debug.ts

@@ -14,10 +14,16 @@ import { Node3D } from '../gen/classes/Node3D.ts';
 import { OS } from '../gen/classes/OS.ts';
 import { SceneTree } from '../gen/classes/SceneTree.ts';
 import { Time } from '../gen/classes/Time.ts';
+import type { Viewport } from '../gen/classes/Viewport.ts';
 import type { Window } from '../gen/classes/Window.ts';
 
 const tree = Engine.getMainLoop() as SceneTree;
 
+/** Does a snapshot line match a string (case-insensitive substring) or `RegExp` pattern? */
+function matches(pattern: string | RegExp | undefined, line: string): boolean {
+    return !pattern || (pattern instanceof RegExp ? pattern.test(line) : line.toLowerCase().includes(pattern.toLowerCase()));
+}
+
 /**
  * Dump a Godot value or object as a string.
  * Value types (vectors, arrays, dictionaries, …) render via Godot's `str()`.
@@ -57,8 +63,7 @@ export function snapshot(pattern?: string | RegExp, node?: Node, depth = 99): st
         if (d <= 0) return;
         const count = n.getChildCount();
         const line = `${ind}${n.getClass()} "${n.name}" (${count} children)`;
-        const keep = !pattern || (pattern instanceof RegExp ? pattern.test(line) : line.toLowerCase().includes(pattern.toLowerCase()));
-        if (keep) lines.push(line);
+        if (matches(pattern, line)) lines.push(line);
         for (let i = 0; i < count; i++) {
             const c = n.getChild(i);
             if (c) walk(c as Node, d - 1, ind + '  ');
@@ -102,7 +107,7 @@ export function click(path: string): string | null {
     const node = resolveNode(path, root);
     if (!(node instanceof Control)) return null;
     const rect = node.getGlobalRect();
-    const scale = root!.contentScaleFactor;
+    const scale = root.contentScaleFactor;
     const position = new Vector2(
         (rect.position.x + rect.size.x / 2) * scale,
         (rect.position.y + rect.size.y / 2) * scale,
@@ -113,7 +118,7 @@ export function click(path: string): string | null {
         event.globalPosition = position;
         event.buttonIndex = MouseButton.MOUSE_BUTTON_LEFT;
         event.pressed = down;
-        root!.pushInput(event);
+        root.pushInput(event);
     };
     press(true);
     setTimeout(() => press(false), 50);
@@ -176,6 +181,150 @@ function ensureDOMRect(): void {
     };
 }
 
+type Push = (x: number, y: number) => void;
+type BoundsCollect = (node: any, push: Push, viewport: Viewport) => void;
+
+/** Affine 2D point mapper from a transform's basis/origin, optionally scaled. */
+function makeAffine(t: any, scale = 1): (x: number, y: number) => [number, number] {
+    const tox = t.origin.x, toy = t.origin.y;
+    const txx = t.x.x, txy = t.x.y;
+    const tyx = t.y.x, tyy = t.y.y;
+    return (x, y) => [(tox + txx * x + tyx * y) * scale, (toy + txy * x + tyy * y) * scale];
+}
+
+/**
+ * Axis-aligned 2D bounds accumulator in CSS pixels. Non-finite points (e.g.
+ * geometry behind the camera) are dropped; `rect()` is `null` when no point
+ * was added.
+ */
+function cssBounds(): { add(x: number, y: number): void; rect(): [number, number, number, number] | null } {
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    let found = false;
+    return {
+        add(x, y) {
+            if (!Number.isFinite(x) || !Number.isFinite(y)) return;
+            if (x < minX) minX = x; if (y < minY) minY = y;
+            if (x > maxX) maxX = x; if (y > maxY) maxY = y;
+            found = true;
+        },
+        rect() {
+            return found ? [minX, minY, maxX - minX, maxY - minY] : null;
+        },
+    };
+}
+
+/** World-space AABB (min, max) of a local AABB under its global transform, or `null` when degenerate. */
+function worldAabb(aabb: any, gt: any): [number, number, number, number, number, number] | null {
+    if (aabb.size.x === 0 && aabb.size.y === 0 && aabb.size.z === 0) return null;
+    const bx = gt.basis.x, by = gt.basis.y, bz = gt.basis.z;
+    const cx = aabb.position.x + aabb.size.x / 2;
+    const cy = aabb.position.y + aabb.size.y / 2;
+    const cz = aabb.position.z + aabb.size.z / 2;
+    const ex = Math.hypot(bx.x, bx.y, bx.z) * aabb.size.x / 2;
+    const ey = Math.hypot(by.x, by.y, by.z) * aabb.size.y / 2;
+    const ez = Math.hypot(bz.x, bz.y, bz.z) * aabb.size.z / 2;
+    const ox = gt.origin.x, oy = gt.origin.y, oz = gt.origin.z;
+    const wx = ox + bx.x * cx + by.x * cy + bz.x * cz;
+    const wy = oy + bx.y * cx + by.y * cy + bz.y * cz;
+    const wz = oz + bx.z * cx + by.z * cy + bz.z * cz;
+    return [wx - ex, wy - ey, wz - ez, wx + ex, wy + ey, wz + ez];
+}
+
+/**
+ * World-space AABB of a node's visual content: the union of its own AABB (when
+ * it is a `VisualInstance3D`) and every descendant `VisualInstance3D`'s, each in
+ * its own global transform — mirrors the editor's `_calculate_spatial_bounds`.
+ * Returns `null` when there is no non-degenerate visual.
+ */
+function worldBounds(node: Node3D): [number, number, number, number, number, number] | null {
+    let minX = Infinity, minY = Infinity, minZ = Infinity;
+    let maxX = -Infinity, maxY = -Infinity, maxZ = -Infinity;
+    const add = (aabb: any, gt: any) => {
+        const box = worldAabb(aabb, gt);
+        if (!box) return;
+        if (box[0] < minX) minX = box[0]; if (box[3] > maxX) maxX = box[3];
+        if (box[1] < minY) minY = box[1]; if (box[4] > maxY) maxY = box[4];
+        if (box[2] < minZ) minZ = box[2]; if (box[5] > maxZ) maxZ = box[5];
+    };
+    if (typeof (node as any).getAabb === 'function') {
+        add((node as any).getAabb(), node.globalTransform);
+    }
+    for (const child of node.findChildren('*', 'VisualInstance3D', true, false) as unknown as any[]) {
+        if (child && typeof child.getAabb === 'function') {
+            add(child.getAabb(), child.globalTransform);
+        }
+    }
+    return minX === Infinity ? null : [minX, minY, minZ, maxX, maxY, maxZ];
+}
+
+/**
+ * Compute a node's bounding rect in CSS pixels. The callback pushes points in
+ * viewport logical units; they're mapped through the viewport's screen transform
+ * (content scale, stretch, SubViewport/child-window placement), then divided by
+ * screenGetScale to reach CSS pixels. Never throws: React DevTools calls this on
+ * every commit and must not see a throw (e.g. a wrapper freed by an unmount).
+ */
+function boundsForViewport(node: Node, collect: (push: Push, viewport: Viewport) => void): DOMRect | null {
+    try {
+        const viewport = node.getViewport();
+        if (!viewport) return null;
+        const xform = makeAffine(viewport.getScreenTransform(), 1 / DisplayServer.screenGetScale());
+        const bounds = cssBounds();
+        collect((x, y) => bounds.add(...xform(x, y)), viewport);
+        const r = bounds.rect();
+        return r ? new DOMRect(r[0], r[1], r[2], r[3]) : null;
+    } catch {
+        return null;
+    }
+}
+
+/** Install `getBoundingClientRect` on a node prototype. */
+function defineBoundingClientRect(proto: object, collect: BoundsCollect): void {
+    Object.defineProperty(proto, 'getBoundingClientRect', {
+        configurable: true,
+        value(this: Node): DOMRect | null {
+            return boundsForViewport(this, (push, viewport) => collect(this, push, viewport));
+        },
+    });
+}
+
+/** Push the four corners of an axis-aligned rect through `emit`. */
+function pushRect(emit: (x: number, y: number) => void, x0: number, y0: number, x1: number, y1: number): void {
+    for (const px of [x0, x1]) {
+        for (const py of [y0, y1]) {
+            emit(px, py);
+        }
+    }
+}
+
+const canvasItemBounds: BoundsCollect = (node, push) => {
+    if (node instanceof Control) {
+        const rc = node.getGlobalRect();
+        pushRect(push, rc.position.x, rc.position.y, rc.position.x + rc.size.x, rc.position.y + rc.size.y);
+        return;
+    }
+    if (typeof node.getRect !== 'function') return;
+    const rect = node.getRect() as Rect2;
+    const xform = makeAffine(node.getScreenTransform());
+    pushRect((px, py) => push(...xform(px, py)), rect.position.x, rect.position.y, rect.position.x + rect.size.x, rect.position.y + rect.size.y);
+};
+
+const node3dBounds: BoundsCollect = (node, push, viewport) => {
+    const camera = viewport.getCamera3d();
+    if (!camera) return;
+    const box = worldBounds(node);
+    if (!box) return;
+    const [minX, minY, minZ, maxX, maxY, maxZ] = box;
+    for (let i = 0; i < 8; i++) {
+        const s = camera.unprojectPosition(new Vector3(
+            i & 1 ? maxX : minX,
+            i & 2 ? maxY : minY,
+            i & 4 ? maxZ : minZ,
+        ));
+        push(s.x, s.y);
+    }
+};
+
 /**
  * Bootstrap the debugging environment.
  *
@@ -192,101 +341,8 @@ export function initDebug(): void {
     });
 
     ensureDOMRect();
-
-    Object.defineProperty(CanvasItem.prototype, 'getBoundingClientRect', {
-        configurable: true,
-        value(this: CanvasItem): DOMRect | null {
-            const scale = DisplayServer.screenGetScale();
-            if (this instanceof Control) {
-                const rc = (this as Control).getGlobalRect();
-                return new DOMRect(
-                    rc.position.x / scale, rc.position.y / scale,
-                    rc.size.x / scale, rc.size.y / scale,
-                );
-            }
-
-            if (typeof (this as any).getRect !== 'function') return null;
-
-            const rect = (this as any).getRect() as Rect2;
-            const t = this.getScreenTransform();
-
-            const pos = rect.position;
-            const sz = rect.size;
-            const tx = t.x;
-            const ty = t.y;
-            const to = t.origin;
-
-            const x0 = pos.x, y0 = pos.y;
-            const x1 = x0 + sz.x, y1 = y0 + sz.y;
-            const txx = tx.x, txy = tx.y;
-            const tyx = ty.x, tyy = ty.y;
-            const tox = to.x, toy = to.y;
-
-            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-            const accum = (px: number, py: number) => {
-                if (px < minX) minX = px; if (py < minY) minY = py;
-                if (px > maxX) maxX = px; if (py > maxY) maxY = py;
-            };
-
-            accum(txx * x0 + tyx * y0 + tox, txy * x0 + tyy * y0 + toy);
-            accum(txx * x1 + tyx * y0 + tox, txy * x1 + tyy * y0 + toy);
-            accum(txx * x0 + tyx * y1 + tox, txy * x0 + tyy * y1 + toy);
-            accum(txx * x1 + tyx * y1 + tox, txy * x1 + tyy * y1 + toy);
-
-            return new DOMRect(
-                minX / scale, minY / scale,
-                (maxX - minX) / scale, (maxY - minY) / scale,
-            );
-        },
-    });
-
-    Object.defineProperty(Node3D.prototype, 'getBoundingClientRect', {
-        configurable: true,
-        value(this: Node3D): DOMRect | null {
-            if (typeof (this as any).getAabb !== 'function') return null;
-
-            const aabb = (this as any).getAabb();
-            const gt = this.globalTransform;
-            const viewport = this.getViewport();
-            if (!viewport) return null;
-            const camera = viewport.getCamera3d();
-            if (!camera) return null;
-            const scale = DisplayServer.screenGetScale();
-
-            const b = gt.basis;
-            const bx = b.x, by = b.y, bz = b.z;
-            const o = gt.origin;
-            const p = aabb.position, e = aabb.end;
-
-            const [px, py, pz] = [p.x, p.y, p.z];
-            const [ex, ey, ez] = [e.x, e.y, e.z];
-            const [bxx, bxy, bxz] = [bx.x, bx.y, bx.z];
-            const [byx, byy, byz] = [by.x, by.y, by.z];
-            const [bzx, bzy, bzz] = [bz.x, bz.y, bz.z];
-            const [ox, oy, oz] = [o.x, o.y, o.z];
-
-            const corners = [
-                [px, py, pz], [ex, py, pz], [px, ey, pz], [ex, ey, pz],
-                [px, py, ez], [ex, py, ez], [px, ey, ez], [ex, ey, ez],
-            ];
-
-            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
-
-            for (const [cx, cy, cz] of corners) {
-                const wx = bxx * cx + byx * cy + bzx * cz + ox;
-                const wy = bxy * cx + byy * cy + bzy * cz + oy;
-                const wz = bxz * cx + byz * cy + bzz * cz + oz;
-                const s = camera.unprojectPosition(new Vector3(wx, wy, wz));
-                if (s.x < minX) minX = s.x; if (s.y < minY) minY = s.y;
-                if (s.x > maxX) maxX = s.x; if (s.y > maxY) maxY = s.y;
-            }
-
-            return new DOMRect(
-                minX / scale, minY / scale,
-                (maxX - minX) / scale, (maxY - minY) / scale,
-            );
-        },
-    });
+    defineBoundingClientRect(CanvasItem.prototype, canvasItemBounds);
+    defineBoundingClientRect(Node3D.prototype, node3dBounds);
 
     (globalThis as any).$ = {
         Engine, OS, ClassDB, Time,

package/src/preload.ts

@@ -44,6 +44,8 @@ const FORMATS: Record<string, { cls?: string; scan?: boolean; native?: boolean }
 	mp3: { cls: 'AudioStreamMP3' },
 	tres: { cls: 'Resource', scan: true, native: true },
 	po: { cls: 'Translation', native: true },
+	ttf: { cls: 'FontFile' },
+	otf: { cls: 'FontFile' },
 	mtl: { scan: true },
 };