(function webpackUniversalModuleDefinition(root, factory) {
	if(typeof exports === 'object' && typeof module === 'object')
		module.exports = factory();
	else if(typeof define === 'function' && define.amd)
		define("babylon-mmd", [], factory);
	else if(typeof exports === 'object')
		exports["babylon-mmd"] = factory();
	else
		root["BABYLONMMD"] = factory();
})((typeof self !== "undefined" ? self : typeof global !== "undefined" ? global : this), () => {
return /******/ (() => { // webpackBootstrap
/******/ 	"use strict";
/******/ 	var __webpack_modules__ = ({

/***/ "./src/Runtime/Optimized/wasm/md/index.js":
/*!************************************************!*\
  !*** ./src/Runtime/Optimized/wasm/md/index.js ***!
  \************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AnimationPool: () => (/* binding */ AnimationPool),
/* harmony export */   MmdRuntime: () => (/* binding */ MmdRuntime),
/* harmony export */   createAnimationPool: () => (/* binding */ createAnimationPool),
/* harmony export */   createMmdRuntime: () => (/* binding */ createMmdRuntime),
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__),
/* harmony export */   init: () => (/* binding */ init),
/* harmony export */   initSync: () => (/* binding */ initSync),
/* harmony export */   initThreadPool: () => (/* binding */ initThreadPool),
/* harmony export */   wbg_rayon_PoolBuilder: () => (/* binding */ wbg_rayon_PoolBuilder),
/* harmony export */   wbg_rayon_start_worker: () => (/* binding */ wbg_rayon_start_worker)
/* harmony export */ });
/* harmony import */ var _snippets_wasm_bindgen_rayon_3e04391371ad0a8e_src_workerHelpers_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.js */ "./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.js");


let wasm;

const heap = new Array(128).fill(undefined);

heap.push(undefined, null, true, false);

function getObject(idx) { return heap[idx]; }

let heap_next = heap.length;

function dropObject(idx) {
    if (idx < 132) return;
    heap[idx] = heap_next;
    heap_next = idx;
}

function takeObject(idx) {
    const ret = getObject(idx);
    dropObject(idx);
    return ret;
}

function addHeapObject(obj) {
    if (heap_next === heap.length) heap.push(heap.length + 1);
    const idx = heap_next;
    heap_next = heap[idx];

    if (typeof(heap_next) !== 'number') throw new Error('corrupt heap');

    heap[idx] = obj;
    return idx;
}

function _assertBoolean(n) {
    if (typeof(n) !== 'boolean') {
        throw new Error(`expected a boolean argument, found ${typeof(n)}`);
    }
}

const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );

if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };

let cachedUint8Memory0 = null;

function getUint8Memory0() {
    if (cachedUint8Memory0 === null || cachedUint8Memory0.buffer !== wasm.memory.buffer) {
        cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
    }
    return cachedUint8Memory0;
}

function getStringFromWasm0(ptr, len) {
    ptr = ptr >>> 0;
    return cachedTextDecoder.decode(getUint8Memory0().slice(ptr, ptr + len));
}

function _assertNum(n) {
    if (typeof(n) !== 'number') throw new Error(`expected a number argument, found ${typeof(n)}`);
}

function isLikeNone(x) {
    return x === undefined || x === null;
}

function _assertClass(instance, klass) {
    if (!(instance instanceof klass)) {
        throw new Error(`expected instance of ${klass.name}`);
    }
    return instance.ptr;
}
/**
*/
function init() {
    wasm.init();
}

/**
* @returns {MmdRuntime}
*/
function createMmdRuntime() {
    const ret = wasm.createMmdRuntime();
    return MmdRuntime.__wrap(ret);
}

/**
* @returns {AnimationPool}
*/
function createAnimationPool() {
    const ret = wasm.createAnimationPool();
    return AnimationPool.__wrap(ret);
}

function logError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        let error = (function () {
            try {
                return e instanceof Error ? `${e.message}\n\nStack:\n${e.stack}` : e.toString();
            } catch(_) {
                return "<failed to stringify thrown value>";
            }
        }());
        console.error("wasm-bindgen: imported JS function that was not marked as `catch` threw an error:", error);
        throw e;
    }
}

