@headless-three/renderer 0.1.10 → 0.3.0

package/dist/loaders.js

@@ -1,858 +1,25 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncodedImageTextureLoader = void 0;
-exports.createEncodedImageTextureLoader = createEncodedImageTextureLoader;
-exports.createNodeGltfLoader = createNodeGltfLoader;
-exports.loadGltfFromFile = loadGltfFromFile;
-exports.loadVrmFromFile = loadVrmFromFile;
-exports.loadVrmAnimationFromFile = loadVrmAnimationFromFile;
-exports.applyVrmAnimation = applyVrmAnimation;
-exports.resolveLocalAssetPath = resolveLocalAssetPath;
-exports.installLocalFileFetch = installLocalFileFetch;
-const promises_1 = require("node:fs/promises");
-const node_path_1 = __importDefault(require("node:path"));
-const node_url_1 = require("node:url");
-// eslint-disable-next-line @typescript-eslint/no-var-requires
-const { AnimationMixer, ColorKeyframeTrack, InterpolateDiscrete, InterpolateLinear, LoadingManager, Texture } = require('three');
-class EncodedImageTextureLoader {
-    constructor(rootDir = process.cwd(), manager) {
-        this.loaderPath = '';
-        this.rootDir = resolveLocalRootDir(rootDir, 'rootDir');
-        this.manager = optionalLoadingManager(manager, 'manager');
-    }
-    setCrossOrigin() {
-        return this;
-    }
-    setRequestHeader() {
-        return this;
-    }
-    setWithCredentials() {
-        return this;
-    }
-    setPath(loaderPath) {
-        this.loaderPath = validatedTextureLoaderPath(loaderPath, 'loaderPath');
-        return this;
-    }
-    load(url, onLoad, _onProgress, onError) {
-        const texture = new Texture();
-        const requestedUrl = requiredString(url, 'url');
-        const loadCallback = optionalFunction(onLoad, 'onLoad');
-        const errorCallback = optionalFunction(onError, 'onError');
-        const source = resolveLoadingManagerUrl(this.manager, resolveTextureLoaderSource(requestedUrl, this.loaderPath));
-        const encodedDataUri = encodedImageDataUriBuffer(source);
-        const data = encodedDataUri
-            ? Promise.resolve(encodedDataUri)
-            : /^blob:/i.test(source)
-                ? readBlobUrlBuffer(source)
-                : (0, promises_1.readFile)(resolveLocalAssetPath(source, this.rootDir));
-        this.manager?.itemStart?.(source);
-        data.then((buffer) => {
-            texture.image = buffer;
-            texture.source.data = buffer;
-            texture.needsUpdate = true;
-            try {
-                loadCallback?.(texture);
-            }
-            finally {
-                this.manager?.itemEnd?.(source);
-            }
-        }, (error) => {
-            this.manager?.itemError?.(source);
-            this.manager?.itemEnd?.(source);
-            errorCallback?.(error);
-        });
-        return texture;
-    }
-    loadAsync(url, onProgress) {
-        return new Promise((resolve, reject) => {
-            try {
-                this.load(url, resolve, onProgress, reject);
-            }
-            catch (error) {
-                reject(error);
-            }
-        });
-    }
-}
-exports.EncodedImageTextureLoader = EncodedImageTextureLoader;
-function createEncodedImageTextureLoader(rootDir, manager) {
-    return new EncodedImageTextureLoader(rootDir, manager);
-}
-async function createNodeGltfLoader(rootDir = process.cwd(), options = {}) {
-    const loaderOptions = objectOptions(options, 'options');
-    const root = resolveLocalRootDir(rootDir, 'rootDir');
-    const { configureLoader, installFetch, manager, registerTextureHandlers, } = validateNodeGltfLoaderOptions(loaderOptions);
-    const loadingManager = manager ?? new LoadingManager();
-    if (installFetch !== false) {
-        installLocalFileFetch();
-    }
-    installEncodedImageSupportProbe();
-    const encodedImages = createEncodedImageTextureLoader(root, loadingManager);
-    if (registerTextureHandlers !== false) {
-        registerEncodedImageHandlers(loadingManager, encodedImages);
-    }
-    const { GLTFLoader } = await importGltfLoader();
-    const loader = new GLTFLoader(loadingManager);
-    loader.setPath?.((0, node_url_1.pathToFileURL)(`${root}${node_path_1.default.sep}`).href);
-    await configureLoader?.(loader);
-    installAnimationPointerExtension(loader);
-    installNodeVisibilityExtension(loader);
-    installEmbeddedGlbImageNormalizer(loader);
-    return { encodedImages, loader, manager: loadingManager, rootDir: root };
-}
-async function loadGltfFromFile(filePath, options = {}) {
-    const loaderOptions = objectOptions(options, 'options');
-    validateLoadGltfFromFileOptions(loaderOptions);
-    const absolute = resolveLocalAssetPath(requiredString(filePath, 'filePath'));
-    const rootDirOption = optionalString(loaderOptions.rootDir, 'options.rootDir');
-    const root = rootDirOption == null ? node_path_1.default.dirname(absolute) : resolveLocalRootDir(rootDirOption, 'options.rootDir');
-    const baseUrl = optionalString(loaderOptions.baseUrl, 'options.baseUrl') ?? (0, node_url_1.pathToFileURL)(`${root}${node_path_1.default.sep}`).href;
-    const { loader } = await createNodeGltfLoader(root, loaderOptions);
-    const bytes = await (0, promises_1.readFile)(absolute);
-    return await new Promise((resolve, reject) => {
-        loader.parse(arrayBufferView(bytes), baseUrl, (gltf) => resolve(gltf), reject);
-    });
-}
-async function loadVrmFromFile(filePath, options = {}) {
-    const loaderOptions = objectOptions(options, 'options');
-    validateLoadGltfFromFileOptions(loaderOptions);
-    const validatedFilePath = requiredString(filePath, 'filePath');
-    const { VRMLoaderPlugin, configureLoader, ...gltfOptions } = loaderOptions;
-    const configureLoaderCallback = optionalFunction(configureLoader, 'options.configureLoader');
-    const VrmPlugin = optionalFunction(VRMLoaderPlugin, 'options.VRMLoaderPlugin') ?? await importVrmLoaderPlugin();
-    return await loadGltfFromFile(validatedFilePath, {
-        ...gltfOptions,
-        configureLoader: async (loader) => {
-            registerLoaderPlugin(loader, (parser) => new VrmPlugin(parser), 'VRMLoaderPlugin');
-            await configureLoaderCallback?.(loader);
-        },
-    });
-}
-async function loadVrmAnimationFromFile(filePath, options = {}) {
-    const loaderOptions = objectOptions(options, 'options');
-    validateLoadGltfFromFileOptions(loaderOptions);
-    const validatedFilePath = requiredString(filePath, 'filePath');
-    const { VRMAnimationLoaderPlugin, VRMLoaderPlugin, configureLoader, ...gltfOptions } = loaderOptions;
-    const VrmPlugin = optionalFunction(VRMLoaderPlugin, 'options.VRMLoaderPlugin');
-    const configureLoaderCallback = optionalFunction(configureLoader, 'options.configureLoader');
-    const AnimationPlugin = optionalFunction(VRMAnimationLoaderPlugin, 'options.VRMAnimationLoaderPlugin') ?? await importVrmAnimationLoaderPlugin();
-    return await loadGltfFromFile(validatedFilePath, {
-        ...gltfOptions,
-        configureLoader: async (loader) => {
-            if (VrmPlugin) {
-                registerLoaderPlugin(loader, (parser) => new VrmPlugin(parser), 'VRMLoaderPlugin');
-            }
-            registerLoaderPlugin(loader, (parser) => new AnimationPlugin(parser), 'VRMAnimationLoaderPlugin');
-            await configureLoaderCallback?.(loader);
-        },
-    });
-}
-async function applyVrmAnimation(vrm, vrmAnimation, options = {}) {
-    const helperOptions = objectOptions(options, 'options');
-    const model = resolveVrmModelInput(vrm);
-    const animationIndex = optionalNonNegativeInteger(helperOptions.animationIndex, 'options.animationIndex') ?? 0;
-    const animation = resolveVrmAnimationInput(vrmAnimation, animationIndex);
-    const time = optionalNonNegativeNumber(helperOptions.time, 'options.time') ?? 0;
-    const updateDelta = optionalNonNegativeNumber(helperOptions.updateDelta, 'options.updateDelta') ?? 0;
-    const updateVrm = optionalBoolean(helperOptions.updateVrm, 'options.updateVrm') ?? true;
-    const createClip = optionalFunction(helperOptions.createVRMAnimationClip, 'options.createVRMAnimationClip')
-        ?? await importVrmAnimationClipFactory();
-    const Mixer = optionalFunction(helperOptions.AnimationMixer, 'options.AnimationMixer') ?? AnimationMixer;
-    const clip = createClip(animation, model);
-    const mixer = new Mixer(model.scene);
-    if (typeof mixer.clipAction !== 'function') {
-        throw new TypeError('AnimationMixer must provide a clipAction() function.');
-    }
-    const action = mixer.clipAction(clip);
-    if (!action || typeof action.play !== 'function') {
-        throw new TypeError('AnimationMixer.clipAction() must return an action with play().');
-    }
-    action.play();
-    if (typeof mixer.setTime === 'function') {
-        mixer.setTime(time);
-    }
-    else if (typeof mixer.update === 'function') {
-        mixer.update(time);
-    }
-    else {
-        throw new TypeError('AnimationMixer must provide setTime() or update().');
-    }
-    if (updateVrm && model.update != null) {
-        if (typeof model.update !== 'function') {
-            throw new TypeError('vrm.update must be a function when provided.');
-        }
-        model.update(updateDelta);
-    }
-    return { action, clip, mixer };
-}
-function resolveVrmModelInput(vrm) {
-    const input = objectOptions(vrm, 'vrm');
-    const userData = input.userData;
-    const wrapped = userData != null
-        && typeof userData === 'object'
-        && !Array.isArray(userData)
-        && 'vrm' in userData;
-    const label = wrapped ? 'vrm.userData.vrm' : 'vrm';
-    const model = objectOptions(wrapped ? userData.vrm : vrm, label);
-    if (model.scene == null || typeof model.scene !== 'object' || Array.isArray(model.scene)) {
-        throw new TypeError(`${label}.scene must be an object.`);
-    }
-    return model;
-}
-function resolveVrmAnimationInput(vrmAnimation, animationIndex = 0) {
-    const input = objectOptions(vrmAnimation, 'vrmAnimation');
-    const userData = input.userData;
-    if (userData == null || typeof userData !== 'object' || Array.isArray(userData) || !('vrmAnimations' in userData)) {
-        return vrmAnimation;
-    }
-    const animations = userData.vrmAnimations;
-    if (!Array.isArray(animations)) {
-        throw new TypeError('vrmAnimation.userData.vrmAnimations must be an array.');
-    }
-    objectOptions(animations[animationIndex], `vrmAnimation.userData.vrmAnimations[${animationIndex}]`);
-    return animations[animationIndex];
-}
-function encodedImageDataUriBuffer(url) {
-    if (!/^data:/i.test(url))
-        return null;
-    const comma = url.indexOf(',');
-    if (comma < 0) {
-        throw new Error('Data URI texture is missing a comma separator.');
-    }
-    const metadata = url.slice(5, comma).toLowerCase();
-    if (!/^image\/(?:png|jpe?g|webp)(?:;|$)/.test(metadata)) {
-        throw new Error('Data URI texture is not a supported encoded image. Use PNG, JPEG, or WebP data URIs.');
-    }
-    const payload = url.slice(comma + 1);
-    if (/(?:^|;)base64(?:;|$)/.test(metadata)) {
-        return Buffer.from(payload, 'base64');
-    }
-    return Buffer.from(decodeURIComponent(payload), 'utf8');
-}
-async function readBlobUrlBuffer(url) {
-    if (typeof fetch !== 'function') {
-        throw new Error('Blob URL textures require global fetch support. Install a fetch polyfill or rewrite embedded images as files/data URIs before loading.');
-    }
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw new Error(`Blob URL texture fetch failed with status ${response.status}.`);
-    }
-    const contentType = response.headers.get('content-type')?.split(';', 1)[0].trim().toLowerCase();
-    if (contentType && !/^image\/(?:png|jpe?g|webp)$/.test(contentType)) {
-        throw new Error(`Blob URL texture has unsupported content type "${contentType}". Use PNG, JPEG, or WebP embedded images.`);
-    }
-    return Buffer.from(await response.arrayBuffer());
-}
-function resolveTextureLoaderSource(url, loaderPath) {
-    if (!loaderPath || isAbsoluteOrSpecialAssetUrl(url))
-        return url;
-    if (node_path_1.default.isAbsolute(loaderPath))
-        return node_path_1.default.join(loaderPath, url);
-    if (node_path_1.default.win32.isAbsolute(loaderPath))
-        return node_path_1.default.win32.join(loaderPath, url);
-    if (/^[a-z][a-z0-9+.-]*:/i.test(loaderPath)) {
-        return new URL(url, ensureDirectoryUrl(loaderPath)).href;
-    }
-    return node_path_1.default.join(loaderPath, url);
-}
-function validatedTextureLoaderPath(loaderPath, label) {
-    const value = requiredString(loaderPath, label);
-    if (!value || node_path_1.default.isAbsolute(value) || node_path_1.default.win32.isAbsolute(value) || /^file:/i.test(value))
-        return value;
-    if (/^[a-z][a-z0-9+.-]*:/i.test(value)) {
-        throw new Error(`${label} is not a local directory path: ${value}`);
-    }
-    return value;
-}
-function resolveLoadingManagerUrl(manager, url) {
-    const resolveURL = manager?.resolveURL;
-    if (resolveURL == null)
-        return url;
-    const resolved = resolveURL.call(manager, url);
-    return requiredString(resolved, 'manager.resolveURL return value');
-}
-function isAbsoluteOrSpecialAssetUrl(url) {
-    return /^data:/i.test(url)
-        || /^blob:/i.test(url)
-        || node_path_1.default.isAbsolute(url)
-        || node_path_1.default.win32.isAbsolute(url)
-        || /^file:/i.test(url)
-        || /^[a-z][a-z0-9+.-]*:/i.test(url);
-}
-function ensureDirectoryUrl(url) {
-    return url.endsWith('/') ? url : `${url}/`;
-}
-function resolveLocalAssetPath(url, rootDir = process.cwd()) {
-    const assetUrl = requiredString(url, 'url');
-    requiredString(rootDir, 'rootDir');
-    if (/^data:/i.test(assetUrl)) {
-        throw new Error('Data URI textures should be decoded or written to files before loading in Node.');
-    }
-    if (node_path_1.default.isAbsolute(assetUrl) || node_path_1.default.win32.isAbsolute(assetUrl))
-        return node_path_1.default.normalize(assetUrl);
-    if (/^file:/i.test(assetUrl))
-        return (0, node_url_1.fileURLToPath)(assetUrl);
-    if (/^[a-z][a-z0-9+.-]*:/i.test(assetUrl)) {
-        throw new Error(`Remote texture URL is not a local file: ${assetUrl}`);
-    }
-    const root = resolveLocalRootDir(rootDir, 'rootDir');
-    return node_path_1.default.resolve(root, assetUrl);
-}
-function resolveLocalRootDir(rootDir, label) {
-    const value = requiredString(rootDir, label);
-    if (/^data:/i.test(value)) {
-        throw new Error(`${label} must be a local directory path, not a data URI.`);
-    }
-    if (node_path_1.default.isAbsolute(value) || node_path_1.default.win32.isAbsolute(value)) {
-        return node_path_1.default.normalize(value);
-    }
-    if (/^file:/i.test(value)) {
-        return (0, node_url_1.fileURLToPath)(value);
-    }
-    if (/^[a-z][a-z0-9+.-]*:/i.test(value)) {
-        throw new Error(`${label} is not a local directory path: ${value}`);
-    }
-    return node_path_1.default.resolve(value);
-}
-function installLocalFileFetch() {
-    const marker = Symbol.for('headless-three-renderer.local-file-fetch');
-    const globalScope = globalThis;
-    if (typeof globalScope.self === 'undefined') {
-        globalScope.self = globalScope;
-    }
-    if (globalScope[marker])
-        return;
-    if (typeof globalScope.ProgressEvent === 'undefined') {
-        const EventCtor = typeof globalScope.Event === 'function'
-            ? globalScope.Event
-            : class Event {
-                constructor(type) {
-                    this.type = type;
-                }
-            };
-        globalScope.ProgressEvent = class ProgressEvent extends EventCtor {
-            constructor(type, init = {}) {
-                super(type);
-                this.lengthComputable = init.lengthComputable ?? false;
-                this.loaded = init.loaded ?? 0;
-                this.total = init.total ?? 0;
-            }
-        };
-    }
-    const nativeFetch = globalScope.fetch;
-    globalScope.fetch = async (input, init) => {
-        const url = typeof input === 'string' || input instanceof URL ? String(input) : input?.url;
-        if (typeof url === 'string' && url.startsWith('file:')) {
-            const buffer = await (0, promises_1.readFile)((0, node_url_1.fileURLToPath)(url));
-            const ResponseCtor = globalScope.Response;
-            if (typeof ResponseCtor !== 'function') {
-                throw new Error('global Response is not available; install a fetch polyfill before loading local files.');
-            }
-            return new ResponseCtor(buffer);
-        }
-        if (typeof nativeFetch !== 'function') {
-            throw new Error('global fetch is not available; install a fetch polyfill before loading remote assets.');
-        }
-        return nativeFetch(input, init);
-    };
-    globalScope[marker] = true;
-}
-function installEncodedImageSupportProbe() {
-    const globalScope = globalThis;
-    if (typeof globalScope.Image === 'function')
-        return;
-    const marker = Symbol.for('headless-three-renderer.encoded-image-probe');
-    if (globalScope[marker])
-        return;
-    globalScope.Image = class EncodedImageProbe {
-        constructor() {
-            this.height = 0;
-            this.onerror = null;
-            this.onload = null;
-            this.width = 0;
-        }
-        set src(value) {
-            const url = String(value ?? '');
-            const supported = /^data:image\/webp[;,]/i.test(url);
-            this.width = supported ? 1 : 0;
-            this.height = supported ? 1 : 0;
-            queueMicrotask(() => {
-                if (supported) {
-                    this.onload?.();
-                }
-                else {
-                    this.onerror?.();
-                }
-            });
-        }
-    };
-    globalScope[marker] = true;
-}
-function registerEncodedImageHandlers(manager, encodedImages) {
-    manager.addHandler(/^blob:/i, encodedImages);
-    manager.addHandler(/^data:image\/(?:png|jpe?g|webp)/i, encodedImages);
-    manager.addHandler(/\.(png|jpe?g|webp)$/i, encodedImages);
-}
-function arrayBufferView(buffer) {
-    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-}
-function installEmbeddedGlbImageNormalizer(loader) {
-    const originalParse = loader.parse.bind(loader);
-    loader.parse = (data, parsePath, onLoad, onError) => {
-        originalParse(normalizeEmbeddedGlbImages(data), parsePath, onLoad, onError);
-    };
-}
-function installNodeVisibilityExtension(loader) {
-    registerLoaderPlugin(loader, (parser) => ({
-        name: 'KHR_node_visibility',
-        afterRoot(gltf) {
-            applyNodeVisibilityExtension(gltf, parser);
-        },
-    }), 'KHR_node_visibility');
-}
-function installAnimationPointerExtension(loader) {
-    registerLoaderPlugin(loader, (parser) => ({
-        name: 'KHR_animation_pointer',
-        afterRoot(gltf) {
-            return applyAnimationPointerExtension(gltf, parser);
-        },
-    }), 'KHR_animation_pointer');
-}
-async function applyAnimationPointerExtension(gltf, parser) {
-    const animationDefs = parser.json?.animations;
-    const clips = gltf.animations;
-    if (!Array.isArray(animationDefs) || !Array.isArray(clips) || typeof parser.getDependency !== 'function')
-        return;
-    for (let animationIndex = 0; animationIndex < animationDefs.length; animationIndex++) {
-        const animationDef = animationDefs[animationIndex];
-        const clip = clips[animationIndex];
-        if (!clip || !Array.isArray(clip.tracks) || !Array.isArray(animationDef.channels) || !Array.isArray(animationDef.samplers))
-            continue;
-        for (const channel of animationDef.channels) {
-            const pointer = channel.target?.extensions?.KHR_animation_pointer?.pointer;
-            const match = typeof pointer === 'string'
-                ? pointer.match(/^\/materials\/(\d+)\/pbrMetallicRoughness\/baseColorFactor$/)
-                : null;
-            if (!match)
-                continue;
-            const samplerIndex = channel.sampler;
-            const sampler = typeof samplerIndex === 'number' ? animationDef.samplers[samplerIndex] : undefined;
-            if (!sampler || sampler.interpolation === 'CUBICSPLINE' || typeof sampler.input !== 'number' || typeof sampler.output !== 'number')
-                continue;
-            const materialIndex = Number.parseInt(match[1], 10);
-            const targets = materialAnimationTargets(gltf, parser, materialIndex);
-            if (targets.length === 0)
-                continue;
-            const [inputAccessor, outputAccessor] = await Promise.all([
-                parser.getDependency('accessor', sampler.input),
-                parser.getDependency('accessor', sampler.output),
-            ]);
-            const times = inputAccessor.array;
-            const values = outputAccessor.array;
-            const itemSize = outputAccessor.itemSize ?? 0;
-            if (!times || !values || itemSize < 3)
-                continue;
-            const colorValues = animationPointerColorValues(times.length, values, itemSize);
-            const interpolation = sampler.interpolation === 'STEP' ? InterpolateDiscrete : InterpolateLinear;
-            for (const target of targets) {
-                clip.tracks.push(new ColorKeyframeTrack(`${target}.material.color`, times, colorValues, interpolation));
-            }
-            clip.resetDuration?.();
-        }
-    }
-}
-function materialAnimationTargets(gltf, parser, materialIndex) {
-    const associations = parser.associations;
-    if (!associations)
-        return [];
-    const targets = [];
-    const seen = new Set();
-    for (const root of gltfRootScenes(gltf)) {
-        root.traverse?.((object) => {
-            const mesh = object;
-            if (mesh.isMesh !== true)
-                return;
-            const materials = Array.isArray(mesh.material) ? mesh.material : [mesh.material];
-            if (!materials.some((material) => associations.get(material)?.materials === materialIndex))
-                return;
-            const target = mesh.name || mesh.uuid;
-            if (target && !seen.has(target)) {
-                seen.add(target);
-                targets.push(target);
-            }
-        });
-    }
-    return targets;
-}
-function animationPointerColorValues(keyframeCount, values, itemSize) {
-    const colors = new Float32Array(keyframeCount * 3);
-    for (let keyframe = 0; keyframe < keyframeCount; keyframe++) {
-        const source = keyframe * itemSize;
-        const target = keyframe * 3;
-        colors[target] = Number(values[source] ?? 0);
-        colors[target + 1] = Number(values[source + 1] ?? 0);
-        colors[target + 2] = Number(values[source + 2] ?? 0);
-    }
-    return colors;
-}
-function applyNodeVisibilityExtension(gltf, parser) {
-    const associations = parser.associations;
-    const nodes = parser.json?.nodes;
-    if (!associations || !Array.isArray(nodes))
-        return;
-    const nodeIndexByName = uniqueNodeIndexByName(nodes);
-    for (const root of gltfRootScenes(gltf)) {
-        root.traverse?.((object) => {
-            const association = associations.get(object);
-            let nodeIndex = association?.nodes;
-            const objectName = typeof object.name === 'string'
-                ? object.name
-                : '';
-            const associatedNode = typeof nodeIndex === 'number' && Number.isInteger(nodeIndex)
-                ? nodes[nodeIndex]
-                : undefined;
-            const associatedName = typeof associatedNode?.name === 'string'
-                ? associatedNode.name
-                : '';
-            if (objectName && associatedName !== objectName) {
-                nodeIndex = nodeIndexByName.get(objectName) ?? nodeIndex;
-            }
-            if (typeof nodeIndex !== 'number' || !Number.isInteger(nodeIndex))
-                return;
-            const node = nodes[nodeIndex];
-            if (!node || typeof node !== 'object' || Array.isArray(node))
-                return;
-            const visible = node.extensions?.KHR_node_visibility?.visible;
-            const objectLike = object;
-            if (visible === false) {
-                objectLike.visible = false;
-            }
-            else if (visible === true) {
-                objectLike.visible = true;
-            }
-        });
-    }
-}
-function uniqueNodeIndexByName(nodes) {
-    const counts = new Map();
-    for (const node of nodes) {
-        const name = typeof node?.name === 'string'
-            ? node.name
-            : '';
-        if (name)
-            counts.set(name, (counts.get(name) ?? 0) + 1);
-    }
-    const result = new Map();
-    nodes.forEach((node, index) => {
-        const name = typeof node?.name === 'string'
-            ? node.name
-            : '';
-        if (name && counts.get(name) === 1)
-            result.set(name, index);
-    });
-    return result;
-}
-function gltfRootScenes(gltf) {
-    const root = gltf;
-    const scenes = Array.isArray(root?.scenes) ? root.scenes : [];
-    const result = scenes.filter(isTraversableObject);
-    if (isTraversableObject(root?.scene) && !result.includes(root.scene)) {
-        result.push(root.scene);
-    }
-    return result;
-}
-function isTraversableObject(value) {
-    return !!value && typeof value === 'object' && typeof value.traverse === 'function';
-}
-function normalizeEmbeddedGlbImages(data) {
-    if (typeof data === 'string') {
-        validateGltfTextImageReferences(data);
-        return data;
-    }
-    const bytes = Buffer.from(data);
-    const normalized = rewriteGlbBufferViewImages(bytes);
-    if (!normalized) {
-        validateGltfTextImageReferences(bytes);
-    }
-    return normalized ? arrayBufferView(normalized) : data;
-}
-function rewriteGlbBufferViewImages(bytes) {
-    if (bytes.byteLength < 20 || bytes.readUInt32LE(0) !== 0x46546c67 || bytes.readUInt32LE(4) !== 2) {
-        return null;
-    }
-    let offset = 12;
-    let jsonChunk = null;
-    let binChunk = null;
-    while (offset + 8 <= bytes.byteLength) {
-        const chunkLength = bytes.readUInt32LE(offset);
-        const chunkType = bytes.readUInt32LE(offset + 4);
-        const chunkStart = offset + 8;
-        const chunkEnd = chunkStart + chunkLength;
-        if (chunkEnd > bytes.byteLength)
-            return null;
-        const chunk = bytes.subarray(chunkStart, chunkEnd);
-        if (chunkType === 0x4e4f534a) {
-            jsonChunk = chunk;
-        }
-        else if (chunkType === 0x004e4942 && binChunk === null) {
-            binChunk = chunk;
-        }
-        offset = chunkEnd;
-    }
-    if (!jsonChunk || !binChunk)
-        return null;
-    let json;
-    try {
-        json = JSON.parse(jsonChunk.toString('utf8').trimEnd());
-    }
-    catch {
-        return null;
-    }
-    let changed = false;
-    for (const image of gltfImages(json, 'GLB')) {
-        validateGltfImageUri(image);
-        if (!image || !Number.isInteger(image.bufferView))
-            continue;
-        if (typeof image.mimeType !== 'string') {
-            throw new Error('GLB bufferView image is missing mimeType. Embedded GLB images must declare PNG, JPEG, or WebP mimeType values.');
-        }
-        validateSupportedEmbeddedImageType('GLB bufferView image', image.mimeType);
-        const imageBytes = glbBufferViewBytes(json, binChunk, image.bufferView);
-        if (!imageBytes)
-            continue;
-        image.uri = `data:${image.mimeType};base64,${imageBytes.toString('base64')}`;
-        delete image.bufferView;
-        changed = true;
-    }
-    return changed ? encodeGlb(json, binChunk) : null;
-}
-function validateGltfTextImageReferences(data) {
-    const text = typeof data === 'string' ? data : data.toString('utf8');
-    if (!text.trimStart().startsWith('{'))
-        return;
-    let json;
-    try {
-        json = JSON.parse(text);
-    }
-    catch {
-        return;
-    }
-    for (const image of gltfImages(json, 'glTF')) {
-        validateGltfImageUri(image);
-        if (image && Number.isInteger(image.bufferView)) {
-            if (typeof image.mimeType !== 'string') {
-                throw new Error('glTF bufferView image is missing mimeType. Embedded glTF images must declare PNG, JPEG, or WebP mimeType values.');
-            }
-            validateSupportedEmbeddedImageType('glTF bufferView image', image.mimeType);
-        }
-    }
-}
-function gltfImages(json, label) {
-    const images = json.images;
-    if (images == null)
-        return [];
-    if (!Array.isArray(images)) {
-        throw new Error(`${label}.images must be an array.`);
-    }
-    for (let i = 0; i < images.length; i += 1) {
-        const image = images[i];
-        if (!image || typeof image !== 'object' || Array.isArray(image)) {
-            throw new Error(`${label}.images[${i}] must be an object.`);
-        }
-    }
-    return images;
-}
-function validateGltfImageUri(image) {
-    const uri = typeof image?.uri === 'string' ? image.uri : null;
-    if (!uri)
-        return;
-    const mimeType = imageMimeTypeFromUri(uri);
-    if (mimeType) {
-        validateSupportedEmbeddedImageType('glTF image URI', mimeType);
-    }
-}
-function imageMimeTypeFromUri(uri) {
-    const dataUriMatch = uri.match(/^data:([^;,]+)/i);
-    if (dataUriMatch)
-        return dataUriMatch[1].toLowerCase();
-    if (/\.ktx2(?:$|[?#])/i.test(uri))
-        return 'image/ktx2';
-    if (/\.basis(?:$|[?#])/i.test(uri))
-        return 'image/basis';
-    return null;
-}
-function validateSupportedEmbeddedImageType(label, mimeType) {
-    if (!/^image\/(?:png|jpe?g|webp)$/i.test(mimeType)) {
-        throw unsupportedEmbeddedImageTypeError(label, mimeType);
-    }
-}
-function unsupportedEmbeddedImageTypeError(label, mimeType) {
-    if (/(?:ktx2|basis|compressed)/i.test(mimeType)) {
-        return new Error(`${label} uses compressed texture MIME type "${mimeType}". KTX2, Basis, and compressed texture inputs are not decoded by @headless-three/renderer yet; pre-decode the texture to RGBA data or an encoded PNG/JPEG/WebP image before loading.`);
-    }
-    return new Error(`${label} uses unsupported MIME type "${mimeType}". Embedded GLB images must be PNG, JPEG, or WebP encoded images.`);
-}
-function glbBufferViewBytes(json, binChunk, index) {
-    const bufferView = json.bufferViews?.[index];
-    if (!bufferView || bufferView.buffer !== 0 || !Number.isFinite(bufferView.byteLength)) {
-        return null;
-    }
-    const byteOffset = bufferView.byteOffset == null ? 0 : bufferView.byteOffset;
-    if (!Number.isFinite(byteOffset))
-        return null;
-    const start = Math.trunc(byteOffset);
-    const end = start + Math.trunc(bufferView.byteLength);
-    if (start < 0 || end < start || end > binChunk.byteLength)
-        return null;
-    return binChunk.subarray(start, end);
-}
-function encodeGlb(json, binChunk) {
-    const jsonBytes = paddedChunk(Buffer.from(JSON.stringify(json), 'utf8'), 0x20);
-    const binBytes = paddedChunk(binChunk, 0x00);
-    const totalLength = 12 + 8 + jsonBytes.length + 8 + binBytes.length;
-    const glb = Buffer.alloc(totalLength);
-    let offset = 0;
-    offset = writeGlbUint32(glb, offset, 0x46546c67);
-    offset = writeGlbUint32(glb, offset, 2);
-    offset = writeGlbUint32(glb, offset, totalLength);
-    offset = writeGlbUint32(glb, offset, jsonBytes.length);
-    offset = writeGlbUint32(glb, offset, 0x4e4f534a);
-    jsonBytes.copy(glb, offset);
-    offset += jsonBytes.length;
-    offset = writeGlbUint32(glb, offset, binBytes.length);
-    offset = writeGlbUint32(glb, offset, 0x004e4942);
-    binBytes.copy(glb, offset);
-    return glb;
-}
-function paddedChunk(buffer, fill) {
-    const padded = Buffer.alloc((buffer.length + 3) & ~3, fill);
-    buffer.copy(padded);
-    return padded;
-}
-function writeGlbUint32(buffer, offset, value) {
-    buffer.writeUInt32LE(value, offset);
-    return offset + 4;
-}
-function optionalBoolean(value, label) {
-    if (value == null)
-        return undefined;
-    if (typeof value === 'boolean')
-        return value;
-    throw new TypeError(`${label} must be a boolean.`);
-}
-function optionalNonNegativeNumber(value, label) {
-    if (value == null)
-        return undefined;
-    if (typeof value === 'number' && Number.isFinite(value) && value >= 0)
-        return value;
-    throw new TypeError(`${label} must be a finite non-negative number.`);
-}
-function optionalNonNegativeInteger(value, label) {
-    if (value == null)
-        return undefined;
-    if (typeof value === 'number' && Number.isInteger(value) && value >= 0)
-        return value;
-    throw new TypeError(`${label} must be a non-negative integer.`);
-}
-function validateNodeGltfLoaderOptions(options) {
-    return {
-        configureLoader: optionalFunction(options.configureLoader, 'options.configureLoader'),
-        installFetch: optionalBoolean(options.installFetch, 'options.installFetch'),
-        manager: optionalLoadingManager(options.manager, 'options.manager'),
-        registerTextureHandlers: optionalBoolean(options.registerTextureHandlers, 'options.registerTextureHandlers'),
-    };
-}
-function validateLoadGltfFromFileOptions(options) {
-    validateNodeGltfLoaderOptions(options);
-    optionalString(options.rootDir, 'options.rootDir');
-    optionalString(options.baseUrl, 'options.baseUrl');
-}
-function requiredString(value, label) {
-    if (typeof value === 'string')
-        return value;
-    throw new TypeError(`${label} must be a string.`);
-}
-function optionalString(value, label) {
-    if (value == null)
-        return undefined;
-    return requiredString(value, label);
-}
-function objectOptions(value, label) {
-    if (value != null && typeof value === 'object' && !Array.isArray(value)) {
-        return value;
-    }
-    throw new TypeError(`${label} must be an object.`);
-}
-function optionalFunction(value, label) {
-    if (value == null)
-        return undefined;
-    if (typeof value === 'function')
-        return value;
-    throw new TypeError(`${label} must be a function.`);
-}
-function optionalLoadingManager(value, label) {
-    if (value == null)
-        return undefined;
-    if (typeof value.addHandler !== 'function') {
-        throw new TypeError(`${label} must provide an addHandler() function.`);
-    }
-    for (const method of ['itemStart', 'itemEnd', 'itemError', 'resolveURL']) {
-        if (value[method] != null && typeof value[method] !== 'function') {
-            throw new TypeError(`${label}.${method} must be a function when provided.`);
-        }
-    }
-    return value;
-}
-function registerLoaderPlugin(loader, callback, label) {
-    if (typeof loader.register !== 'function') {
-        throw new Error(`GLTFLoader.register is required to install ${label}.`);
-    }
-    loader.register(callback);
-}
-const dynamicImport = new Function('specifier', 'return import(specifier)');
-function importGltfLoader() {
-    return dynamicImport('three/examples/jsm/loaders/GLTFLoader.js');
-}
-async function importVrmLoaderPlugin() {
-    let module;
-    try {
-        module = await dynamicImport('@pixiv/three-vrm');
-    }
-    catch {
-        throw new Error('Missing optional dependency @pixiv/three-vrm. Install it in your project or pass VRMLoaderPlugin to loadVrmFromFile().');
-    }
-    if (typeof module.VRMLoaderPlugin !== 'function') {
-        throw new Error('@pixiv/three-vrm did not export VRMLoaderPlugin.');
-    }
-    return module.VRMLoaderPlugin;
-}
-async function importVrmAnimationLoaderPlugin() {
-    let module;
-    try {
-        module = await dynamicImport('@pixiv/three-vrm-animation');
-    }
-    catch {
-        throw new Error('Missing optional dependency @pixiv/three-vrm-animation. Install it in your project or pass VRMAnimationLoaderPlugin to loadVrmAnimationFromFile().');
-    }
-    if (typeof module.VRMAnimationLoaderPlugin !== 'function') {
-        throw new Error('@pixiv/three-vrm-animation did not export VRMAnimationLoaderPlugin.');
-    }
-    return module.VRMAnimationLoaderPlugin;
-}
-async function importVrmAnimationClipFactory() {
-    let module;
-    try {
-        module = await dynamicImport('@pixiv/three-vrm-animation');
-    }
-    catch {
-        throw new Error('Missing optional dependency @pixiv/three-vrm-animation. Install it in your project or pass createVRMAnimationClip to applyVrmAnimation().');
-    }
-    if (typeof module.createVRMAnimationClip !== 'function') {
-        throw new Error('@pixiv/three-vrm-animation did not export createVRMAnimationClip.');
-    }
-    return module.createVRMAnimationClip;
-}
+exports.installLocalFileFetch = exports.resolveLocalAssetPath = exports.applyVrmAnimation = exports.loadVrmAnimationFromFile = exports.loadVrmFromFile = exports.loadGltfFromFile = exports.createNodeGltfLoader = exports.createEncodedImageTextureLoader = exports.EncodedImageTextureLoader = void 0;
+require("./loaders.part-001");
+require("./loaders.part-002");
+require("./loaders.part-003");
+var loaders_part_001_1 = require("./loaders.part-001");
+Object.defineProperty(exports, "EncodedImageTextureLoader", { enumerable: true, get: function () { return loaders_part_001_1.EncodedImageTextureLoader; } });
+var loaders_part_001_2 = require("./loaders.part-001");
+Object.defineProperty(exports, "createEncodedImageTextureLoader", { enumerable: true, get: function () { return loaders_part_001_2.createEncodedImageTextureLoader; } });
+var loaders_part_001_3 = require("./loaders.part-001");
+Object.defineProperty(exports, "createNodeGltfLoader", { enumerable: true, get: function () { return loaders_part_001_3.createNodeGltfLoader; } });
+var loaders_part_001_4 = require("./loaders.part-001");
+Object.defineProperty(exports, "loadGltfFromFile", { enumerable: true, get: function () { return loaders_part_001_4.loadGltfFromFile; } });
+var loaders_part_001_5 = require("./loaders.part-001");
+Object.defineProperty(exports, "loadVrmFromFile", { enumerable: true, get: function () { return loaders_part_001_5.loadVrmFromFile; } });
+var loaders_part_001_6 = require("./loaders.part-001");
+Object.defineProperty(exports, "loadVrmAnimationFromFile", { enumerable: true, get: function () { return loaders_part_001_6.loadVrmAnimationFromFile; } });
+var loaders_part_001_7 = require("./loaders.part-001");
+Object.defineProperty(exports, "applyVrmAnimation", { enumerable: true, get: function () { return loaders_part_001_7.applyVrmAnimation; } });
+var loaders_part_002_1 = require("./loaders.part-002");
+Object.defineProperty(exports, "resolveLocalAssetPath", { enumerable: true, get: function () { return loaders_part_002_1.resolveLocalAssetPath; } });
+var loaders_part_002_2 = require("./loaders.part-002");
+Object.defineProperty(exports, "installLocalFileFetch", { enumerable: true, get: function () { return loaders_part_002_2.installLocalFileFetch; } });
 //# sourceMappingURL=loaders.js.map