var __bare_os_bundle_exports__ = (() => {
  var __create = Object.create;
  var __defProp = Object.defineProperty;
  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
  var __getOwnPropNames = Object.getOwnPropertyNames;
  var __getProtoOf = Object.getPrototypeOf;
  var __hasOwnProp = Object.prototype.hasOwnProperty;
  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
  }) : x)(function(x) {
    if (typeof require !== "undefined") return require.apply(this, arguments);
    throw Error('Dynamic require of "' + x + '" is not supported');
  });
  var __commonJS = (cb, mod) => function __require2() {
    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
  };
  var __export = (target, all) => {
    for (var name in all)
      __defProp(target, name, { get: all[name], enumerable: true });
  };
  var __copyProps = (to, from, except, desc) => {
    if (from && typeof from === "object" || typeof from === "function") {
      for (let key of __getOwnPropNames(from))
        if (!__hasOwnProp.call(to, key) && key !== except)
          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
    }
    return to;
  };
  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
    // If the importer is in node compatibility mode or this is not an ESM
    // file that has been converted to a CommonJS file using a Babel-
    // compatible transform (i.e. "__esModule" has not been set), then set
    // "default" to the CommonJS "module.exports" for node compatibility.
    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
    mod
  ));
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

  // ../../node_modules/bare-sdl/binding.js
  var require_binding = __commonJS({
    "../../node_modules/bare-sdl/binding.js"(exports, module) {
      module.exports = __require.addon();
    }
  });

  // ../../node_modules/bare-sdl/lib/constants.js
  var require_constants = __commonJS({
    "../../node_modules/bare-sdl/lib/constants.js"(exports, module) {
      var binding = require_binding();
      module.exports = binding.constants;
    }
  });

  // ../../node_modules/bare-sdl/lib/audio-device.js
  var require_audio_device = __commonJS({
    "../../node_modules/bare-sdl/lib/audio-device.js"(exports, module) {
      var binding = require_binding();
      var constants = binding.constants;
      var SDLAudioSpec = class {
        constructor(format) {
          this._format = format;
        }
        get format() {
          return binding.getAudioDeviceFormatFormat(this._format._handle);
        }
        get channels() {
          return binding.getAudioDeviceFormatChannels(this._format._handle);
        }
        get freq() {
          return binding.getAudioDeviceFormatFreq(this._format._handle);
        }
        toJSON() {
          return {
            format: this.format,
            channels: this.channels,
            freq: this.freq
          };
        }
      };
      var SDLAudioDeviceFormat = class {
        constructor(deviceId) {
          this._handle = binding.getAudioDeviceFormat(deviceId);
        }
        get valid() {
          return binding.getAudioDeviceFormatValid(this._handle);
        }
        get sampleFrames() {
          return binding.getAudioDeviceFormatSampleFrames(this._handle);
        }
        get spec() {
          return new SDLAudioSpec(this);
        }
        toJSON() {
          return {
            valid: this.valid,
            sampleFrames: this.sampleFrames,
            spec: this.spec.toJSON()
          };
        }
      };
      var SDLAudioDevice = class _SDLAudioDevice {
        static AudioSpec = SDLAudioSpec;
        static AudioDeviceFormat = SDLAudioDeviceFormat;
        static playbackDeviceFormats() {
          const list = binding.getAudioPlaybackDevices();
          return list.map((deviceId) => {
            return new SDLAudioDeviceFormat(deviceId);
          });
        }
        static getRecordingDevice({ name } = {}) {
          if (!name) {
            return _SDLAudioDevice.defaultRecordingDevice();
          }
          const device = _SDLAudioDevice.recordingDevices().find((device2) => {
            return name === device2.name;
          });
          if (!device) {
            return null;
          }
          return new _SDLAudioDevice(device);
        }
        static recordingDeviceFormats() {
          const list = binding.getAudioRecordingDevices();
          return list.map((deviceId) => {
            return new SDLAudioDeviceFormat(deviceId);
          });
        }
        static recordingDevices() {
          const devices = binding.getAudioRecordingDevices();
          return devices.map((id, index) => {
            const name = _SDLAudioDevice.getAudioDeviceName(id);
            return {
              id,
              name,
              index
            };
          });
        }
        static getPlaybackDevice({ name } = {}) {
          if (!name) {
            return _SDLAudioDevice.defaultPlaybackDevice();
          }
          const device = _SDLAudioDevice.playbackDevices().find((device2) => {
            return name === device2.name;
          });
          if (!device) {
            return null;
          }
          return new _SDLAudioDevice(device);
        }
        static playbackDevices() {
          const devices = binding.getAudioPlaybackDevices();
          return devices.map((id, index) => {
            const name = _SDLAudioDevice.getAudioDeviceName(id);
            return {
              id,
              name,
              index
            };
          });
        }
        static defaultRecordingDevice(spec) {
          return new _SDLAudioDevice(
            constants.SDL_AUDIO_DEVICE_DEFAULT_RECORDING,
            spec
          );
        }
        static defaultPlaybackDevice(spec) {
          return new _SDLAudioDevice(constants.SDL_AUDIO_DEVICE_DEFAULT_PLAYBACK, spec);
        }
        static getAudioDeviceName(id) {
          return binding.getAudioDeviceName(id);
        }
        constructor(deviceId, spec) {
          this._requestedDeviceId = deviceId;
          this.spec = spec;
          const format = this.spec?.format;
          const channels = this.spec?.channels;
          const freq = this.spec?.freq;
          this.id = binding.openAudioDevice(
            this._requestedDeviceId,
            format,
            channels,
            freq
          );
          if (!this.spec) {
            this.spec = this.format.spec;
          }
        }
        close() {
          if (!this.id) return;
          binding.closeAudioDevice(this.id);
          this.id = null;
        }
        destroy() {
          this.close();
        }
        [Symbol.dispose]() {
          this.destroy();
        }
        get name() {
          return binding.getAudioDeviceName(this.id);
        }
        get format() {
          return new SDLAudioDeviceFormat(this.id);
        }
        get isPlaybackDevice() {
          return binding.isAudioDevicePlayback(this.id);
        }
        get isPhysicalDevice() {
          return binding.isAudioDevicePhysical(this.id);
        }
        get isPaused() {
          return binding.isAudioDevicePaused(this.id);
        }
        get gain() {
          return binding.getAudioDeviceGain(this.id);
        }
        set gain(volume) {
          binding.setAudioDeviceGain(this.id, volume);
        }
        pause() {
          if (!this.id) return false;
          return binding.pauseAudioDevice(this.id);
        }
        resume() {
          if (!this.id) return false;
          return binding.resumeAudioDevice(this.id);
        }
        bindStream(stream) {
          if (!this.id) {
            throw new Error("Audio device not open");
          }
          if (!stream._handle) {
            throw new Error("Audio stream not created");
          }
          const success = binding.bindAudioStream(this.id, stream._handle);
          if (typeof stream._onBound === "function") {
            stream._onBound();
          }
          this.resume();
          return success;
        }
        unbindStream(stream) {
          if (!this.id) return;
          if (!stream._handle) {
            throw new Error("Audio stream not created");
          }
          binding.unbindAudioStream(stream._handle);
          if (typeof stream._bound !== "undefined") {
            stream._bound = false;
          }
          return;
        }
        toJSON() {
          return {
            id: this.id,
            name: this.name,
            format: this.format.toJSON(),
            isPlaybackDevice: this.isPlaybackDevice,
            isPhysicalDevice: this.isPhysicalDevice,
            isPaused: this.isPaused,
            gain: this.gain
          };
        }
      };
      module.exports = SDLAudioDevice;
    }
  });

  // ../../node_modules/bare-sdl/lib/camera.js
  var require_camera = __commonJS({
    "../../node_modules/bare-sdl/lib/camera.js"(exports, module) {
      var binding = require_binding();
      var SDLCameraSpec = class {
        constructor(spec) {
          this._spec = spec;
        }
        get format() {
          return binding.getCameraSpecFormat(this._spec);
        }
        get colorspace() {
          return binding.getCameraSpecColorspace(this._spec);
        }
        get width() {
          return binding.getCameraSpecWidth(this._spec);
        }
        get height() {
          return binding.getCameraSpecHeight(this._spec);
        }
        get framerateNumerator() {
          return binding.getCameraSpecFramerateNumerator(this._spec);
        }
        get framerateDenominator() {
          return binding.getCameraSpecFramerateDenominator(this._spec);
        }
        get fps() {
          if (!this.framerateNumerator || !this.framerateDenominator) {
            return 0;
          }
          return this.framerateNumerator / this.framerateDenominator;
        }
        toJSON() {
          return {
            format: this.format,
            colorspace: this.colorspace,
            width: this.width,
            height: this.height,
            framerateNumerator: this.framerateNumerator,
            framerateDenominator: this.framerateDenominator,
            fps: this.fps
          };
        }
      };
      var SDLCameraFrame = class {
        constructor(camera) {
          this._camera = camera;
          this._handle = binding.acquireCameraFrame(camera._handle);
        }
        get valid() {
          return binding.getCameraFrameValid(this._handle);
        }
        get timestamp() {
          return binding.getCameraFrameTimestamp(this._handle);
        }
        get width() {
          return binding.getCameraFrameWidth(this._handle);
        }
        get height() {
          return binding.getCameraFrameHeight(this._handle);
        }
        get pitch() {
          return binding.getCameraFramePitch(this._handle);
        }
        get format() {
          return binding.getCameraFrameFormat(this._handle);
        }
        get pixels() {
          return binding.getCameraFramePixels(this._handle);
        }
        release() {
          if (this._handle && this._camera._handle) {
            binding.releaseCameraFrame(this._camera._handle, this._handle);
            this._handle = null;
          }
        }
        [Symbol.dispose]() {
          this.release();
        }
        toJSON() {
          return {
            valid: this.valid,
            timestamp: this.timestamp,
            width: this.width,
            height: this.height,
            pitch: this.pitch,
            format: this.format
          };
        }
      };
      var SDLCamera = class _SDLCamera {
        static CameraSpec = SDLCameraSpec;
        static CameraFrame = SDLCameraFrame;
        static defaultCamera(spec) {
          const devices = binding.getCameras();
          if (!spec) {
            const formats = _SDLCamera.getSupportedFormats(devices[0]);
            spec = formats[0];
          }
          return new _SDLCamera(devices[0], spec);
        }
        static getCameras() {
          const cameras = binding.getCameras();
          return cameras.map((id, index) => {
            const name = _SDLCamera.getCameraName(id);
            return {
              id,
              name,
              index
            };
          });
        }
        static getCameraName(deviceId) {
          return binding.getCameraName(deviceId);
        }
        static getCameraPosition(deviceId) {
          return binding.getCameraPosition(deviceId);
        }
        static getSupportedFormats(deviceId) {
          const formatHandles = binding.getCameraSupportedFormats(deviceId);
          return formatHandles.map((handle) => {
            const spec = new SDLCameraSpec(handle);
            return spec.toJSON();
          });
        }
        constructor(deviceId, spec) {
          if (typeof deviceId !== "number" && deviceId.id) {
            deviceId = deviceId.id;
          }
          this._deviceId = deviceId;
          this._spec = spec;
          const format = spec?.format;
          const colorspace = spec?.colorspace;
          const width = spec?.width;
          const height = spec?.height;
          const framerateNumerator = spec?.framerateNumerator;
          const framerateDenominator = spec?.framerateDenominator;
          this._handle = binding.openCamera(
            deviceId,
            format,
            colorspace,
            width,
            height,
            framerateNumerator,
            framerateDenominator
          );
        }
        get id() {
          return binding.getCameraId(this._handle);
        }
        get name() {
          return binding.getCameraName(this._deviceId);
        }
        get properties() {
          return binding.getCameraProperties(this._handle);
        }
        get permissionState() {
          return binding.getCameraPermissionState(this._handle);
        }
        get isApproved() {
          return this.permissionState === 1;
        }
        get isDenied() {
          return this.permissionState === -1;
        }
        get isPending() {
          return this.permissionState === 0;
        }
        get spec() {
          const spec = binding.getCameraFormat(this._handle);
          return new SDLCameraSpec(spec);
        }
        acquireFrame() {
          return new SDLCameraFrame(this);
        }
        destroy() {
          if (this._handle) {
            binding.closeCamera(this._handle);
            this._handle = null;
          }
        }
        [Symbol.dispose]() {
          this.destroy();
        }
        toJSON() {
          return {
            id: this.id,
            deviceId: this._deviceId,
            permissionState: this.permissionState,
            isApproved: this.isApproved,
            isDenied: this.isDenied,
            isPending: this.isPending,
            spec: this.spec.toJSON()
          };
        }
      };
      module.exports = SDLCamera;
    }
  });

  // ../../node_modules/bare-sdl/lib/audio-stream.js
  var require_audio_stream = __commonJS({
    "../../node_modules/bare-sdl/lib/audio-stream.js"(exports, module) {
      var binding = require_binding();
      module.exports = class SDLAudioStream {
        constructor(source, target, options = {}) {
          this.source = source;
          this.target = target;
          this._handle = null;
          this._destroyed = false;
          this._handle = binding.createAudioStream(
            source.format,
            source.channels,
            source.freq,
            target.format,
            target.channels,
            target.freq,
            this._makeSafeCallback(options?.get),
            this._makeSafeCallback(options?.put)
          );
        }
        put(buffer, offset = 0, length) {
          if (this._destroyed || !this._handle) return false;
          const result = this._handleBufferParams(buffer, offset, length);
          return binding.putAudioStreamData(
            this._handle,
            result.arrayBuffer,
            result.byteOffset,
            result.length
          );
        }
        get(buffer, offset = 0, length) {
          if (this._destroyed || !this._handle) return 0;
          const result = this._handleBufferParams(buffer, offset, length);
          return binding.getAudioStreamData(
            this._handle,
            result.arrayBuffer,
            result.byteOffset,
            result.length
          );
        }
        _handleBufferParams(buffer, offset, length) {
          let arrayBuffer = buffer;
          let byteOffset = offset;
          if (Buffer.isBuffer(buffer)) {
            arrayBuffer = buffer.buffer;
            byteOffset = buffer.byteOffset + offset;
            length = length ?? buffer.length - offset;
          } else {
            length = length ?? buffer.byteLength - offset;
          }
          return {
            arrayBuffer,
            byteOffset,
            length
          };
        }
        get available() {
          if (this._destroyed || !this._handle) return 0;
          return binding.getAudioStreamAvailable(this._handle);
        }
        get device() {
          if (this._destroyed || !this._handle) return 0;
          return binding.getAudioStreamDevice(this._handle);
        }
        flush() {
          if (this._destroyed || !this._handle) return false;
          return binding.flushAudioStream(this._handle);
        }
        clear() {
          if (this._destroyed || !this._handle) return false;
          return binding.clearAudioStream(this._handle);
        }
        resume() {
          if (this._destroyed || !this._handle) return false;
          return binding.resumeAudioStreamDevice(this._handle);
        }
        destroy() {
          if (this._destroyed) return;
          this._destroyed = true;
          if (this._handle) {
            binding.destroyAudioStream(this._handle);
            this._handle = null;
          }
          this._get = null;
          this._put = null;
        }
        _makeSafeCallback(cb) {
          if (!cb) {
            return;
          }
          return (needed, total) => {
            if (!this._destroyed) {
              cb(needed, total);
            }
          };
        }
      };
    }
  });

  // ../../node_modules/bare-sdl/lib/event.js
  var require_event = __commonJS({
    "../../node_modules/bare-sdl/lib/event.js"(exports, module) {
      var binding = require_binding();
      var SDLEvent = class {
        constructor() {
          this._handle = binding.createEvent();
        }
        get type() {
          return binding.getEventType(this._handle);
        }
        get key() {
          return new SDLKeyboardEvent(this);
        }
      };
      var SDLKeyboardEvent = class {
        constructor(event = new SDLEvent()) {
          this._handle = binding.getEventKey(event._handle);
        }
        get scancode() {
          return binding.getEventKeyScancode(this._handle);
        }
      };
      module.exports = SDLEvent;
      module.exports.Keyboard = SDLKeyboardEvent;
    }
  });

  // ../../node_modules/bare-sdl/lib/poller.js
  var require_poller = __commonJS({
    "../../node_modules/bare-sdl/lib/poller.js"(exports, module) {
      var binding = require_binding();
      module.exports = class SDLPoller {
        poll(event) {
          return binding.poll(event._handle);
        }
      };
    }
  });

  // ../../node_modules/bare-sdl/lib/renderer.js
  var require_renderer = __commonJS({
    "../../node_modules/bare-sdl/lib/renderer.js"(exports, module) {
      var binding = require_binding();
      module.exports = class SDLRenderer {
        constructor(window) {
          this._handle = binding.createRenderer(window._handle);
        }
        destroy() {
          binding.destroyRenderer(this._handle);
          this._handle = null;
        }
        clear() {
          return binding.clearRender(this._handle);
        }
        texture(texture) {
          return binding.textureRender(this._handle, texture._handle);
        }
        present() {
          return binding.presentRender(this._handle);
        }
      };
    }
  });

  // ../../node_modules/bare-sdl/lib/texture.js
  var require_texture = __commonJS({
    "../../node_modules/bare-sdl/lib/texture.js"(exports, module) {
      var binding = require_binding();
      var constants = require_constants();
      module.exports = class SDLTexture {
        constructor(renderer, width, height, pixelFormat = constants.SDL_PIXELFORMAT_RGB24, textureAccess = constants.SDL_TEXTUREACCESS_STREAMING) {
          this._handle = binding.createTexture(
            renderer._handle,
            pixelFormat,
            textureAccess,
            width,
            height
          );
        }
        destroy() {
          binding.destroyTexture(this._handle);
          this._handle = null;
        }
        update(buffer, pitch) {
          return binding.updateTexture(
            this._handle,
            buffer.buffer,
            buffer.byteOffset,
            pitch
          );
        }
      };
    }
  });

  // ../../node_modules/bare-sdl/lib/window.js
  var require_window = __commonJS({
    "../../node_modules/bare-sdl/lib/window.js"(exports, module) {
      var binding = require_binding();
      module.exports = class SDLWindow {
        constructor(title, width, height, flags = 0) {
          this._handle = binding.createWindow(title, width, height, flags);
        }
        destroy() {
          binding.destroyWindow(this._handle);
          this._handle = null;
        }
      };
    }
  });

  // ../../node_modules/bare-sdl/index.js
  var require_bare_sdl = __commonJS({
    "../../node_modules/bare-sdl/index.js"(exports) {
      exports.constants = require_constants();
      exports.AudioDevice = require_audio_device();
      exports.Camera = require_camera();
      exports.AudioStream = require_audio_stream();
      exports.Event = require_event();
      exports.Poller = require_poller();
      exports.Renderer = require_renderer();
      exports.Texture = require_texture();
      exports.Window = require_window();
    }
  });

  // ../../bare-lib-entry-bareSdl.js
  var bare_lib_entry_bareSdl_exports = {};
  __export(bare_lib_entry_bareSdl_exports, {
    default: () => bare_lib_entry_bareSdl_default
  });
  var import_bare_sdl = __toESM(require_bare_sdl());
  var bare_lib_entry_bareSdl_default = import_bare_sdl.default;
  return __toCommonJS(bare_lib_entry_bareSdl_exports);
})();
;(function(){var g=globalThis;var s="__bare_os_stdlib__";g[s]=g[s]||{};var e=typeof __bare_os_bundle_exports__!=="undefined"?__bare_os_bundle_exports__:void 0;var v=e!=null&&typeof e==="object"&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e;g[s]["bareSdl"]=v;})();