let WASM_VECTOR_LEN = 0;

const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );

const encodeString = function (arg, view) {
    const buf = cachedTextEncoder.encode(arg);
    view.set(buf);
    return {
        read: arg.length,
        written: buf.length
    };
};

function passStringToWasm0(arg, malloc, realloc) {

    if (typeof(arg) !== 'string') throw new Error(`expected a string argument, found ${typeof(arg)}`);

    if (realloc === undefined) {
        const buf = cachedTextEncoder.encode(arg);
        const ptr = malloc(buf.length, 1) >>> 0;
        getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
        WASM_VECTOR_LEN = buf.length;
        return ptr;
    }

    let len = arg.length;
    let ptr = malloc(len, 1) >>> 0;

    const mem = getUint8Memory0();

    let offset = 0;

    for (; offset < len; offset++) {
        const code = arg.charCodeAt(offset);
        if (code > 0x7F) break;
        mem[ptr + offset] = code;
    }

    if (offset !== len) {
        if (offset !== 0) {
            arg = arg.slice(offset);
        }
        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
        const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
        const ret = encodeString(arg, view);
        if (ret.read !== arg.length) throw new Error('failed to pass whole string');
        offset += ret.written;
        ptr = realloc(ptr, len, offset, 1) >>> 0;
    }

    WASM_VECTOR_LEN = offset;
    return ptr;
}

let cachedInt32Memory0 = null;

function getInt32Memory0() {
    if (cachedInt32Memory0 === null || cachedInt32Memory0.buffer !== wasm.memory.buffer) {
        cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
    }
    return cachedInt32Memory0;
}

function handleError(f, args) {
    try {
        return f.apply(this, args);
    } catch (e) {
        wasm.__wbindgen_exn_store(addHeapObject(e));
    }
}
/**
* @param {number} num_threads
* @returns {Promise<any>}
*/
function initThreadPool(num_threads) {
    _assertNum(num_threads);
    const ret = wasm.initThreadPool(num_threads);
    return takeObject(ret);
}

/**
* @param {number} receiver
*/
function wbg_rayon_start_worker(receiver) {
    _assertNum(receiver);
    wasm.wbg_rayon_start_worker(receiver);
}

const AnimationPoolFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_animationpool_free(ptr >>> 0));
/**
*/
class AnimationPool {

