var AL = {
    QUEUE_INTERVAL: 25,
    QUEUE_LOOKAHEAD: .1,
    DEVICE_NAME: "Emscripten OpenAL",
    CAPTURE_DEVICE_NAME: "Emscripten OpenAL capture",
    ALC_EXTENSIONS: {
        ALC_SOFT_pause_device: true,
        ALC_SOFT_HRTF: true
    },
    AL_EXTENSIONS: {
        AL_EXT_float32: true,
        AL_SOFT_loop_points: true,
        AL_SOFT_source_length: true,
        AL_EXT_source_distance_model: true,
        AL_SOFT_source_spatialize: true
    },
    _alcErr: 0,
    alcErr: 0,
    deviceRefCounts: {},
    alcStringCache: {},
    paused: false,
    stringCache: {},
    contexts: {},
    currentCtx: null,
    buffers: {
        0: {
            id: 0,
            refCount: 0,
            audioBuf: null,
            frequency: 0,
            bytesPerSample: 2,
            channels: 1,
            length: 0
        }
    },
    paramArray: [],
    _nextId: 1,
    newId: () => AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++,
    freeIds: [],
    scheduleContextAudio: ctx => {
        if (MainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
            return
        }
        for (var i in ctx.sources) {
            AL.scheduleSourceAudio(ctx.sources[i])
        }
    },
    scheduleSourceAudio: (src, lookahead) => {
        if (MainLoop.timingMode === 1 && document["visibilityState"] != "visible") {
            return
        }
        if (src.state !== 4114) {
            return
        }
        var currentTime = AL.updateSourceTime(src);
        var startTime = src.bufStartTime;
        var startOffset = src.bufOffset;
        var bufCursor = src.bufsProcessed;
        for (var i = 0; i < src.audioQueue.length; i++) {
            var audioSrc = src.audioQueue[i];
            startTime = audioSrc._startTime + audioSrc._duration;
            startOffset = 0;
            bufCursor += audioSrc._skipCount + 1
        }
        if (!lookahead) {
            lookahead = AL.QUEUE_LOOKAHEAD
        }
        var lookaheadTime = currentTime + lookahead;
        var skipCount = 0;
        while (startTime < lookaheadTime) {
            if (bufCursor >= src.bufQueue.length) {
                if (src.looping) {
                    bufCursor %= src.bufQueue.length
                } else {
                    break
                }
            }
            var buf = src.bufQueue[bufCursor % src.bufQueue.length];
            if (buf.length === 0) {
                skipCount++;
                if (skipCount === src.bufQueue.length) {
                    break
                }
            } else {
                var audioSrc = src.context.audioCtx.createBufferSource();
                audioSrc.buffer = buf.audioBuf;
                audioSrc.playbackRate.value = src.playbackRate;
                if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
                    audioSrc.loopStart = buf.audioBuf._loopStart;
                    audioSrc.loopEnd = buf.audioBuf._loopEnd
                }
                var duration = 0;
                if (src.type === 4136 && src.looping) {
                    duration = Number.POSITIVE_INFINITY;
                    audioSrc.loop = true;
                    if (buf.audioBuf._loopStart) {
                        audioSrc.loopStart = buf.audioBuf._loopStart
                    }
                    if (buf.audioBuf._loopEnd) {
                        audioSrc.loopEnd = buf.audioBuf._loopEnd
                    }
                } else {
                    duration = (buf.audioBuf.duration - startOffset) / src.playbackRate
                }
                audioSrc._startOffset = startOffset;
                audioSrc._duration = duration;
                audioSrc._skipCount = skipCount;
                skipCount = 0;
                audioSrc.connect(src.gain);
                if (typeof audioSrc.start != "undefined") {
                    startTime = Math.max(startTime, src.context.audioCtx.currentTime);
                    audioSrc.start(startTime, startOffset)
                } else if (typeof audioSrc.noteOn != "undefined") {
                    startTime = Math.max(startTime, src.context.audioCtx.currentTime);
                    audioSrc.noteOn(startTime)
                }
                audioSrc._startTime = startTime;
                src.audioQueue.push(audioSrc);
                startTime += duration
            }
            startOffset = 0;
            bufCursor++
        }
    },
    updateSourceTime: src => {
        var currentTime = src.context.audioCtx.currentTime;
        if (src.state !== 4114) {
            return currentTime
        }
        if (!isFinite(src.bufStartTime)) {
            src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
            src.bufOffset = 0
        }
        var nextStartTime = 0;
        while (src.audioQueue.length) {
            var audioSrc = src.audioQueue[0];
            src.bufsProcessed += audioSrc._skipCount;
            nextStartTime = audioSrc._startTime + audioSrc._duration;
            if (currentTime < nextStartTime) {
                break
            }
            src.audioQueue.shift();
            src.bufStartTime = nextStartTime;
            src.bufOffset = 0;
            src.bufsProcessed++
        }
        if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
            AL.setSourceState(src, 4116)
        } else if (src.type === 4136 && src.looping) {
            var buf = src.bufQueue[0];
            if (buf.length === 0) {
                src.bufOffset = 0
            } else {
                var delta = (currentTime - src.bufStartTime) * src.playbackRate;
                var loopStart = buf.audioBuf._loopStart || 0;
                var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
                if (loopEnd <= loopStart) {
                    loopEnd = buf.audioBuf.duration
                }
                if (delta < loopEnd) {
                    src.bufOffset = delta
                } else {
                    src.bufOffset = loopStart + (delta - loopStart) % (loopEnd - loopStart)
                }
            }
        } else if (src.audioQueue[0]) {
            src.bufOffset = (currentTime - src.audioQueue[0]._startTime) * src.playbackRate
        } else {
            if (src.type !== 4136 && src.looping) {
                var srcDuration = AL.sourceDuration(src) / src.playbackRate;
                if (srcDuration > 0) {
                    src.bufStartTime += Math.floor((currentTime - src.bufStartTime) / srcDuration) * srcDuration
                }
            }
            for (var i = 0; i < src.bufQueue.length; i++) {
                if (src.bufsProcessed >= src.bufQueue.length) {
                    if (src.looping) {
                        src.bufsProcessed %= src.bufQueue.length
                    } else {
                        AL.setSourceState(src, 4116);
                        break
                    }
                }
                var buf = src.bufQueue[src.bufsProcessed];
                if (buf.length > 0) {
                    nextStartTime = src.bufStartTime + buf.audioBuf.duration / src.playbackRate;
                    if (currentTime < nextStartTime) {
                        src.bufOffset = (currentTime - src.bufStartTime) * src.playbackRate;
                        break
                    }
                    src.bufStartTime = nextStartTime
                }
                src.bufOffset = 0;
                src.bufsProcessed++
            }
        }
        return currentTime
    },
    cancelPendingSourceAudio: src => {
        AL.updateSourceTime(src);
        for (var i = 1; i < src.audioQueue.length; i++) {
            var audioSrc = src.audioQueue[i];
            audioSrc.stop()
        }
        if (src.audioQueue.length > 1) {
            src.audioQueue.length = 1
        }
    },
    stopSourceAudio: src => {
        for (var i = 0; i < src.audioQueue.length; i++) {
            src.audioQueue[i].stop()
        }
        src.audioQueue.length = 0
    },
    setSourceState: (src, state) => {
        if (state === 4114) {
            if (src.state === 4114 || src.state == 4116) {
                src.bufsProcessed = 0;
                src.bufOffset = 0
            } else {}
            AL.stopSourceAudio(src);
            src.state = 4114;
            src.bufStartTime = Number.NEGATIVE_INFINITY;
            AL.scheduleSourceAudio(src)
        } else if (state === 4115) {
            if (src.state === 4114) {
                AL.updateSourceTime(src);
                AL.stopSourceAudio(src);
                src.state = 4115
            }
        } else if (state === 4116) {
            if (src.state !== 4113) {
                src.state = 4116;
                src.bufsProcessed = src.bufQueue.length;
                src.bufStartTime = Number.NEGATIVE_INFINITY;
                src.bufOffset = 0;
                AL.stopSourceAudio(src)
            }
        } else if (state === 4113) {
            if (src.state !== 4113) {
                src.state = 4113;
                src.bufsProcessed = 0;
                src.bufStartTime = Number.NEGATIVE_INFINITY;
                src.bufOffset = 0;
                AL.stopSourceAudio(src)
            }
        }
    },
    initSourcePanner: src => {
        if (src.type === 4144) {
            return
        }
        var templateBuf = AL.buffers[0];
        for (var i = 0; i < src.bufQueue.length; i++) {
            if (src.bufQueue[i].id !== 0) {
                templateBuf = src.bufQueue[i];
                break
            }
        }
        if (src.spatialize === 1 || src.spatialize === 2 && templateBuf.channels === 1) {
            if (src.panner) {
                return
            }
            src.panner = src.context.audioCtx.createPanner();
            AL.updateSourceGlobal(src);
            AL.updateSourceSpace(src);
            src.panner.connect(src.context.gain);
            src.gain.disconnect();
            src.gain.connect(src.panner)
        } else {
            if (!src.panner) {
                return
            }
            src.panner.disconnect();
            src.gain.disconnect();
            src.gain.connect(src.context.gain);
            src.panner = null
        }
    },
    updateContextGlobal: ctx => {
        for (var i in ctx.sources) {
            AL.updateSourceGlobal(ctx.sources[i])
        }
    },
    updateSourceGlobal: src => {
        var panner = src.panner;
        if (!panner) {
            return
        }
        panner.refDistance = src.refDistance;
        panner.maxDistance = src.maxDistance;
        panner.rolloffFactor = src.rolloffFactor;
        panner.panningModel = src.context.hrtf ? "HRTF" : "equalpower";
        var distanceModel = src.context.sourceDistanceModel ? src.distanceModel : src.context.distanceModel;
        switch (distanceModel) {
            case 0:
                panner.distanceModel = "inverse";
                panner.refDistance = 340282e33;
                break;
            case 53249:
            case 53250:
                panner.distanceModel = "inverse";
                break;
            case 53251:
            case 53252:
                panner.distanceModel = "linear";
                break;
            case 53253:
            case 53254:
                panner.distanceModel = "exponential";
                break
        }
    },
    updateListenerSpace: ctx => {
        var listener = ctx.audioCtx.listener;
        if (listener.positionX) {
            listener.positionX.value = ctx.listener.position[0];
            listener.positionY.value = ctx.listener.position[1];
            listener.positionZ.value = ctx.listener.position[2]
        } else {
            listener.setPosition(ctx.listener.position[0], ctx.listener.position[1], ctx.listener.position[2])
        }
        if (listener.forwardX) {
            listener.forwardX.value = ctx.listener.direction[0];
            listener.forwardY.value = ctx.listener.direction[1];
            listener.forwardZ.value = ctx.listener.direction[2];
            listener.upX.value = ctx.listener.up[0];
            listener.upY.value = ctx.listener.up[1];
            listener.upZ.value = ctx.listener.up[2]
        } else {
            listener.setOrientation(ctx.listener.direction[0], ctx.listener.direction[1], ctx.listener.direction[2], ctx.listener.up[0], ctx.listener.up[1], ctx.listener.up[2])
        }
        for (var i in ctx.sources) {
            AL.updateSourceSpace(ctx.sources[i])
        }
    },
    updateSourceSpace: src => {
        if (!src.panner) {
            return
        }
        var panner = src.panner;
        var posX = src.position[0];
        var posY = src.position[1];
        var posZ = src.position[2];
        var dirX = src.direction[0];
        var dirY = src.direction[1];
        var dirZ = src.direction[2];
        var listener = src.context.listener;
        var lPosX = listener.position[0];
        var lPosY = listener.position[1];
        var lPosZ = listener.position[2];
        if (src.relative) {
            var lBackX = -listener.direction[0];
            var lBackY = -listener.direction[1];
            var lBackZ = -listener.direction[2];
            var lUpX = listener.up[0];
            var lUpY = listener.up[1];
            var lUpZ = listener.up[2];
            var inverseMagnitude = (x, y, z) => {
                var length = Math.sqrt(x * x + y * y + z * z);
                if (length < Number.EPSILON) {
                    return 0
                }
                return 1 / length
            };
            var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
            lBackX *= invMag;
            lBackY *= invMag;
            lBackZ *= invMag;
            invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
            lUpX *= invMag;
            lUpY *= invMag;
            lUpZ *= invMag;
            var lRightX = lUpY * lBackZ - lUpZ * lBackY;
            var lRightY = lUpZ * lBackX - lUpX * lBackZ;
            var lRightZ = lUpX * lBackY - lUpY * lBackX;
            invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
            lRightX *= invMag;
            lRightY *= invMag;
            lRightZ *= invMag;
            lUpX = lBackY * lRightZ - lBackZ * lRightY;
            lUpY = lBackZ * lRightX - lBackX * lRightZ;
            lUpZ = lBackX * lRightY - lBackY * lRightX;
            var oldX = dirX;
            var oldY = dirY;
            var oldZ = dirZ;
            dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
            dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
            dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
            oldX = posX;
            oldY = posY;
            oldZ = posZ;
            posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
            posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
            posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
            posX += lPosX;
            posY += lPosY;
            posZ += lPosZ
        }
        if (panner.positionX) {
            if (posX != panner.positionX.value) panner.positionX.value = posX;
            if (posY != panner.positionY.value) panner.positionY.value = posY;
            if (posZ != panner.positionZ.value) panner.positionZ.value = posZ
        } else {
            panner.setPosition(posX, posY, posZ)
        }
        if (panner.orientationX) {
            if (dirX != panner.orientationX.value) panner.orientationX.value = dirX;
            if (dirY != panner.orientationY.value) panner.orientationY.value = dirY;
            if (dirZ != panner.orientationZ.value) panner.orientationZ.value = dirZ
        } else {
            panner.setOrientation(dirX, dirY, dirZ)
        }
        var oldShift = src.dopplerShift;
        var velX = src.velocity[0];
        var velY = src.velocity[1];
        var velZ = src.velocity[2];
        var lVelX = listener.velocity[0];
        var lVelY = listener.velocity[1];
        var lVelZ = listener.velocity[2];
        if (posX === lPosX && posY === lPosY && posZ === lPosZ || velX === lVelX && velY === lVelY && velZ === lVelZ) {
            src.dopplerShift = 1
        } else {
            var speedOfSound = src.context.speedOfSound;
            var dopplerFactor = src.context.dopplerFactor;
            var slX = lPosX - posX;
            var slY = lPosY - posY;
            var slZ = lPosZ - posZ;
            var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
            var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
            var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;
            vls = Math.min(vls, speedOfSound / dopplerFactor);
            vss = Math.min(vss, speedOfSound / dopplerFactor);
            src.dopplerShift = (speedOfSound - dopplerFactor * vls) / (speedOfSound - dopplerFactor * vss)
        }
        if (src.dopplerShift !== oldShift) {
            AL.updateSourceRate(src)
        }
    },
    updateSourceRate: src => {
        if (src.state === 4114) {
            AL.cancelPendingSourceAudio(src);
            var audioSrc = src.audioQueue[0];
            if (!audioSrc) {
                return
            }
            var duration;
            if (src.type === 4136 && src.looping) {
                duration = Number.POSITIVE_INFINITY
            } else {
                duration = (audioSrc.buffer.duration - audioSrc._startOffset) / src.playbackRate
            }
            audioSrc._duration = duration;
            audioSrc.playbackRate.value = src.playbackRate;
            AL.scheduleSourceAudio(src)
        }
    },
    sourceDuration: src => {
        var length = 0;
        for (var i = 0; i < src.bufQueue.length; i++) {
            var audioBuf = src.bufQueue[i].audioBuf;
            length += audioBuf ? audioBuf.duration : 0
        }
        return length
    },
    sourceTell: src => {
        AL.updateSourceTime(src);
        var offset = 0;
        for (var i = 0; i < src.bufsProcessed; i++) {
            if (src.bufQueue[i].audioBuf) {
                offset += src.bufQueue[i].audioBuf.duration
            }
        }
        offset += src.bufOffset;
        return offset
    },
    sourceSeek: (src, offset) => {
        var playing = src.state == 4114;
        if (playing) {
            AL.setSourceState(src, 4113)
        }
        if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
            src.bufsProcessed = 0;
            while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
                offset -= src.bufQueue[src.bufsProcessed].audioBuf.duration;
                src.bufsProcessed++
            }
            src.bufOffset = offset
        }
        if (playing) {
            AL.setSourceState(src, 4114)
        }
    },
    getGlobalParam: (funcname, param) => {
        if (!AL.currentCtx) {
            return null
        }
        switch (param) {
            case 49152:
                return AL.currentCtx.dopplerFactor;
            case 49155:
                return AL.currentCtx.speedOfSound;
            case 53248:
                return AL.currentCtx.distanceModel;
            default:
                AL.currentCtx.err = 40962;
                return null
        }
    },
    setGlobalParam: (funcname, param, value) => {
        if (!AL.currentCtx) {
            return
        }
        switch (param) {
            case 49152:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.currentCtx.dopplerFactor = value;
                AL.updateListenerSpace(AL.currentCtx);
                break;
            case 49155:
                if (!Number.isFinite(value) || value <= 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.currentCtx.speedOfSound = value;
                AL.updateListenerSpace(AL.currentCtx);
                break;
            case 53248:
                switch (value) {
                    case 0:
                    case 53249:
                    case 53250:
                    case 53251:
                    case 53252:
                    case 53253:
                    case 53254:
                        AL.currentCtx.distanceModel = value;
                        AL.updateContextGlobal(AL.currentCtx);
                        break;
                    default:
                        AL.currentCtx.err = 40963;
                        return
                }
                break;
            default:
                AL.currentCtx.err = 40962;
                return
        }
    },
    getListenerParam: (funcname, param) => {
        if (!AL.currentCtx) {
            return null
        }
        switch (param) {
            case 4100:
                return AL.currentCtx.listener.position;
            case 4102:
                return AL.currentCtx.listener.velocity;
            case 4111:
                return AL.currentCtx.listener.direction.concat(AL.currentCtx.listener.up);
            case 4106:
                return AL.currentCtx.gain.gain.value;
            default:
                AL.currentCtx.err = 40962;
                return null
        }
    },
    setListenerParam: (funcname, param, value) => {
        if (!AL.currentCtx) {
            return
        }
        if (value === null) {
            AL.currentCtx.err = 40962;
            return
        }
        var listener = AL.currentCtx.listener;
        switch (param) {
            case 4100:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                listener.position[0] = value[0];
                listener.position[1] = value[1];
                listener.position[2] = value[2];
                AL.updateListenerSpace(AL.currentCtx);
                break;
            case 4102:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                listener.velocity[0] = value[0];
                listener.velocity[1] = value[1];
                listener.velocity[2] = value[2];
                AL.updateListenerSpace(AL.currentCtx);
                break;
            case 4106:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.currentCtx.gain.gain.value = value;
                break;
            case 4111:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2]) || !Number.isFinite(value[3]) || !Number.isFinite(value[4]) || !Number.isFinite(value[5])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                listener.direction[0] = value[0];
                listener.direction[1] = value[1];
                listener.direction[2] = value[2];
                listener.up[0] = value[3];
                listener.up[1] = value[4];
                listener.up[2] = value[5];
                AL.updateListenerSpace(AL.currentCtx);
                break;
            default:
                AL.currentCtx.err = 40962;
                return
        }
    },
    getBufferParam: (funcname, bufferId, param) => {
        if (!AL.currentCtx) {
            return
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
            AL.currentCtx.err = 40961;
            return
        }
        switch (param) {
            case 8193:
                return buf.frequency;
            case 8194:
                return buf.bytesPerSample * 8;
            case 8195:
                return buf.channels;
            case 8196:
                return buf.length * buf.bytesPerSample * buf.channels;
            case 8213:
                if (buf.length === 0) {
                    return [0, 0]
                }
                return [(buf.audioBuf._loopStart || 0) * buf.frequency, (buf.audioBuf._loopEnd || buf.length) * buf.frequency];
            default:
                AL.currentCtx.err = 40962;
                return null
        }
    },
    setBufferParam: (funcname, bufferId, param, value) => {
        if (!AL.currentCtx) {
            return
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
            AL.currentCtx.err = 40961;
            return
        }
        if (value === null) {
            AL.currentCtx.err = 40962;
            return
        }
        switch (param) {
            case 8196:
                if (value !== 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                break;
            case 8213:
                if (value[0] < 0 || value[0] > buf.length || value[1] < 0 || value[1] > buf.Length || value[0] >= value[1]) {
                    AL.currentCtx.err = 40963;
                    return
                }
                if (buf.refCount > 0) {
                    AL.currentCtx.err = 40964;
                    return
                }
                if (buf.audioBuf) {
                    buf.audioBuf._loopStart = value[0] / buf.frequency;
                    buf.audioBuf._loopEnd = value[1] / buf.frequency
                }
                break;
            default:
                AL.currentCtx.err = 40962;
                return
        }
    },
    getSourceParam: (funcname, sourceId, param) => {
        if (!AL.currentCtx) {
            return null
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
            AL.currentCtx.err = 40961;
            return null
        }
        switch (param) {
            case 514:
                return src.relative;
            case 4097:
                return src.coneInnerAngle;
            case 4098:
                return src.coneOuterAngle;
            case 4099:
                return src.pitch;
            case 4100:
                return src.position;
            case 4101:
                return src.direction;
            case 4102:
                return src.velocity;
            case 4103:
                return src.looping;
            case 4105:
                if (src.type === 4136) {
                    return src.bufQueue[0].id
                }
                return 0;
            case 4106:
                return src.gain.gain.value;
            case 4109:
                return src.minGain;
            case 4110:
                return src.maxGain;
            case 4112:
                return src.state;
            case 4117:
                if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
                    return 0
                }
                return src.bufQueue.length;
            case 4118:
                if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 || src.looping) {
                    return 0
                }
                return src.bufsProcessed;
            case 4128:
                return src.refDistance;
            case 4129:
                return src.rolloffFactor;
            case 4130:
                return src.coneOuterGain;
            case 4131:
                return src.maxDistance;
            case 4132:
                return AL.sourceTell(src);
            case 4133:
                var offset = AL.sourceTell(src);
                if (offset > 0) {
                    offset *= src.bufQueue[0].frequency
                }
                return offset;
            case 4134:
                var offset = AL.sourceTell(src);
                if (offset > 0) {
                    offset *= src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample
                }
                return offset;
            case 4135:
                return src.type;
            case 4628:
                return src.spatialize;
            case 8201:
                var length = 0;
                var bytesPerFrame = 0;
                for (var i = 0; i < src.bufQueue.length; i++) {
                    length += src.bufQueue[i].length;
                    if (src.bufQueue[i].id !== 0) {
                        bytesPerFrame = src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels
                    }
                }
                return length * bytesPerFrame;
            case 8202:
                var length = 0;
                for (var i = 0; i < src.bufQueue.length; i++) {
                    length += src.bufQueue[i].length
                }
                return length;
            case 8203:
                return AL.sourceDuration(src);
            case 53248:
                return src.distanceModel;
            default:
                AL.currentCtx.err = 40962;
                return null
        }
    },
    setSourceParam: (funcname, sourceId, param, value) => {
        if (!AL.currentCtx) {
            return
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
            AL.currentCtx.err = 40961;
            return
        }
        if (value === null) {
            AL.currentCtx.err = 40962;
            return
        }
        switch (param) {
            case 514:
                if (value === 1) {
                    src.relative = true;
                    AL.updateSourceSpace(src)
                } else if (value === 0) {
                    src.relative = false;
                    AL.updateSourceSpace(src)
                } else {
                    AL.currentCtx.err = 40963;
                    return
                }
                break;
            case 4097:
                if (!Number.isFinite(value)) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.coneInnerAngle = value;
                if (src.panner) {
                    src.panner.coneInnerAngle = value % 360
                }
                break;
            case 4098:
                if (!Number.isFinite(value)) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.coneOuterAngle = value;
                if (src.panner) {
                    src.panner.coneOuterAngle = value % 360
                }
                break;
            case 4099:
                if (!Number.isFinite(value) || value <= 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                if (src.pitch === value) {
                    break
                }
                src.pitch = value;
                AL.updateSourceRate(src);
                break;
            case 4100:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.position[0] = value[0];
                src.position[1] = value[1];
                src.position[2] = value[2];
                AL.updateSourceSpace(src);
                break;
            case 4101:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.direction[0] = value[0];
                src.direction[1] = value[1];
                src.direction[2] = value[2];
                AL.updateSourceSpace(src);
                break;
            case 4102:
                if (!Number.isFinite(value[0]) || !Number.isFinite(value[1]) || !Number.isFinite(value[2])) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.velocity[0] = value[0];
                src.velocity[1] = value[1];
                src.velocity[2] = value[2];
                AL.updateSourceSpace(src);
                break;
            case 4103:
                if (value === 1) {
                    src.looping = true;
                    AL.updateSourceTime(src);
                    if (src.type === 4136 && src.audioQueue.length > 0) {
                        var audioSrc = src.audioQueue[0];
                        audioSrc.loop = true;
                        audioSrc._duration = Number.POSITIVE_INFINITY
                    }
                } else if (value === 0) {
                    src.looping = false;
                    var currentTime = AL.updateSourceTime(src);
                    if (src.type === 4136 && src.audioQueue.length > 0) {
                        var audioSrc = src.audioQueue[0];
                        audioSrc.loop = false;
                        audioSrc._duration = src.bufQueue[0].audioBuf.duration / src.playbackRate;
                        audioSrc._startTime = currentTime - src.bufOffset / src.playbackRate
                    }
                } else {
                    AL.currentCtx.err = 40963;
                    return
                }
                break;
            case 4105:
                if (src.state === 4114 || src.state === 4115) {
                    AL.currentCtx.err = 40964;
                    return
                }
                if (value === 0) {
                    for (var i in src.bufQueue) {
                        src.bufQueue[i].refCount--
                    }
                    src.bufQueue.length = 1;
                    src.bufQueue[0] = AL.buffers[0];
                    src.bufsProcessed = 0;
                    src.type = 4144
                } else {
                    var buf = AL.buffers[value];
                    if (!buf) {
                        AL.currentCtx.err = 40963;
                        return
                    }
                    for (var i in src.bufQueue) {
                        src.bufQueue[i].refCount--
                    }
                    src.bufQueue.length = 0;
                    buf.refCount++;
                    src.bufQueue = [buf];
                    src.bufsProcessed = 0;
                    src.type = 4136
                }
                AL.initSourcePanner(src);
                AL.scheduleSourceAudio(src);
                break;
            case 4106:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.gain.gain.value = value;
                break;
            case 4109:
                if (!Number.isFinite(value) || value < 0 || value > Math.min(src.maxGain, 1)) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.minGain = value;
                break;
            case 4110:
                if (!Number.isFinite(value) || value < Math.max(0, src.minGain) || value > 1) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.maxGain = value;
                break;
            case 4128:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.refDistance = value;
                if (src.panner) {
                    src.panner.refDistance = value
                }
                break;
            case 4129:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.rolloffFactor = value;
                if (src.panner) {
                    src.panner.rolloffFactor = value
                }
                break;
            case 4130:
                if (!Number.isFinite(value) || value < 0 || value > 1) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.coneOuterGain = value;
                if (src.panner) {
                    src.panner.coneOuterGain = value
                }
                break;
            case 4131:
                if (!Number.isFinite(value) || value < 0) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.maxDistance = value;
                if (src.panner) {
                    src.panner.maxDistance = value
                }
                break;
            case 4132:
                if (value < 0 || value > AL.sourceDuration(src)) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.sourceSeek(src, value);
                break;
            case 4133:
                var srcLen = AL.sourceDuration(src);
                if (srcLen > 0) {
                    var frequency;
                    for (var bufId in src.bufQueue) {
                        if (bufId) {
                            frequency = src.bufQueue[bufId].frequency;
                            break
                        }
                    }
                    value /= frequency
                }
                if (value < 0 || value > srcLen) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.sourceSeek(src, value);
                break;
            case 4134:
                var srcLen = AL.sourceDuration(src);
                if (srcLen > 0) {
                    var bytesPerSec;
                    for (var bufId in src.bufQueue) {
                        if (bufId) {
                            var buf = src.bufQueue[bufId];
                            bytesPerSec = buf.frequency * buf.bytesPerSample * buf.channels;
                            break
                        }
                    }
                    value /= bytesPerSec
                }
                if (value < 0 || value > srcLen) {
                    AL.currentCtx.err = 40963;
                    return
                }
                AL.sourceSeek(src, value);
                break;
            case 4628:
                if (value !== 0 && value !== 1 && value !== 2) {
                    AL.currentCtx.err = 40963;
                    return
                }
                src.spatialize = value;
                AL.initSourcePanner(src);
                break;
            case 8201:
            case 8202:
            case 8203:
                AL.currentCtx.err = 40964;
                break;
            case 53248:
                switch (value) {
                    case 0:
                    case 53249:
                    case 53250:
                    case 53251:
                    case 53252:
                    case 53253:
                    case 53254:
                        src.distanceModel = value;
                        if (AL.currentCtx.sourceDistanceModel) {
                            AL.updateContextGlobal(AL.currentCtx)
                        }
                        break;
                    default:
                        AL.currentCtx.err = 40963;
                        return
                }
                break;
            default:
                AL.currentCtx.err = 40962;
                return
        }
    },
    captures: {},
    sharedCaptureAudioCtx: null,
    requireValidCaptureDevice: (deviceId, funcname) => {
        if (deviceId === 0) {
            AL.alcErr = 40961;
            return null
        }
        var c = AL.captures[deviceId];
        if (!c) {
            AL.alcErr = 40961;
            return null
        }
        var err = c.mediaStreamError;
        if (err) {
            AL.alcErr = 40961;
            return null
        }
        return c
    }
};
var _alBuffer3f = (bufferId, param, value0, value1, value2) => {
    AL.setBufferParam("alBuffer3f", bufferId, param, null)
};
var _alBuffer3i = (bufferId, param, value0, value1, value2) => {
    AL.setBufferParam("alBuffer3i", bufferId, param, null)
};
var _alBufferData = (bufferId, format, pData, size, freq) => {
    if (!AL.currentCtx) {
        return
    }
    var buf = AL.buffers[bufferId];
    if (!buf) {
        AL.currentCtx.err = 40963;
        return
    }
    if (freq <= 0) {
        AL.currentCtx.err = 40963;
        return
    }
    var audioBuf = null;
    try {
        switch (format) {
            case 4352:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    for (var i = 0; i < size; ++i) {
                        channel0[i] = HEAPU8[pData++] * .0078125 - 1
                    }
                }
                buf.bytesPerSample = 1;
                buf.channels = 1;
                buf.length = size;
                break;
            case 4353:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 1, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    pData >>= 1;
                    for (var i = 0; i < size >> 1; ++i) {
                        channel0[i] = HEAP16[pData++] * 30517578125e-15
                    }
                }
                buf.bytesPerSample = 2;
                buf.channels = 1;
                buf.length = size >> 1;
                break;
            case 4354:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 1, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    var channel1 = audioBuf.getChannelData(1);
                    for (var i = 0; i < size >> 1; ++i) {
                        channel0[i] = HEAPU8[pData++] * .0078125 - 1;
                        channel1[i] = HEAPU8[pData++] * .0078125 - 1
                    }
                }
                buf.bytesPerSample = 1;
                buf.channels = 2;
                buf.length = size >> 1;
                break;
            case 4355:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 2, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    var channel1 = audioBuf.getChannelData(1);
                    pData >>= 1;
                    for (var i = 0; i < size >> 2; ++i) {
                        channel0[i] = HEAP16[pData++] * 30517578125e-15;
                        channel1[i] = HEAP16[pData++] * 30517578125e-15
                    }
                }
                buf.bytesPerSample = 2;
                buf.channels = 2;
                buf.length = size >> 2;
                break;
            case 65552:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size >> 2, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    pData >>= 2;
                    for (var i = 0; i < size >> 2; ++i) {
                        channel0[i] = HEAPF32[pData++]
                    }
                }
                buf.bytesPerSample = 4;
                buf.channels = 1;
                buf.length = size >> 2;
                break;
            case 65553:
                if (size > 0) {
                    audioBuf = AL.currentCtx.audioCtx.createBuffer(2, size >> 3, freq);
                    var channel0 = audioBuf.getChannelData(0);
                    var channel1 = audioBuf.getChannelData(1);
                    pData >>= 2;
                    for (var i = 0; i < size >> 3; ++i) {
                        channel0[i] = HEAPF32[pData++];
                        channel1[i] = HEAPF32[pData++]
                    }
                }
                buf.bytesPerSample = 4;
                buf.channels = 2;
                buf.length = size >> 3;
                break;
            default:
                AL.currentCtx.err = 40963;
                return
        }
        buf.frequency = freq;
        buf.audioBuf = audioBuf
    } catch (e) {
        AL.currentCtx.err = 40963;
        return
    }
};
var _alBufferf = (bufferId, param, value) => {
    AL.setBufferParam("alBufferf", bufferId, param, null)
};
var _alBufferfv = (bufferId, param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.setBufferParam("alBufferfv", bufferId, param, null)
};
var _alBufferi = (bufferId, param, value) => {
    AL.setBufferParam("alBufferi", bufferId, param, null)
};
var _alBufferiv = (bufferId, param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 8213:
            AL.paramArray[0] = HEAP32[pValues >> 2];
            AL.paramArray[1] = HEAP32[pValues + 4 >> 2];
            AL.setBufferParam("alBufferiv", bufferId, param, AL.paramArray);
            break;
        default:
            AL.setBufferParam("alBufferiv", bufferId, param, null);
            break
    }
};
var _alDeleteBuffers = (count, pBufferIds) => {
    if (!AL.currentCtx) {
        return
    }
    for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[pBufferIds + i * 4 >> 2];
        if (bufId === 0) {
            continue
        }
        if (!AL.buffers[bufId]) {
            AL.currentCtx.err = 40961;
            return
        }
        if (AL.buffers[bufId].refCount) {
            AL.currentCtx.err = 40964;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[pBufferIds + i * 4 >> 2];
        if (bufId === 0) {
            continue
        }
        AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
        delete AL.buffers[bufId];
        AL.freeIds.push(bufId)
    }
};
var _alSourcei = (sourceId, param, value) => {
    switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
            AL.setSourceParam("alSourcei", sourceId, param, value);
            break;
        default:
            AL.setSourceParam("alSourcei", sourceId, param, null);
            break
    }
};
var _alDeleteSources = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        if (!AL.currentCtx.sources[srcId]) {
            AL.currentCtx.err = 40961;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4116);
        _alSourcei(srcId, 4105, 0);
        delete AL.currentCtx.sources[srcId];
        AL.freeIds.push(srcId)
    }
};
var _alDisable = param => {
    if (!AL.currentCtx) {
        return
    }
    switch (param) {
        case 512:
            AL.currentCtx.sourceDistanceModel = false;
            AL.updateContextGlobal(AL.currentCtx);
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alDistanceModel = model => {
    AL.setGlobalParam("alDistanceModel", 53248, model)
};
var _alDopplerFactor = value => {
    AL.setGlobalParam("alDopplerFactor", 49152, value)
};
var _alDopplerVelocity = value => {
    warnOnce("alDopplerVelocity() is deprecated, and only kept for compatibility with OpenAL 1.0. Use alSpeedOfSound() instead.");
    if (!AL.currentCtx) {
        return
    }
    if (value <= 0) {
        AL.currentCtx.err = 40963;
        return
    }
};
var _alEnable = param => {
    if (!AL.currentCtx) {
        return
    }
    switch (param) {
        case 512:
            AL.currentCtx.sourceDistanceModel = true;
            AL.updateContextGlobal(AL.currentCtx);
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGenBuffers = (count, pBufferIds) => {
    if (!AL.currentCtx) {
        return
    }
    for (var i = 0; i < count; ++i) {
        var buf = {
            deviceId: AL.currentCtx.deviceId,
            id: AL.newId(),
            refCount: 0,
            audioBuf: null,
            frequency: 0,
            bytesPerSample: 2,
            channels: 1,
            length: 0
        };
        AL.deviceRefCounts[buf.deviceId]++;
        AL.buffers[buf.id] = buf;
        HEAP32[pBufferIds + i * 4 >> 2] = buf.id
    }
};
var _alGenSources = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    for (var i = 0; i < count; ++i) {
        var gain = AL.currentCtx.audioCtx.createGain();
        gain.connect(AL.currentCtx.gain);
        var src = {
            context: AL.currentCtx,
            id: AL.newId(),
            type: 4144,
            state: 4113,
            bufQueue: [AL.buffers[0]],
            audioQueue: [],
            looping: false,
            pitch: 1,
            dopplerShift: 1,
            gain,
            minGain: 0,
            maxGain: 1,
            panner: null,
            bufsProcessed: 0,
            bufStartTime: Number.NEGATIVE_INFINITY,
            bufOffset: 0,
            relative: false,
            refDistance: 1,
            maxDistance: 340282e33,
            rolloffFactor: 1,
            position: [0, 0, 0],
            velocity: [0, 0, 0],
            direction: [0, 0, 0],
            coneOuterGain: 0,
            coneInnerAngle: 360,
            coneOuterAngle: 360,
            distanceModel: 53250,
            spatialize: 2,
            get playbackRate() {
                return this.pitch * this.dopplerShift
            }
        };
        AL.currentCtx.sources[src.id] = src;
        HEAP32[pSourceIds + i * 4 >> 2] = src.id
    }
};
var _alGetBoolean = param => {
    var val = AL.getGlobalParam("alGetBoolean", param);
    if (val === null) {
        return 0
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            return val !== 0 ? 1 : 0;
        default:
            AL.currentCtx.err = 40962;
            return 0
    }
};
var _alGetBooleanv = (param, pValues) => {
    var val = AL.getGlobalParam("alGetBooleanv", param);
    if (val === null || !pValues) {
        return
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            HEAP8[pValues] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetBuffer3f = (bufferId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getBufferParam("alGetBuffer3f", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.currentCtx.err = 40962
};
var _alGetBuffer3i = (bufferId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getBufferParam("alGetBuffer3i", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.currentCtx.err = 40962
};
var _alGetBufferf = (bufferId, param, pValue) => {
    var val = AL.getBufferParam("alGetBufferf", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.currentCtx.err = 40962
};
var _alGetBufferfv = (bufferId, param, pValues) => {
    var val = AL.getBufferParam("alGetBufferfv", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.currentCtx.err = 40962
};
var _alGetBufferi = (bufferId, param, pValue) => {
    var val = AL.getBufferParam("alGetBufferi", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 8193:
        case 8194:
        case 8195:
        case 8196:
            HEAP32[pValue >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetBufferiv = (bufferId, param, pValues) => {
    var val = AL.getBufferParam("alGetBufferiv", bufferId, param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 8193:
        case 8194:
        case 8195:
        case 8196:
            HEAP32[pValues >> 2] = val;
            break;
        case 8213:
            HEAP32[pValues >> 2] = val[0];
            HEAP32[pValues + 4 >> 2] = val[1];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetDouble = param => {
    var val = AL.getGlobalParam("alGetDouble", param);
    if (val === null) {
        return 0
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            return val;
        default:
            AL.currentCtx.err = 40962;
            return 0
    }
};
var _alGetDoublev = (param, pValues) => {
    var val = AL.getGlobalParam("alGetDoublev", param);
    if (val === null || !pValues) {
        return
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            HEAPF64[pValues >> 3] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetEnumValue = pEnumName => {
    if (!AL.currentCtx) {
        return 0
    }
    if (!pEnumName) {
        AL.currentCtx.err = 40963;
        return 0
    }
    var name = UTF8ToString(pEnumName);
    switch (name) {
        case "AL_BITS":
            return 8194;
        case "AL_BUFFER":
            return 4105;
        case "AL_BUFFERS_PROCESSED":
            return 4118;
        case "AL_BUFFERS_QUEUED":
            return 4117;
        case "AL_BYTE_OFFSET":
            return 4134;
        case "AL_CHANNELS":
            return 8195;
        case "AL_CONE_INNER_ANGLE":
            return 4097;
        case "AL_CONE_OUTER_ANGLE":
            return 4098;
        case "AL_CONE_OUTER_GAIN":
            return 4130;
        case "AL_DIRECTION":
            return 4101;
        case "AL_DISTANCE_MODEL":
            return 53248;
        case "AL_DOPPLER_FACTOR":
            return 49152;
        case "AL_DOPPLER_VELOCITY":
            return 49153;
        case "AL_EXPONENT_DISTANCE":
            return 53253;
        case "AL_EXPONENT_DISTANCE_CLAMPED":
            return 53254;
        case "AL_EXTENSIONS":
            return 45060;
        case "AL_FORMAT_MONO16":
            return 4353;
        case "AL_FORMAT_MONO8":
            return 4352;
        case "AL_FORMAT_STEREO16":
            return 4355;
        case "AL_FORMAT_STEREO8":
            return 4354;
        case "AL_FREQUENCY":
            return 8193;
        case "AL_GAIN":
            return 4106;
        case "AL_INITIAL":
            return 4113;
        case "AL_INVALID":
            return -1;
        case "AL_ILLEGAL_ENUM":
        case "AL_INVALID_ENUM":
            return 40962;
        case "AL_INVALID_NAME":
            return 40961;
        case "AL_ILLEGAL_COMMAND":
        case "AL_INVALID_OPERATION":
            return 40964;
        case "AL_INVALID_VALUE":
            return 40963;
        case "AL_INVERSE_DISTANCE":
            return 53249;
        case "AL_INVERSE_DISTANCE_CLAMPED":
            return 53250;
        case "AL_LINEAR_DISTANCE":
            return 53251;
        case "AL_LINEAR_DISTANCE_CLAMPED":
            return 53252;
        case "AL_LOOPING":
            return 4103;
        case "AL_MAX_DISTANCE":
            return 4131;
        case "AL_MAX_GAIN":
            return 4110;
        case "AL_MIN_GAIN":
            return 4109;
        case "AL_NONE":
            return 0;
        case "AL_NO_ERROR":
            return 0;
        case "AL_ORIENTATION":
            return 4111;
        case "AL_OUT_OF_MEMORY":
            return 40965;
        case "AL_PAUSED":
            return 4115;
        case "AL_PENDING":
            return 8209;
        case "AL_PITCH":
            return 4099;
        case "AL_PLAYING":
            return 4114;
        case "AL_POSITION":
            return 4100;
        case "AL_PROCESSED":
            return 8210;
        case "AL_REFERENCE_DISTANCE":
            return 4128;
        case "AL_RENDERER":
            return 45059;
        case "AL_ROLLOFF_FACTOR":
            return 4129;
        case "AL_SAMPLE_OFFSET":
            return 4133;
        case "AL_SEC_OFFSET":
            return 4132;
        case "AL_SIZE":
            return 8196;
        case "AL_SOURCE_RELATIVE":
            return 514;
        case "AL_SOURCE_STATE":
            return 4112;
        case "AL_SOURCE_TYPE":
            return 4135;
        case "AL_SPEED_OF_SOUND":
            return 49155;
        case "AL_STATIC":
            return 4136;
        case "AL_STOPPED":
            return 4116;
        case "AL_STREAMING":
            return 4137;
        case "AL_UNDETERMINED":
            return 4144;
        case "AL_UNUSED":
            return 8208;
        case "AL_VELOCITY":
            return 4102;
        case "AL_VENDOR":
            return 45057;
        case "AL_VERSION":
            return 45058;
        case "AL_AUTO_SOFT":
            return 2;
        case "AL_SOURCE_DISTANCE_MODEL":
            return 512;
        case "AL_SOURCE_SPATIALIZE_SOFT":
            return 4628;
        case "AL_LOOP_POINTS_SOFT":
            return 8213;
        case "AL_BYTE_LENGTH_SOFT":
            return 8201;
        case "AL_SAMPLE_LENGTH_SOFT":
            return 8202;
        case "AL_SEC_LENGTH_SOFT":
            return 8203;
        case "AL_FORMAT_MONO_FLOAT32":
            return 65552;
        case "AL_FORMAT_STEREO_FLOAT32":
            return 65553;
        default:
            AL.currentCtx.err = 40963;
            return 0
    }
};
var _alGetError = () => {
    if (!AL.currentCtx) {
        return 40964
    }
    var err = AL.currentCtx.err;
    AL.currentCtx.err = 0;
    return err
};
var _alGetFloat = param => {
    var val = AL.getGlobalParam("alGetFloat", param);
    if (val === null) {
        return 0
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            return val;
        default:
            return 0
    }
};
var _alGetFloatv = (param, pValues) => {
    var val = AL.getGlobalParam("alGetFloatv", param);
    if (val === null || !pValues) {
        return
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            HEAPF32[pValues >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetInteger = param => {
    var val = AL.getGlobalParam("alGetInteger", param);
    if (val === null) {
        return 0
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            return val;
        default:
            AL.currentCtx.err = 40962;
            return 0
    }
};
var _alGetIntegerv = (param, pValues) => {
    var val = AL.getGlobalParam("alGetIntegerv", param);
    if (val === null || !pValues) {
        return
    }
    switch (param) {
        case 49152:
        case 49155:
        case 53248:
            HEAP32[pValues >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetListener3f = (param, pValue0, pValue1, pValue2) => {
    var val = AL.getListenerParam("alGetListener3f", param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            HEAPF32[pValue0 >> 2] = val[0];
            HEAPF32[pValue1 >> 2] = val[1];
            HEAPF32[pValue2 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetListener3i = (param, pValue0, pValue1, pValue2) => {
    var val = AL.getListenerParam("alGetListener3i", param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            HEAP32[pValue0 >> 2] = val[0];
            HEAP32[pValue1 >> 2] = val[1];
            HEAP32[pValue2 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetListenerf = (param, pValue) => {
    var val = AL.getListenerParam("alGetListenerf", param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4106:
            HEAPF32[pValue >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetListenerfv = (param, pValues) => {
    var val = AL.getListenerParam("alGetListenerfv", param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            HEAPF32[pValues >> 2] = val[0];
            HEAPF32[pValues + 4 >> 2] = val[1];
            HEAPF32[pValues + 8 >> 2] = val[2];
            break;
        case 4111:
            HEAPF32[pValues >> 2] = val[0];
            HEAPF32[pValues + 4 >> 2] = val[1];
            HEAPF32[pValues + 8 >> 2] = val[2];
            HEAPF32[pValues + 12 >> 2] = val[3];
            HEAPF32[pValues + 16 >> 2] = val[4];
            HEAPF32[pValues + 20 >> 2] = val[5];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetListeneri = (param, pValue) => {
    var val = AL.getListenerParam("alGetListeneri", param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    AL.currentCtx.err = 40962
};
var _alGetListeneriv = (param, pValues) => {
    var val = AL.getListenerParam("alGetListeneriv", param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            HEAP32[pValues >> 2] = val[0];
            HEAP32[pValues + 4 >> 2] = val[1];
            HEAP32[pValues + 8 >> 2] = val[2];
            break;
        case 4111:
            HEAP32[pValues >> 2] = val[0];
            HEAP32[pValues + 4 >> 2] = val[1];
            HEAP32[pValues + 8 >> 2] = val[2];
            HEAP32[pValues + 12 >> 2] = val[3];
            HEAP32[pValues + 16 >> 2] = val[4];
            HEAP32[pValues + 20 >> 2] = val[5];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSource3f = (sourceId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getSourceParam("alGetSource3f", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4101:
        case 4102:
            HEAPF32[pValue0 >> 2] = val[0];
            HEAPF32[pValue1 >> 2] = val[1];
            HEAPF32[pValue2 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSource3i = (sourceId, param, pValue0, pValue1, pValue2) => {
    var val = AL.getSourceParam("alGetSource3i", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValue0 || !pValue1 || !pValue2) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4101:
        case 4102:
            HEAP32[pValue0 >> 2] = val[0];
            HEAP32[pValue1 >> 2] = val[1];
            HEAP32[pValue2 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSourcef = (sourceId, param, pValue) => {
    var val = AL.getSourceParam("alGetSourcef", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
            HEAPF32[pValue >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSourcefv = (sourceId, param, pValues) => {
    var val = AL.getSourceParam("alGetSourcefv", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
            HEAPF32[pValues >> 2] = val[0];
            break;
        case 4100:
        case 4101:
        case 4102:
            HEAPF32[pValues >> 2] = val[0];
            HEAPF32[pValues + 4 >> 2] = val[1];
            HEAPF32[pValues + 8 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSourcei = (sourceId, param, pValue) => {
    var val = AL.getSourceParam("alGetSourcei", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValue) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4112:
        case 4117:
        case 4118:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4135:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
            HEAP32[pValue >> 2] = val;
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var _alGetSourceiv = (sourceId, param, pValues) => {
    var val = AL.getSourceParam("alGetSourceiv", sourceId, param);
    if (val === null) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4112:
        case 4117:
        case 4118:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4135:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
            HEAP32[pValues >> 2] = val;
            break;
        case 4100:
        case 4101:
        case 4102:
            HEAP32[pValues >> 2] = val[0];
            HEAP32[pValues + 4 >> 2] = val[1];
            HEAP32[pValues + 8 >> 2] = val[2];
            break;
        default:
            AL.currentCtx.err = 40962;
            return
    }
};
var stringToNewUTF8 = str => {
    var size = lengthBytesUTF8(str) + 1;
    var ret = _malloc(size);
    if (ret) stringToUTF8(str, ret, size);
    return ret
};
var _alGetString = param => {
    if (AL.stringCache[param]) {
        return AL.stringCache[param]
    }
    var ret;
    switch (param) {
        case 0:
            ret = "No Error";
            break;
        case 40961:
            ret = "Invalid Name";
            break;
        case 40962:
            ret = "Invalid Enum";
            break;
        case 40963:
            ret = "Invalid Value";
            break;
        case 40964:
            ret = "Invalid Operation";
            break;
        case 40965:
            ret = "Out of Memory";
            break;
        case 45057:
            ret = "Emscripten";
            break;
        case 45058:
            ret = "1.1";
            break;
        case 45059:
            ret = "WebAudio";
            break;
        case 45060:
            ret = Object.keys(AL.AL_EXTENSIONS).join(" ");
            break;
        default:
            if (AL.currentCtx) {
                AL.currentCtx.err = 40962
            } else {}
            return 0
    }
    ret = stringToNewUTF8(ret);
    AL.stringCache[param] = ret;
    return ret
};
var _alIsBuffer = bufferId => {
    if (!AL.currentCtx) {
        return false
    }
    if (bufferId > AL.buffers.length) {
        return false
    }
    if (!AL.buffers[bufferId]) {
        return false
    }
    return true
};
var _alIsEnabled = param => {
    if (!AL.currentCtx) {
        return 0
    }
    switch (param) {
        case 512:
            return AL.currentCtx.sourceDistanceModel ? 0 : 1;
        default:
            AL.currentCtx.err = 40962;
            return 0
    }
};
var _alIsExtensionPresent = pExtName => {
    var name = UTF8ToString(pExtName);
    return AL.AL_EXTENSIONS[name] ? 1 : 0
};
var _alIsSource = sourceId => {
    if (!AL.currentCtx) {
        return false
    }
    if (!AL.currentCtx.sources[sourceId]) {
        return false
    }
    return true
};
var _alListener3f = (param, value0, value1, value2) => {
    switch (param) {
        case 4100:
        case 4102:
            AL.paramArray[0] = value0;
            AL.paramArray[1] = value1;
            AL.paramArray[2] = value2;
            AL.setListenerParam("alListener3f", param, AL.paramArray);
            break;
        default:
            AL.setListenerParam("alListener3f", param, null);
            break
    }
};
var _alListener3i = (param, value0, value1, value2) => {
    switch (param) {
        case 4100:
        case 4102:
            AL.paramArray[0] = value0;
            AL.paramArray[1] = value1;
            AL.paramArray[2] = value2;
            AL.setListenerParam("alListener3i", param, AL.paramArray);
            break;
        default:
            AL.setListenerParam("alListener3i", param, null);
            break
    }
};
var _alListenerf = (param, value) => {
    switch (param) {
        case 4106:
            AL.setListenerParam("alListenerf", param, value);
            break;
        default:
            AL.setListenerParam("alListenerf", param, null);
            break
    }
};
var _alListenerfv = (param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            AL.paramArray[0] = HEAPF32[pValues >> 2];
            AL.paramArray[1] = HEAPF32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAPF32[pValues + 8 >> 2];
            AL.setListenerParam("alListenerfv", param, AL.paramArray);
            break;
        case 4111:
            AL.paramArray[0] = HEAPF32[pValues >> 2];
            AL.paramArray[1] = HEAPF32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAPF32[pValues + 8 >> 2];
            AL.paramArray[3] = HEAPF32[pValues + 12 >> 2];
            AL.paramArray[4] = HEAPF32[pValues + 16 >> 2];
            AL.paramArray[5] = HEAPF32[pValues + 20 >> 2];
            AL.setListenerParam("alListenerfv", param, AL.paramArray);
            break;
        default:
            AL.setListenerParam("alListenerfv", param, null);
            break
    }
};
var _alListeneri = (param, value) => {
    AL.setListenerParam("alListeneri", param, null)
};
var _alListeneriv = (param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4100:
        case 4102:
            AL.paramArray[0] = HEAP32[pValues >> 2];
            AL.paramArray[1] = HEAP32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAP32[pValues + 8 >> 2];
            AL.setListenerParam("alListeneriv", param, AL.paramArray);
            break;
        case 4111:
            AL.paramArray[0] = HEAP32[pValues >> 2];
            AL.paramArray[1] = HEAP32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAP32[pValues + 8 >> 2];
            AL.paramArray[3] = HEAP32[pValues + 12 >> 2];
            AL.paramArray[4] = HEAP32[pValues + 16 >> 2];
            AL.paramArray[5] = HEAP32[pValues + 20 >> 2];
            AL.setListenerParam("alListeneriv", param, AL.paramArray);
            break;
        default:
            AL.setListenerParam("alListeneriv", param, null);
            break
    }
};
var _alSource3f = (sourceId, param, value0, value1, value2) => {
    switch (param) {
        case 4100:
        case 4101:
        case 4102:
            AL.paramArray[0] = value0;
            AL.paramArray[1] = value1;
            AL.paramArray[2] = value2;
            AL.setSourceParam("alSource3f", sourceId, param, AL.paramArray);
            break;
        default:
            AL.setSourceParam("alSource3f", sourceId, param, null);
            break
    }
};
var _alSource3i = (sourceId, param, value0, value1, value2) => {
    switch (param) {
        case 4100:
        case 4101:
        case 4102:
            AL.paramArray[0] = value0;
            AL.paramArray[1] = value1;
            AL.paramArray[2] = value2;
            AL.setSourceParam("alSource3i", sourceId, param, AL.paramArray);
            break;
        default:
            AL.setSourceParam("alSource3i", sourceId, param, null);
            break
    }
};
var _alSourcePause = sourceId => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    AL.setSourceState(src, 4115)
};
var _alSourcePausev = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pSourceIds) {
        AL.currentCtx.err = 40963
    }
    for (var i = 0; i < count; ++i) {
        if (!AL.currentCtx.sources[HEAP32[pSourceIds + i * 4 >> 2]]) {
            AL.currentCtx.err = 40961;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4115)
    }
};
var _alSourcePlay = sourceId => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    AL.setSourceState(src, 4114)
};
var _alSourcePlayv = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pSourceIds) {
        AL.currentCtx.err = 40963
    }
    for (var i = 0; i < count; ++i) {
        if (!AL.currentCtx.sources[HEAP32[pSourceIds + i * 4 >> 2]]) {
            AL.currentCtx.err = 40961;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4114)
    }
};
var _alSourceQueueBuffers = (sourceId, count, pBufferIds) => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    if (src.type === 4136) {
        AL.currentCtx.err = 40964;
        return
    }
    if (count === 0) {
        return
    }
    var templateBuf = AL.buffers[0];
    for (var buf of src.bufQueue) {
        if (buf.id !== 0) {
            templateBuf = buf;
            break
        }
    }
    for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[pBufferIds + i * 4 >> 2];
        var buf = AL.buffers[bufId];
        if (!buf) {
            AL.currentCtx.err = 40961;
            return
        }
        if (templateBuf.id !== 0 && (buf.frequency !== templateBuf.frequency || buf.bytesPerSample !== templateBuf.bytesPerSample || buf.channels !== templateBuf.channels)) {
            AL.currentCtx.err = 40964
        }
    }
    if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
        src.bufQueue.length = 0
    }
    src.type = 4137;
    for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[pBufferIds + i * 4 >> 2];
        var buf = AL.buffers[bufId];
        buf.refCount++;
        src.bufQueue.push(buf)
    }
    if (src.looping) {
        AL.cancelPendingSourceAudio(src)
    }
    AL.initSourcePanner(src);
    AL.scheduleSourceAudio(src)
};
var _alSourceRewind = sourceId => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    AL.setSourceState(src, 4116);
    AL.setSourceState(src, 4113)
};
var _alSourceRewindv = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pSourceIds) {
        AL.currentCtx.err = 40963
    }
    for (var i = 0; i < count; ++i) {
        if (!AL.currentCtx.sources[HEAP32[pSourceIds + i * 4 >> 2]]) {
            AL.currentCtx.err = 40961;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4113)
    }
};
var _alSourceStop = sourceId => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    AL.setSourceState(src, 4116)
};
var _alSourceStopv = (count, pSourceIds) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pSourceIds) {
        AL.currentCtx.err = 40963
    }
    for (var i = 0; i < count; ++i) {
        if (!AL.currentCtx.sources[HEAP32[pSourceIds + i * 4 >> 2]]) {
            AL.currentCtx.err = 40961;
            return
        }
    }
    for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[pSourceIds + i * 4 >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4116)
    }
};
var _alSourceUnqueueBuffers = (sourceId, count, pBufferIds) => {
    if (!AL.currentCtx) {
        return
    }
    var src = AL.currentCtx.sources[sourceId];
    if (!src) {
        AL.currentCtx.err = 40961;
        return
    }
    if (count > (src.bufQueue.length === 1 && src.bufQueue[0].id === 0 ? 0 : src.bufsProcessed)) {
        AL.currentCtx.err = 40963;
        return
    }
    if (count === 0) {
        return
    }
    for (var i = 0; i < count; i++) {
        var buf = src.bufQueue.shift();
        buf.refCount--;
        HEAP32[pBufferIds + i * 4 >> 2] = buf.id;
        src.bufsProcessed--
    }
    if (src.bufQueue.length === 0) {
        src.bufQueue.push(AL.buffers[0])
    }
    AL.initSourcePanner(src);
    AL.scheduleSourceAudio(src)
};
var _alSourcef = (sourceId, param, value) => {
    switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
            AL.setSourceParam("alSourcef", sourceId, param, value);
            break;
        default:
            AL.setSourceParam("alSourcef", sourceId, param, null);
            break
    }
};
var _alSourcefv = (sourceId, param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
            var val = HEAPF32[pValues >> 2];
            AL.setSourceParam("alSourcefv", sourceId, param, val);
            break;
        case 4100:
        case 4101:
        case 4102:
            AL.paramArray[0] = HEAPF32[pValues >> 2];
            AL.paramArray[1] = HEAPF32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAPF32[pValues + 8 >> 2];
            AL.setSourceParam("alSourcefv", sourceId, param, AL.paramArray);
            break;
        default:
            AL.setSourceParam("alSourcefv", sourceId, param, null);
            break
    }
};
var _alSourceiv = (sourceId, param, pValues) => {
    if (!AL.currentCtx) {
        return
    }
    if (!pValues) {
        AL.currentCtx.err = 40963;
        return
    }
    switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
            var val = HEAP32[pValues >> 2];
            AL.setSourceParam("alSourceiv", sourceId, param, val);
            break;
        case 4100:
        case 4101:
        case 4102:
            AL.paramArray[0] = HEAP32[pValues >> 2];
            AL.paramArray[1] = HEAP32[pValues + 4 >> 2];
            AL.paramArray[2] = HEAP32[pValues + 8 >> 2];
            AL.setSourceParam("alSourceiv", sourceId, param, AL.paramArray);
            break;
        default:
            AL.setSourceParam("alSourceiv", sourceId, param, null);
            break
    }
};
var _alSpeedOfSound = value => {
    AL.setGlobalParam("alSpeedOfSound", 49155, value)
};
var _alcCloseDevice = deviceId => {
    if (!(deviceId in AL.deviceRefCounts) || AL.deviceRefCounts[deviceId] > 0) {
        return 0
    }
    delete AL.deviceRefCounts[deviceId];
    AL.freeIds.push(deviceId);
    return 1
};
var autoResumeAudioContext = ctx => {
    for (var event of ["keydown", "mousedown", "touchstart"]) {
        for (var element of [document, document.getElementById("canvas")]) {
            element?.addEventListener(event, () => {
                if (ctx.state === "suspended") ctx.resume()
            }, {
                once: true
            })
        }
    }
};
var _alcCreateContext = (deviceId, pAttrList) => {
    if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return 0
    }
    var options = null;
    var attrs = [];
    var hrtf = null;
    pAttrList >>= 2;
    if (pAttrList) {
        var attr = 0;
        var val = 0;
        while (true) {
            attr = HEAP32[pAttrList++];
            attrs.push(attr);
            if (attr === 0) {
                break
            }
            val = HEAP32[pAttrList++];
            attrs.push(val);
            switch (attr) {
                case 4103:
                    if (!options) {
                        options = {}
                    }
                    options.sampleRate = val;
                    break;
                case 4112:
                case 4113:
                    break;
                case 6546:
                    switch (val) {
                        case 0:
                            hrtf = false;
                            break;
                        case 1:
                            hrtf = true;
                            break;
                        case 2:
                            break;
                        default:
                            AL.alcErr = 40964;
                            return 0
                    }
                    break;
                case 6550:
                    if (val !== 0) {
                        AL.alcErr = 40964;
                        return 0
                    }
                    break;
                default:
                    AL.alcErr = 40964;
                    return 0
            }
        }
    }
    var AudioContext = window.AudioContext || window.webkitAudioContext;
    var ac = null;
    try {
        if (options) {
            ac = new AudioContext(options)
        } else {
            ac = new AudioContext
        }
    } catch (e) {
        if (e.name === "NotSupportedError") {
            AL.alcErr = 40964
        } else {
            AL.alcErr = 40961
        }
        return 0
    }
    autoResumeAudioContext(ac);
    if (typeof ac.createGain == "undefined") {
        ac.createGain = ac.createGainNode
    }
    var gain = ac.createGain();
    gain.connect(ac.destination);
    var ctx = {
        deviceId,
        id: AL.newId(),
        attrs,
        audioCtx: ac,
        listener: {
            position: [0, 0, 0],
            velocity: [0, 0, 0],
            direction: [0, 0, 0],
            up: [0, 0, 0]
        },
        sources: [],
        interval: setInterval(() => AL.scheduleContextAudio(ctx), AL.QUEUE_INTERVAL),
        gain,
        distanceModel: 53250,
        speedOfSound: 343.3,
        dopplerFactor: 1,
        sourceDistanceModel: false,
        hrtf: hrtf || false,
        _err: 0,
        get err() {
            return this._err
        },
        set err(val) {
            if (this._err === 0 || val === 0) {
                this._err = val
            }
        }
    };
    AL.deviceRefCounts[deviceId]++;
    AL.contexts[ctx.id] = ctx;
    if (hrtf !== null) {
        for (var ctxId in AL.contexts) {
            var c = AL.contexts[ctxId];
            if (c.deviceId === deviceId) {
                c.hrtf = hrtf;
                AL.updateContextGlobal(c)
            }
        }
    }
    return ctx.id
};
var _alcDestroyContext = contextId => {
    var ctx = AL.contexts[contextId];
    if (AL.currentCtx === ctx) {
        AL.alcErr = 40962;
        return
    }
    if (AL.contexts[contextId].interval) {
        clearInterval(AL.contexts[contextId].interval)
    }
    AL.deviceRefCounts[ctx.deviceId]--;
    delete AL.contexts[contextId];
    AL.freeIds.push(contextId)
};
var _alcGetIntegerv = (deviceId, param, size, pValues) => {
    if (size === 0 || !pValues) {
        return
    }
    switch (param) {
        case 4096:
            HEAP32[pValues >> 2] = 1;
            break;
        case 4097:
            HEAP32[pValues >> 2] = 1;
            break;
        case 4098:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            if (!AL.currentCtx) {
                AL.alcErr = 40962;
                return
            }
            HEAP32[pValues >> 2] = AL.currentCtx.attrs.length;
            break;
        case 4099:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            if (!AL.currentCtx) {
                AL.alcErr = 40962;
                return
            }
            for (var i = 0; i < AL.currentCtx.attrs.length; i++) {
                HEAP32[pValues + i * 4 >> 2] = AL.currentCtx.attrs[i]
            }
            break;
        case 4103:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            if (!AL.currentCtx) {
                AL.alcErr = 40962;
                return
            }
            HEAP32[pValues >> 2] = AL.currentCtx.audioCtx.sampleRate;
            break;
        case 4112:
        case 4113:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            if (!AL.currentCtx) {
                AL.alcErr = 40962;
                return
            }
            HEAP32[pValues >> 2] = 2147483647;
            break;
        case 6546:
        case 6547:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            var hrtfStatus = 0;
            for (var ctxId in AL.contexts) {
                var ctx = AL.contexts[ctxId];
                if (ctx.deviceId === deviceId) {
                    hrtfStatus = ctx.hrtf ? 1 : 0
                }
            }
            HEAP32[pValues >> 2] = hrtfStatus;
            break;
        case 6548:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            HEAP32[pValues >> 2] = 1;
            break;
        case 131075:
            if (!(deviceId in AL.deviceRefCounts)) {
                AL.alcErr = 40961;
                return
            }
            if (!AL.currentCtx) {
                AL.alcErr = 40962;
                return
            }
            HEAP32[pValues >> 2] = 1;
        case 786:
            var c = AL.requireValidCaptureDevice(deviceId, "alcGetIntegerv");
            if (!c) {
                return
            }
            var n = c.capturedFrameCount;
            var dstfreq = c.requestedSampleRate;
            var srcfreq = c.audioCtx.sampleRate;
            var nsamples = Math.floor(n * (dstfreq / srcfreq));
            HEAP32[pValues >> 2] = nsamples;
            break;
        default:
            AL.alcErr = 40963;
            return
    }
};
var _alcIsExtensionPresent = (deviceId, pExtName) => {
    var name = UTF8ToString(pExtName);
    return AL.ALC_EXTENSIONS[name] ? 1 : 0
};
var _alcMakeContextCurrent = contextId => {
    if (contextId === 0) {
        AL.currentCtx = null
    } else {
        AL.currentCtx = AL.contexts[contextId]
    }
    return 1
};
var _alcOpenDevice = pDeviceName => {
    if (pDeviceName) {
        var name = UTF8ToString(pDeviceName);
        if (name !== AL.DEVICE_NAME) {
            return 0
        }
    }
    if (globalThis.AudioContext || globalThis.webkitAudioContext) {
        var deviceId = AL.newId();
        AL.deviceRefCounts[deviceId] = 0;
        return deviceId
    }
    return 0
};
var _alcSuspendContext = contextId => {};