    constructor() {
        throw new Error('cannot invoke `new` directly');
    }

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(AnimationPool.prototype);
        obj.__wbg_ptr = ptr;
        AnimationPoolFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        AnimationPoolFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_animationpool_free(ptr);
    }
    /**
    * @param {number} count
    * @returns {number}
    */
    allocateLengthsBuffer(count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(count);
        const ret = wasm.animationpool_allocateLengthsBuffer(this.__wbg_ptr, count);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @param {number} count
    */
    deallocateLengthsBuffer(ptr, count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        _assertNum(count);
        wasm.animationpool_deallocateLengthsBuffer(this.__wbg_ptr, ptr, count);
    }
    /**
    * @param {number} track_lengths
    * @param {number} track_count
    * @returns {number}
    */
    createBoneTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createBoneTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getBoneTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getBoneTrackRotations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackRotations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getBoneTrackRotationInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} track_lengths
    * @param {number} track_count
    * @returns {number}
    */
    createMovableBoneTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createMovableBoneTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMovableBoneTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMovableBoneTrackPositions(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackPositions(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMovableBoneTrackPositionInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackPositionInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMovableBoneTrackRotations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackRotations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMovableBoneTrackRotationInterpolations(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMovableBoneTrackRotationInterpolations(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} track_lengths
    * @param {number} track_count
    * @returns {number}
    */
    createMorphTracks(track_lengths, track_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(track_lengths);
        _assertNum(track_count);
        const ret = wasm.animationpool_createMorphTracks(this.__wbg_ptr, track_lengths, track_count);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMorphTrackFrameNumbers(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMorphTrackFrameNumbers(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} tracks
    * @param {number} index
    * @returns {number}
    */
    getMorphTrackWeights(tracks, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(tracks);
        _assertNum(index);
        const ret = wasm.animationpool_getMorphTrackWeights(this.__wbg_ptr, tracks, index);
        return ret >>> 0;
    }
    /**
    * @param {number} bone_tracks_ptr
    * @param {number} bone_track_count
    * @param {number} movable_bone_tracks_ptr
    * @param {number} movable_bone_track_count
    * @param {number} morph_tracks_ptr
    * @param {number} morph_track_count
    * @param {number} property_track_length
    * @param {number} property_track_ik_count
    * @returns {number}
    */
    createAnimation(bone_tracks_ptr, bone_track_count, movable_bone_tracks_ptr, movable_bone_track_count, morph_tracks_ptr, morph_track_count, property_track_length, property_track_ik_count) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(bone_tracks_ptr);
        _assertNum(bone_track_count);
        _assertNum(movable_bone_tracks_ptr);
        _assertNum(movable_bone_track_count);
        _assertNum(morph_tracks_ptr);
        _assertNum(morph_track_count);
        _assertNum(property_track_length);
        _assertNum(property_track_ik_count);
        const ret = wasm.animationpool_createAnimation(this.__wbg_ptr, bone_tracks_ptr, bone_track_count, movable_bone_tracks_ptr, movable_bone_track_count, morph_tracks_ptr, morph_track_count, property_track_length, property_track_ik_count);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @returns {number}
    */
    getPropertyTrackFrameNumbers(animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        const ret = wasm.animationpool_getPropertyTrackFrameNumbers(this.__wbg_ptr, animation_ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @param {number} index
    * @returns {number}
    */
    getPropertyTrackIkStates(animation_ptr, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        _assertNum(index);
        const ret = wasm.animationpool_getPropertyTrackIkStates(this.__wbg_ptr, animation_ptr, index);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    */
    destroyAnimation(animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        wasm.animationpool_destroyAnimation(this.__wbg_ptr, animation_ptr);
    }
    /**
    * @param {number} animation_ptr
    * @returns {number}
    */
    createBoneBindIndexMap(animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        const ret = wasm.animationpool_createBoneBindIndexMap(this.__wbg_ptr, animation_ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @returns {number}
    */
    createMovableBoneBindIndexMap(animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        const ret = wasm.animationpool_createMovableBoneBindIndexMap(this.__wbg_ptr, animation_ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @param {number} morph_lengths
    * @returns {number}
    */
    createMorphBindIndexMap(animation_ptr, morph_lengths) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        _assertNum(morph_lengths);
        const ret = wasm.animationpool_createMorphBindIndexMap(this.__wbg_ptr, animation_ptr, morph_lengths);
        return ret >>> 0;
    }
    /**
    * @param {number} morph_bind_index_map
    * @param {number} index
    * @returns {number}
    */
    getNthMorphBindIndexMap(morph_bind_index_map, index) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(morph_bind_index_map);
        _assertNum(index);
        const ret = wasm.animationpool_getNthMorphBindIndexMap(this.__wbg_ptr, morph_bind_index_map, index);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @returns {number}
    */
    createIkSolverBindIndexMap(animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        const ret = wasm.animationpool_createIkSolverBindIndexMap(this.__wbg_ptr, animation_ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} animation_ptr
    * @param {number} bone_bind_index_map
    * @param {number} movable_bone_bind_index_map
    * @param {number} morph_bind_index_map
    * @param {number} ik_solver_bind_index_map
    * @returns {number}
    */
    createRuntimeAnimation(animation_ptr, bone_bind_index_map, movable_bone_bind_index_map, morph_bind_index_map, ik_solver_bind_index_map) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        _assertNum(bone_bind_index_map);
        _assertNum(movable_bone_bind_index_map);
        _assertNum(morph_bind_index_map);
        _assertNum(ik_solver_bind_index_map);
        const ret = wasm.animationpool_createRuntimeAnimation(this.__wbg_ptr, animation_ptr, bone_bind_index_map, movable_bone_bind_index_map, morph_bind_index_map, ik_solver_bind_index_map);
        return ret >>> 0;
    }
    /**
    * @param {number} runtime_animation_ptr
    */
    destroyRuntimeAnimation(runtime_animation_ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(runtime_animation_ptr);
        wasm.animationpool_destroyRuntimeAnimation(this.__wbg_ptr, runtime_animation_ptr);
    }
    /**
    * @param {number} animation_ptr
    * @param {number} mmd_model_ptr
    * @param {number} frame_time
    */
    animateMmdModel(animation_ptr, mmd_model_ptr, frame_time) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(animation_ptr);
        _assertNum(mmd_model_ptr);
        wasm.animationpool_animateMmdModel(this.__wbg_ptr, animation_ptr, mmd_model_ptr, frame_time);
    }
}

const MmdRuntimeFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_mmdruntime_free(ptr >>> 0));
/**
*/
class MmdRuntime {

    constructor() {
        throw new Error('cannot invoke `new` directly');
    }

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(MmdRuntime.prototype);
        obj.__wbg_ptr = ptr;
        MmdRuntimeFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        MmdRuntimeFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_mmdruntime_free(ptr);
    }
    /**
    * @param {number} size
    * @returns {number}
    */
    allocateBuffer(size) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(size);
        const ret = wasm.mmdruntime_allocateBuffer(this.__wbg_ptr, size);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @param {number} size
    */
    deallocateBuffer(ptr, size) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        _assertNum(size);
        wasm.mmdruntime_deallocateBuffer(this.__wbg_ptr, ptr, size);
    }
    /**
    * @param {number} serialized_metadata_ptr
    * @param {number} serialized_metadata_size
    * @returns {number}
    */
    createMmdModel(serialized_metadata_ptr, serialized_metadata_size) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(serialized_metadata_ptr);
        _assertNum(serialized_metadata_size);
        const ret = wasm.mmdruntime_createMmdModel(this.__wbg_ptr, serialized_metadata_ptr, serialized_metadata_size);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    */
    destroyMmdModel(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        wasm.mmdruntime_destroyMmdModel(this.__wbg_ptr, ptr);
    }
    /**
    * @param {number} ptr
    * @returns {number}
    */
    getAnimationArena(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        const ret = wasm.mmdruntime_getAnimationArena(this.__wbg_ptr, ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @returns {number}
    */
    getAnimationIkSolverStateArena(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        const ret = wasm.mmdruntime_getAnimationIkSolverStateArena(this.__wbg_ptr, ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @returns {number}
    */
    getAnimationMorphArena(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        const ret = wasm.mmdruntime_getAnimationMorphArena(this.__wbg_ptr, ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @returns {number}
    */
    getBoneWorldMatrixArena(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        const ret = wasm.mmdruntime_getBoneWorldMatrixArena(this.__wbg_ptr, ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @returns {number}
    */
    createBoneWorldMatrixBackBuffer(ptr) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        const ret = wasm.mmdruntime_createBoneWorldMatrixBackBuffer(this.__wbg_ptr, ptr);
        return ret >>> 0;
    }
    /**
    * @param {number} ptr
    * @param {number} runtime_animation
    */
    setRuntimeAnimation(ptr, runtime_animation) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        _assertNum(runtime_animation);
        wasm.mmdruntime_setRuntimeAnimation(this.__wbg_ptr, ptr, runtime_animation);
    }
    /**
    * @param {number} ptr
    * @param {boolean} external_physics
    */
    setExternalPhysics(ptr, external_physics) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        _assertNum(ptr);
        _assertBoolean(external_physics);
        wasm.mmdruntime_setExternalPhysics(this.__wbg_ptr, ptr, external_physics);
    }
    /**
    * @param {number | undefined} [frame_time]
    */
    beforePhysics(frame_time) {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        if (!isLikeNone(frame_time)) {
            _assertNum(frame_time);
        }
        wasm.mmdruntime_beforePhysics(this.__wbg_ptr, !isLikeNone(frame_time), isLikeNone(frame_time) ? 0 : frame_time);
    }
    /**
    */
    afterPhysics() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        wasm.mmdruntime_afterPhysics(this.__wbg_ptr);
    }
    /**
    * @returns {number}
    */
    getLockStatePtr() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        const ret = wasm.mmdruntime_getLockStatePtr(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
    */
    swapWorldMatrixBuffer() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        wasm.mmdruntime_swapWorldMatrixBuffer(this.__wbg_ptr);
    }
    /**
    * @param {MmdRuntime} mmd_runtime
    * @param {number | undefined} [frame_time]
    */
    static bufferedBeforePhysics(mmd_runtime, frame_time) {
        _assertClass(mmd_runtime, MmdRuntime);
        if (mmd_runtime.__wbg_ptr === 0) {
            throw new Error('Attempt to use a moved value');
        }
        if (!isLikeNone(frame_time)) {
            _assertNum(frame_time);
        }
        wasm.mmdruntime_bufferedBeforePhysics(mmd_runtime.__wbg_ptr, !isLikeNone(frame_time), isLikeNone(frame_time) ? 0 : frame_time);
    }
    /**
    * @param {MmdRuntime} mmd_runtime
    * @param {number | undefined} [frame_time]
    */
    static bufferedUpdate(mmd_runtime, frame_time) {
        _assertClass(mmd_runtime, MmdRuntime);
        if (mmd_runtime.__wbg_ptr === 0) {
            throw new Error('Attempt to use a moved value');
        }
        if (!isLikeNone(frame_time)) {
            _assertNum(frame_time);
        }
        wasm.mmdruntime_bufferedUpdate(mmd_runtime.__wbg_ptr, !isLikeNone(frame_time), isLikeNone(frame_time) ? 0 : frame_time);
    }
}

const wbg_rayon_PoolBuilderFinalization = (typeof FinalizationRegistry === 'undefined')
    ? { register: () => {}, unregister: () => {} }
    : new FinalizationRegistry(ptr => wasm.__wbg_wbg_rayon_poolbuilder_free(ptr >>> 0));
/**
*/
class wbg_rayon_PoolBuilder {

    constructor() {
        throw new Error('cannot invoke `new` directly');
    }

    static __wrap(ptr) {
        ptr = ptr >>> 0;
        const obj = Object.create(wbg_rayon_PoolBuilder.prototype);
        obj.__wbg_ptr = ptr;
        wbg_rayon_PoolBuilderFinalization.register(obj, obj.__wbg_ptr, obj);
        return obj;
    }

    __destroy_into_raw() {
        const ptr = this.__wbg_ptr;
        this.__wbg_ptr = 0;
        wbg_rayon_PoolBuilderFinalization.unregister(this);
        return ptr;
    }

    free() {
        const ptr = this.__destroy_into_raw();
        wasm.__wbg_wbg_rayon_poolbuilder_free(ptr);
    }
    /**
    * @returns {number}
    */
    numThreads() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        const ret = wasm.wbg_rayon_poolbuilder_numThreads(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
    * @returns {number}
    */
    receiver() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        const ret = wasm.wbg_rayon_poolbuilder_receiver(this.__wbg_ptr);
        return ret >>> 0;
    }
    /**
    */
    build() {
        if (this.__wbg_ptr == 0) throw new Error('Attempt to use a moved value');
        _assertNum(this.__wbg_ptr);
        wasm.wbg_rayon_poolbuilder_build(this.__wbg_ptr);
    }
}

async function __wbg_load(module, imports) {
    if (typeof Response === 'function' && module instanceof Response) {
        if (typeof WebAssembly.instantiateStreaming === 'function') {
            try {
                return await WebAssembly.instantiateStreaming(module, imports);

            } catch (e) {
                if (module.headers.get('Content-Type') != 'application/wasm') {
                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);

                } else {
                    throw e;
                }
            }
        }

        const bytes = await module.arrayBuffer();
        return await WebAssembly.instantiate(bytes, imports);

    } else {
        const instance = await WebAssembly.instantiate(module, imports);

        if (instance instanceof WebAssembly.Instance) {
            return { instance, module };

        } else {
            return instance;
        }
    }
}

function __wbg_get_imports() {
    const imports = {};
    imports.wbg = {};
    imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
        takeObject(arg0);
    };
    imports.wbg.__wbg_new_abda76e883ba8a5f = function() { return logError(function () {
        const ret = new Error();
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbg_stack_658279fe44541cf6 = function() { return logError(function (arg0, arg1) {
        const ret = getObject(arg1).stack;
        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
        const len1 = WASM_VECTOR_LEN;
        getInt32Memory0()[arg0 / 4 + 1] = len1;
        getInt32Memory0()[arg0 / 4 + 0] = ptr1;
    }, arguments) };
    imports.wbg.__wbg_error_f851667af71bcfc6 = function() { return logError(function (arg0, arg1) {
        let deferred0_0;
        let deferred0_1;
        try {
            deferred0_0 = arg0;
            deferred0_1 = arg1;
            console.error(getStringFromWasm0(arg0, arg1));
        } finally {
            wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
        }
    }, arguments) };
    imports.wbg.__wbg_instanceof_Window_cee7a886d55e7df5 = function() { return logError(function (arg0) {
        let result;
        try {
            result = getObject(arg0) instanceof Window;
        } catch (_) {
            result = false;
        }
        const ret = result;
        _assertBoolean(ret);
        return ret;
    }, arguments) };
    imports.wbg.__wbg_newnoargs_cfecb3965268594c = function() { return logError(function (arg0, arg1) {
        const ret = new Function(getStringFromWasm0(arg0, arg1));
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbg_call_3f093dd26d5569f8 = function() { return handleError(function (arg0, arg1) {
        const ret = getObject(arg0).call(getObject(arg1));
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
        const ret = getObject(arg0);
        return addHeapObject(ret);
    };
    imports.wbg.__wbg_self_05040bd9523805b9 = function() { return handleError(function () {
        const ret = self.self;
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbg_window_adc720039f2cb14f = function() { return handleError(function () {
        const ret = window.window;
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbg_globalThis_622105db80c1457d = function() { return handleError(function () {
        const ret = globalThis.globalThis;
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbg_global_f56b013ed9bcf359 = function() { return handleError(function () {
        const ret = __webpack_require__.g.global;
        return addHeapObject(ret);
    }, arguments) };
    imports.wbg.__wbindgen_is_undefined = function(arg0) {
        const ret = getObject(arg0) === undefined;
        _assertBoolean(ret);
        return ret;
    };
    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
        throw new Error(getStringFromWasm0(arg0, arg1));
    };
    imports.wbg.__wbindgen_module = function() {
        const ret = __wbg_init.__wbindgen_wasm_module;
        return addHeapObject(ret);
    };
    imports.wbg.__wbindgen_memory = function() {
        const ret = wasm.memory;
        return addHeapObject(ret);
    };
    imports.wbg.__wbg_startWorkers_2ee336a9694dda13 = function() { return logError(function (arg0, arg1, arg2) {
        const ret = (0,_snippets_wasm_bindgen_rayon_3e04391371ad0a8e_src_workerHelpers_js__WEBPACK_IMPORTED_MODULE_0__.startWorkers)(takeObject(arg0), takeObject(arg1), wbg_rayon_PoolBuilder.__wrap(arg2));
        return addHeapObject(ret);
    }, arguments) };

    return imports;
}

function __wbg_init_memory(imports, maybe_memory) {
    imports.wbg.memory = maybe_memory || new WebAssembly.Memory({initial:19,maximum:16384,shared:true});
}

function __wbg_finalize_init(instance, module) {
    wasm = instance.exports;
    __wbg_init.__wbindgen_wasm_module = module;
    cachedInt32Memory0 = null;
    cachedUint8Memory0 = null;

    wasm.__wbindgen_start();
    return wasm;
}

function initSync(module, maybe_memory) {
    if (wasm !== undefined) return wasm;

    const imports = __wbg_get_imports();

    __wbg_init_memory(imports, maybe_memory);

    if (!(module instanceof WebAssembly.Module)) {
        module = new WebAssembly.Module(module);
    }

    const instance = new WebAssembly.Instance(module, imports);

    return __wbg_finalize_init(instance, module);
}

async function __wbg_init(input, maybe_memory) {
    if (wasm !== undefined) return wasm;

    if (typeof input === 'undefined') {
        input = new URL(/* asset import */ __webpack_require__(/*! index_bg.wasm */ "./src/Runtime/Optimized/wasm/md/index_bg.wasm"), __webpack_require__.b);
    }
    const imports = __wbg_get_imports();

    if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
        input = fetch(input);
    }

    __wbg_init_memory(imports, maybe_memory);

    const { instance, module } = await __wbg_load(await input, imports);

    return __wbg_finalize_init(instance, module);
}


/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (__wbg_init);


/***/ }),

/***/ "./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.js":
/*!*********************************************************************************************************!*\
  !*** ./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.js ***!
  \*********************************************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   startWorkers: () => (/* binding */ startWorkers)
/* harmony export */ });
/*
 * Copyright 2022 Google Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Note: this is never used, but necessary to prevent a bug in Firefox
// (https://bugzilla.mozilla.org/show_bug.cgi?id=1702191) where it collects
// Web Workers that have a shared WebAssembly memory with the main thread,
// but are not explicitly rooted via a `Worker` instance.
//
// By storing them in a variable, we can keep `Worker` objects around and
// prevent them from getting GC-d.
let _workers;

async function startWorkers(module, memory, builder) {
  if (builder.numThreads() === 0) {
    throw new Error(`num_threads must be > 0.`);
  }

  const workerInit = {
    module,
    memory,
    receiver: builder.receiver()
  };

  _workers = await Promise.all(
    Array.from({ length: builder.numThreads() }, async () => {
      // Self-spawn into a new Worker.
      //
      // TODO: while `new URL('...', import.meta.url) becomes a semi-standard
      // way to get asset URLs relative to the module across various bundlers
      // and browser, ideally we should switch to `import.meta.resolve`
      // once it becomes a standard.
      const worker = new Worker(
        new URL(/* worker import */ __webpack_require__.p + __webpack_require__.u("src_Runtime_Optimized_wasm_md_index_js-src_Runtime_Optimized_wasm_md_snippets_wasm-bindgen-ra-c8b86d"), __webpack_require__.b),
        {
          type: undefined
        }
      );
      worker.postMessage(workerInit);
      await new Promise(resolve =>
        worker.addEventListener('message', resolve, { once: true })
      );
      return worker;
    })
  );
  builder.build();
}


/***/ }),

/***/ "./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.worker.js":
/*!****************************************************************************************************************!*\
  !*** ./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.worker.js ***!
  \****************************************************************************************************************/
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {

__webpack_require__.r(__webpack_exports__);
/* harmony import */ var ___WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../../../ */ "./src/Runtime/Optimized/wasm/md/index.js");
/*
 * Copyright 2022 Google Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *     http://www.apache.org/licenses/LICENSE-2.0
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Note: our JS should have been generated in
// `[out-dir]/snippets/wasm-bindgen-rayon-[hash]/workerHelpers.worker.js`,
// resolve the main module via `../../..`.
//
// This might need updating if the generated structure changes on wasm-bindgen
// side ever in the future, but works well with bundlers today. The whole
// point of this crate, after all, is to abstract away unstable features
// and temporary bugs so that you don't need to deal with them in your code.


onmessage = async ({ data: { module, memory, receiver } }) => {
  await (0,___WEBPACK_IMPORTED_MODULE_0__["default"])(module, memory);
  postMessage(true);
  (0,___WEBPACK_IMPORTED_MODULE_0__.wbg_rayon_start_worker)(receiver);
};


/***/ }),

/***/ "./src/Runtime/Optimized/wasm/md/index_bg.wasm":
/*!*****************************************************!*\
  !*** ./src/Runtime/Optimized/wasm/md/index_bg.wasm ***!
  \*****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

module.exports = __webpack_require__.p + "5dd17222f46109441022.wasm";

/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = __webpack_modules__;
/******/ 	
/************************************************************************/
/******/ 	/* webpack/runtime/define property getters */
/******/ 	(() => {
/******/ 		// define getter functions for harmony exports
/******/ 		__webpack_require__.d = (exports, definition) => {
/******/ 			for(var key in definition) {
/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 				}
/******/ 			}
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/get javascript chunk filename */
/******/ 	(() => {
/******/ 		// This function allow to reference async chunks
/******/ 		__webpack_require__.u = (chunkId) => {
/******/ 			// return url for filenames based on template
/******/ 			return "" + chunkId + ".babylon.mmd.js";
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/global */
/******/ 	(() => {
/******/ 		__webpack_require__.g = (function() {
/******/ 			if (typeof globalThis === 'object') return globalThis;
/******/ 			try {
/******/ 				return this || new Function('return this')();
/******/ 			} catch (e) {
/******/ 				if (typeof window === 'object') return window;
/******/ 			}
/******/ 		})();
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
/******/ 	(() => {
/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/make namespace object */
/******/ 	(() => {
/******/ 		// define __esModule on exports
/******/ 		__webpack_require__.r = (exports) => {
/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ 			}
/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
/******/ 		};
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/publicPath */
/******/ 	(() => {
/******/ 		var scriptUrl;
/******/ 		if (__webpack_require__.g.importScripts) scriptUrl = __webpack_require__.g.location + "";
/******/ 		var document = __webpack_require__.g.document;
/******/ 		if (!scriptUrl && document) {
/******/ 			if (document.currentScript)
/******/ 				scriptUrl = document.currentScript.src;
/******/ 			if (!scriptUrl) {
/******/ 				var scripts = document.getElementsByTagName("script");
/******/ 				if(scripts.length) {
/******/ 					var i = scripts.length - 1;
/******/ 					while (i > -1 && (!scriptUrl || !/^http(s?):/.test(scriptUrl))) scriptUrl = scripts[i--].src;
/******/ 				}
/******/ 			}
/******/ 		}
/******/ 		// When supporting browsers where an automatic publicPath is not supported you must specify an output.publicPath manually via configuration
/******/ 		// or pass an empty string ("") and set the __webpack_public_path__ variable from your code to use your own logic.
/******/ 		if (!scriptUrl) throw new Error("Automatic publicPath is not supported in this browser");
/******/ 		scriptUrl = scriptUrl.replace(/#.*$/, "").replace(/\?.*$/, "").replace(/\/[^\/]+$/, "/");
/******/ 		__webpack_require__.p = scriptUrl;
/******/ 	})();
/******/ 	
/******/ 	/* webpack/runtime/importScripts chunk loading */
/******/ 	(() => {
/******/ 		__webpack_require__.b = self.location + "";
/******/ 		
/******/ 		// object to store loaded chunks
/******/ 		// "1" means "already loaded"
/******/ 		var installedChunks = {
/******/ 			"src_Runtime_Optimized_wasm_md_index_js-src_Runtime_Optimized_wasm_md_snippets_wasm-bindgen-ra-c8b86d": 1
/******/ 		};
/******/ 		
/******/ 		// no chunk install function needed
/******/ 		// no chunk loading
/******/ 		
/******/ 		// no HMR
/******/ 		
/******/ 		// no HMR manifest
/******/ 	})();
/******/ 	
/************************************************************************/
/******/ 	
/******/ 	// startup
/******/ 	// Load entry module and return exports
/******/ 	// This entry module is referenced by other modules so it can't be inlined
/******/ 	var __webpack_exports__ = __webpack_require__("./src/Runtime/Optimized/wasm/md/snippets/wasm-bindgen-rayon-3e04391371ad0a8e/src/workerHelpers.worker.js");
/******/ 	
/******/ 	return __webpack_exports__;
/******/ })()
;
});
//# sourceMappingURL=src_Runtime_Optimized_wasm_md_index_js-src_Runtime_Optimized_wasm_md_snippets_wasm-bindgen-ra-c8b86d.babylon.mmd.js.map