@hi-ashleyj/llama 0.11.0 → 0.12.0

package/dist/Game.svelte

@@ -4,6 +4,11 @@ import { setupGame } from "./core-contexts.js";
 import { Timing } from "./controllers/motions.js";
 import { Keyboard } from "./controllers/keyboard.js";
 import { Mouse } from "./controllers/mouse.js";
+import { getSetupAudio } from "./audio/context.js";
+import { decodeAllBuffers } from "./resources/audio.js";
+const raise = (err) => {
+  throw new Error(err);
+};
 export let width = 1920;
 export let height = 1080;
 export let background = "#000000";
@@ -68,7 +73,9 @@ export const context = {
   onAfterFrame: (callback) => {
     frameAfterEvents.add(callback);
     return () => frameAfterEvents.delete(callback);
-  }
+  },
+  defaultTextFontFace: writable(null),
+  getAudioContext: () => audio ? audio : raise("There Is No AudioContext")
 };
 setupGame(context);
 let last = -1;
@@ -88,7 +95,16 @@ const loop = function(time) {
   requestAnimationFrame(loop);
   last = time;
 };
+let audio = null;
+getSetupAudio((node) => {
+  if (!audio)
+    throw new Error("Audio Is Not Yet Created!");
+  node.connect(audio.destination);
+  return () => audio && node.disconnect(audio.destination);
+});
 onMount(() => {
+  audio = new AudioContext();
+  decodeAllBuffers(audio);
   requestAnimationFrame(loop);
   keyboard.start();
   mouse.start();
@@ -104,13 +120,18 @@ $: {
 $: {
   mouse.setWidth(width);
 }
+const resumeAudioContext = () => {
+  if (audio?.state === "suspended") {
+    audio?.resume();
+  }
+};
 </script>
 
 <div class="game" style:background-color={background}>
     <slot />
 </div>
 
-<svelte:window bind:innerHeight={wih} bind:innerWidth={wiw}></svelte:window>
+<svelte:window bind:innerHeight={wih} bind:innerWidth={wiw} on:click={resumeAudioContext} on:keydown={resumeAudioContext}></svelte:window>
 
 <style>
     .game {

package/dist/audio/AudioCompressor.svelte

@@ -0,0 +1,46 @@
+<script>import { getAudioContext, getConnector } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+export let preGain = 1;
+export let postGain = 1;
+export let attack = 10;
+export let threshold = -6;
+export let blend = 3;
+export let ratio = 2;
+export let release = 150;
+let output;
+let input;
+let process;
+$: {
+  if (output) {
+    output.gain.setTargetAtTime(postGain, audioCTX.currentTime, 4e-3);
+  }
+}
+$: {
+  if (input) {
+    input.gain.setTargetAtTime(preGain, audioCTX.currentTime, 4e-3);
+  }
+}
+$: {
+  if (process) {
+    process.attack.setTargetAtTime(attack / 1e3, audioCTX.currentTime, 4e-3);
+    process.threshold.setTargetAtTime(threshold, audioCTX.currentTime, 4e-3);
+    process.knee.setTargetAtTime(Math.min(threshold + blend, 0), audioCTX.currentTime, 4e-3);
+    process.ratio.setTargetAtTime(ratio, audioCTX.currentTime, 4e-3);
+    process.release.setTargetAtTime(release / 1e3, audioCTX.currentTime, 4e-3);
+  }
+}
+const connect = getConnector((node) => {
+  node.connect(output);
+  return () => node.disconnect(output);
+});
+onMount(() => {
+  const audioCTX2 = audioContext();
+  output = audioCTX2.createGain();
+  input = audioCTX2.createGain();
+  process = audioCTX2.createDynamicsCompressor();
+  return connect(output);
+});
+</script>
+
+<slot />

package/dist/audio/AudioCompressor.svelte.d.ts

@@ -0,0 +1,24 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        preGain?: number | undefined;
+        postGain?: number | undefined;
+        attack?: number | undefined;
+        threshold?: number | undefined;
+        blend?: number | undefined;
+        ratio?: number | undefined;
+        release?: number | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type AudioCompressorProps = typeof __propDef.props;
+export type AudioCompressorEvents = typeof __propDef.events;
+export type AudioCompressorSlots = typeof __propDef.slots;
+export default class AudioCompressor extends SvelteComponent<AudioCompressorProps, AudioCompressorEvents, AudioCompressorSlots> {
+}
+export {};

package/dist/audio/AudioGain.svelte

@@ -0,0 +1,22 @@
+<script>import { getAudioContext, getConnector } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+export let gain = 1;
+let output;
+$: {
+  if (output) {
+    output.gain.setTargetAtTime(gain, output.context.currentTime, 4e-3);
+  }
+}
+const connect = getConnector((node) => {
+  node.connect(output);
+  return () => node.disconnect(output);
+});
+onMount(() => {
+  const audioCTX = audioContext();
+  output = audioCTX.createGain();
+  return connect(output);
+});
+</script>
+
+<slot />

package/dist/audio/AudioGain.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        gain?: number | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type AudioGainProps = typeof __propDef.props;
+export type AudioGainEvents = typeof __propDef.events;
+export type AudioGainSlots = typeof __propDef.slots;
+export default class AudioGain extends SvelteComponent<AudioGainProps, AudioGainEvents, AudioGainSlots> {
+}
+export {};

package/dist/audio/AudioListenerPosition.svelte

@@ -0,0 +1,94 @@
+<script>export let position = [0, 0, 0];
+export let orientation = [0, 0, 0];
+$:
+  positionX = position[0];
+$:
+  positionY = position[1];
+$:
+  positionZ = position[2];
+$:
+  roll = orientation[0];
+$:
+  pitch = orientation[1];
+$:
+  yaw = orientation[2];
+const dot = ([i, j, k], [x, y, z]) => {
+  return i * x + j * y + k * z;
+};
+const cross = ([i, j, k], [x, y, z]) => {
+  return [
+    j * z - k * y,
+    (i * z - k * x) * -1,
+    i * y - j * x
+  ];
+};
+const buildQuaternion = (roll2, pitch2, yaw2) => {
+  const rdRoll = roll2 / 360 * Math.PI;
+  const rdPitch = pitch2 / 360 * Math.PI;
+  const rdYaw = yaw2 / 360 * Math.PI;
+  const x = Math.sin(rdRoll) * Math.cos(rdPitch) * Math.cos(rdYaw) - Math.cos(rdRoll) * Math.sin(rdPitch) * Math.sin(rdYaw);
+  const y = Math.cos(rdRoll) * Math.sin(rdPitch) * Math.cos(rdYaw) + Math.sin(rdRoll) * Math.cos(rdPitch) * Math.sin(rdYaw);
+  const z = Math.cos(rdRoll) * Math.cos(rdPitch) * Math.sin(rdYaw) - Math.sin(rdRoll) * Math.sin(rdPitch) * Math.cos(rdYaw);
+  const w = Math.cos(rdRoll) * Math.cos(rdPitch) * Math.cos(rdYaw) + Math.sin(rdRoll) * Math.sin(rdPitch) * Math.sin(rdYaw);
+  return [x, y, z, w];
+};
+const rotatedVector = ([i, j, k], [x, y, z, w]) => {
+  const dotUVTimesTwo = dot([x, y, z], [i, j, k]) * 2;
+  const WxWMinusDotUU = w * w - dot([x, y, z], [x, y, z]);
+  const crossUV = cross([x, y, z], [i, j, k]);
+  return [
+    dotUVTimesTwo * x + WxWMinusDotUU * i + 2 * w * crossUV[0],
+    dotUVTimesTwo * y + WxWMinusDotUU * j + 2 * w * crossUV[1],
+    dotUVTimesTwo * z + WxWMinusDotUU * k + 2 * w * crossUV[2]
+  ];
+};
+$:
+  quaterion = buildQuaternion(roll, pitch, yaw);
+$:
+  forward = rotatedVector([1, 0, 0], quaterion);
+$:
+  up = rotatedVector([0, 1, 0], quaterion);
+import { getAudioContext } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+let audioCTX = null;
+$: {
+  if (audioCTX)
+    audioCTX.listener.positionX.value = positionX;
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.positionY.value = positionY;
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.positionZ.value = positionZ;
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.forwardX.value = forward[0];
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.forwardY.value = forward[1];
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.forwardZ.value = forward[2];
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.upX.value = up[0];
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.upY.value = up[1];
+}
+$: {
+  if (audioCTX)
+    audioCTX.listener.upZ.value = up[2];
+}
+onMount(() => {
+  audioCTX = audioContext();
+});
+</script>

package/dist/audio/AudioListenerPosition.svelte.d.ts

@@ -0,0 +1,17 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        position?: [number, number, number] | undefined;
+        orientation?: [number, number, number] | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type AudioListenerPositionProps = typeof __propDef.props;
+export type AudioListenerPositionEvents = typeof __propDef.events;
+export type AudioListenerPositionSlots = typeof __propDef.slots;
+export default class AudioListenerPosition extends SvelteComponent<AudioListenerPositionProps, AudioListenerPositionEvents, AudioListenerPositionSlots> {
+}
+export {};

package/dist/audio/AudioPanner.svelte

@@ -0,0 +1,22 @@
+<script>import { getAudioContext, getConnector } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+export let pan = 0;
+let output;
+$: {
+  if (output) {
+    output.pan.value = pan;
+  }
+}
+const connect = getConnector((node) => {
+  node.connect(output);
+  return () => node.disconnect(output);
+});
+onMount(() => {
+  const audioCtx = audioContext();
+  output = audioCtx.createStereoPanner();
+  return connect(output);
+});
+</script>
+
+<slot />

package/dist/audio/AudioPanner.svelte.d.ts

@@ -0,0 +1,18 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        pan?: number | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type AudioPannerProps = typeof __propDef.props;
+export type AudioPannerEvents = typeof __propDef.events;
+export type AudioPannerSlots = typeof __propDef.slots;
+export default class AudioPanner extends SvelteComponent<AudioPannerProps, AudioPannerEvents, AudioPannerSlots> {
+}
+export {};

package/dist/audio/BufferedAudioSource.svelte

@@ -0,0 +1,47 @@
+<script>import { getAudioContext, getConnector } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+export let volume = 1;
+export let audioBuffer;
+let output;
+let audioCTX;
+$: {
+  if (output) {
+    output.gain.setTargetAtTime(volume, output.context.currentTime, 4e-3);
+  }
+}
+const playing = /* @__PURE__ */ new Set();
+export const play = () => {
+  if (!audioBuffer)
+    return;
+  const source = audioCTX.createBufferSource();
+  source.buffer = audioBuffer;
+  source.addEventListener("ended", () => {
+    source.disconnect(output);
+    playing.delete(source);
+  });
+  source.connect(output);
+  playing.add(source);
+  source.start();
+  return () => {
+    if (playing.has(source)) {
+      source.stop();
+      source.disconnect(output);
+      playing.delete(source);
+    }
+  };
+};
+const connect = getConnector();
+onMount(() => {
+  audioCTX = audioContext();
+  output = audioCtx.createGain();
+  const disconnect = connect(output);
+  return () => {
+    for (let node of playing) {
+      node.stop();
+      node.disconnect(output);
+    }
+    disconnect();
+  };
+});
+</script>

package/dist/audio/BufferedAudioSource.svelte.d.ts

@@ -0,0 +1,19 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        volume?: number | undefined;
+        audioBuffer: AudioBuffer;
+        play?: (() => (() => void) | undefined) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type BufferedAudioSourceProps = typeof __propDef.props;
+export type BufferedAudioSourceEvents = typeof __propDef.events;
+export type BufferedAudioSourceSlots = typeof __propDef.slots;
+export default class BufferedAudioSource extends SvelteComponent<BufferedAudioSourceProps, BufferedAudioSourceEvents, BufferedAudioSourceSlots> {
+    get play(): any;
+}
+export {};

package/dist/audio/MediaAudioSource.svelte

@@ -0,0 +1,37 @@
+<script>import { getAudioContext, getConnector } from "./context.js";
+import { onMount } from "svelte";
+const audioContext = getAudioContext();
+export let url;
+export let volume = 1;
+export let paused = true;
+export let playbackPosition;
+export let loop = false;
+export const playFromStart = () => {
+  playbackPosition = 0;
+  paused = false;
+};
+export const play = () => {
+  paused = false;
+};
+export const pause = () => {
+  paused = true;
+};
+let output;
+let sourceNode;
+let element;
+$: {
+  if (output) {
+    output.gain.setTargetAtTime(volume, output.context.currentTime, 4e-3);
+  }
+}
+const connect = getConnector();
+onMount(() => {
+  const audioCTX = audioContext();
+  sourceNode = audioCTX.createMediaElementSource(element);
+  output = audioCTX.createGain();
+  sourceNode.connect(output);
+  return connect(output);
+});
+</script>
+
+<audio src={url} hidden loop={loop} bind:paused={paused} bind:currentTime={playbackPosition} bind:this={element} />

package/dist/audio/MediaAudioSource.svelte.d.ts

@@ -0,0 +1,26 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        url: string;
+        volume?: number | undefined;
+        paused?: boolean | undefined;
+        playbackPosition: number;
+        loop?: boolean | undefined;
+        playFromStart?: (() => void) | undefined;
+        play?: (() => void) | undefined;
+        pause?: (() => void) | undefined;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type MediaAudioSourceProps = typeof __propDef.props;
+export type MediaAudioSourceEvents = typeof __propDef.events;
+export type MediaAudioSourceSlots = typeof __propDef.slots;
+export default class MediaAudioSource extends SvelteComponent<MediaAudioSourceProps, MediaAudioSourceEvents, MediaAudioSourceSlots> {
+    get playFromStart(): any;
+    get play(): any;
+    get pause(): any;
+}
+export {};

package/dist/audio/context.d.ts

@@ -0,0 +1,7 @@
+export type DisconnectFunction = () => any;
+export type AudioSvelteContext = {
+    connect: (node: AudioNode) => DisconnectFunction;
+};
+export declare const getSetupAudio: (connect: (node: AudioNode) => DisconnectFunction) => void;
+export declare const getAudioContext: () => () => AudioContext;
+export declare const getConnector: (connect?: ((node: AudioNode) => DisconnectFunction) | undefined) => (node: AudioNode) => DisconnectFunction;

package/dist/audio/context.js

@@ -0,0 +1,21 @@
+import { getContext, setContext } from 'svelte';
+import { getGame } from "../core-contexts.js";
+const CONNECTOR = Symbol();
+export const getSetupAudio = function (connect) {
+    if (getContext(CONNECTOR)) {
+        throw new Error("HELP ME I AM ALREADY INSIDE AN AUDIO CONTEXT");
+    }
+    setContext(CONNECTOR, {
+        connect
+    });
+};
+export const getAudioContext = () => {
+    return getGame().getAudioContext;
+};
+export const getConnector = (connect) => {
+    const ctx = getContext(CONNECTOR);
+    if (connect) {
+        setContext(CONNECTOR, { connect });
+    }
+    return ctx.connect;
+};

package/dist/core-contexts.d.ts

@@ -32,6 +32,8 @@ export type GameContext = {
         time: number;
     }) => any | void) => () => any;
     getLayerByName: (name: string) => LayerContext | null;
+    defaultTextFontFace: Writable<string | null>;
+    getAudioContext: () => AudioContext;
 };
 export declare const setupGame: (context: GameContext) => void;
 export declare const getGame: () => GameContext;

package/dist/drawables/MultiLineText.svelte

@@ -1,5 +1,7 @@
 <script>import { setupDrawable } from "../drawable.js";
 import { onMount } from "svelte";
+import { getGame } from "../core-contexts.js";
+import { effectiveScene } from "../extras/scenes.js";
 export let text;
 export let size;
 export let spacing = 1.4;
@@ -10,8 +12,11 @@ export let stroke = void 0;
 export let strokeWidth = null;
 export let alignH = "left";
 export let alignV = "top";
+const { defaultTextFontFace } = getGame();
 $:
-  computedFont = (style ? style + " " : "") + size + "px " + font;
+  effectiveFont = font ? font : typeof $defaultTextFontFace === "string" ? $defaultTextFontFace : "sans-serif";
+$:
+  computedFont = (style ? style + " " : "") + size + "px " + effectiveFont;
 $:
   splits = text?.split("\n") || [];
 $:

package/dist/drawables/Text.svelte

@@ -1,4 +1,5 @@
 <script>import { setupDrawable } from "../drawable.js";
+import { getGame } from "..";
 import { onMount } from "svelte";
 export let text;
 export let size;
@@ -9,8 +10,11 @@ export let stroke = void 0;
 export let strokeWidth = null;
 export let alignH = "left";
 export let alignV = "top";
+const { defaultTextFontFace } = getGame();
 $:
-  computedFont = (style ? style + " " : "") + size + "px " + font;
+  effectiveFont = font ? font : typeof $defaultTextFontFace === "string" ? $defaultTextFontFace : "sans-serif";
+$:
+  computedFont = (style ? style + " " : "") + size + "px " + effectiveFont;
 const draw = function({ ctx }, { x, y, w, h }) {
   if (!text)
     return;

package/dist/drawables/Text.svelte.d.ts

@@ -3,7 +3,7 @@ declare const __propDef: {
     props: {
         text: string;
         size: number;
-        font: string;
+        font: string | undefined;
         style?: string | undefined;
         fill?: string | undefined;
         stroke?: string | undefined;

package/dist/extras/DefaultFontFace.svelte

@@ -0,0 +1,18 @@
+<script>import { getGame } from "..";
+import { onMount, createEventDispatcher } from "svelte";
+const { defaultTextFontFace } = getGame();
+const dispatch = createEventDispatcher();
+export let font;
+export let url;
+onMount(() => {
+  defaultTextFontFace.set(font);
+  if (url) {
+    const face = new FontFace(font, `url(${url})`);
+    face.load().then(() => dispatch("loaded"));
+    document.fonts.add(face);
+    return () => {
+      document.fonts.delete(face);
+    };
+  }
+});
+</script>

package/dist/extras/DefaultFontFace.svelte.d.ts

@@ -0,0 +1,25 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        /**
+             * THE DEFAULT FONT IS ONLY SET ON MOUNT. WRAP INSIDE A {key} IF THIS WILL CHANGE
+             */ font: string;
+        /**
+             * FONT FACES ARE ONLY AUTO-LOADED ON MOUNT.
+             * WRAPPING INSIDE A {key} MAY FIX THIS (not recommended)
+             * IF CHANGING FONTS, PRELOAD THEM ALL IN CSS AND UPDATE font PROP ONLY WITHIN {key} BLOCK
+             */ url: string | undefined;
+    };
+    events: {
+        loaded: CustomEvent<any>;
+    } & {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type DefaultFontFaceProps = typeof __propDef.props;
+export type DefaultFontFaceEvents = typeof __propDef.events;
+export type DefaultFontFaceSlots = typeof __propDef.slots;
+export default class DefaultFontFace extends SvelteComponent<DefaultFontFaceProps, DefaultFontFaceEvents, DefaultFontFaceSlots> {
+}
+export {};

package/dist/extras/Empty.svelte

@@ -1 +1,2 @@
+<script></script>
 <slot />

package/dist/extras/Empty.svelte.d.ts

@@ -1,15 +1,6 @@
-/** @typedef {typeof __propDef.props}  EmptyProps */
-/** @typedef {typeof __propDef.events}  EmptyEvents */
-/** @typedef {typeof __propDef.slots}  EmptySlots */
-export default class Empty {
-}
-export type EmptyProps = typeof __propDef.props;
-export type EmptyEvents = typeof __propDef.events;
-export type EmptySlots = typeof __propDef.slots;
+import { SvelteComponent } from "svelte";
 declare const __propDef: {
-    props: {
-        [x: string]: never;
-    };
+    props: Record<string, never>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
@@ -17,4 +8,9 @@ declare const __propDef: {
         default: {};
     };
 };
+export type EmptyProps = typeof __propDef.props;
+export type EmptyEvents = typeof __propDef.events;
+export type EmptySlots = typeof __propDef.slots;
+export default class Empty extends SvelteComponent<EmptyProps, EmptyEvents, EmptySlots> {
+}
 export {};

package/dist/extras/SensibleDefaultStyles.svelte

@@ -1,3 +1,5 @@
+<script></script>
+
 <div class="game-wrapper">
     <slot />
 </div>

package/dist/extras/SensibleDefaultStyles.svelte.d.ts

@@ -1,15 +1,6 @@
-/** @typedef {typeof __propDef.props}  SensibleDefaultStylesProps */
-/** @typedef {typeof __propDef.events}  SensibleDefaultStylesEvents */
-/** @typedef {typeof __propDef.slots}  SensibleDefaultStylesSlots */
-export default class SensibleDefaultStyles {
-}
-export type SensibleDefaultStylesProps = typeof __propDef.props;
-export type SensibleDefaultStylesEvents = typeof __propDef.events;
-export type SensibleDefaultStylesSlots = typeof __propDef.slots;
+import { SvelteComponent } from "svelte";
 declare const __propDef: {
-    props: {
-        [x: string]: never;
-    };
+    props: Record<string, never>;
     events: {
         [evt: string]: CustomEvent<any>;
     };
@@ -17,4 +8,9 @@ declare const __propDef: {
         default: {};
     };
 };
+export type SensibleDefaultStylesProps = typeof __propDef.props;
+export type SensibleDefaultStylesEvents = typeof __propDef.events;
+export type SensibleDefaultStylesSlots = typeof __propDef.slots;
+export default class SensibleDefaultStyles extends SvelteComponent<SensibleDefaultStylesProps, SensibleDefaultStylesEvents, SensibleDefaultStylesSlots> {
+}
 export {};

package/dist/index.d.ts

@@ -2,17 +2,20 @@ export { default as Game } from "./Game.svelte";
 export { default as Layer } from "./Layer.svelte";
 export { default as GameObject } from "./GameObject.svelte";
 export { getGame, getLayer, getTriggerLayerRender } from "./core-contexts.js";
-export type { GameContext, LayerContext, LayerDrawable } from "./core-contexts.d.ts";
+export type { GameContext, LayerContext, LayerDrawable } from "./core-contexts.js";
 export { default as MouseClickable } from "./controllers/MouseClickable.svelte";
 export { default as MouseEventArea } from "./controllers/MouseEventArea.svelte";
 export { MOUSE_ACTION } from "./controllers/mouse.js";
 export { KEYBOARD_ACTION } from "./controllers/keyboard.js";
-export { setupDrawable } from "./drawable.js";
-export type { DrawableContext, DrawableObject, DrawFunction } from "./drawable.d.ts";
+export { setupDrawable, type DrawableContext, type DrawFunction, type DrawableObject } from "./drawable.js";
 export * as Drawables from "./drawables/index.js";
 export { resolve as resolveImage } from "./resources/images.js";
-export { useTileSet, getTile } from "./resources/tileset.js";
-export type { TileSet } from "./resources/tileset.d.ts";
+export { useTileSet, getTile, type TileSet } from "./resources/tileset.js";
+export { resolveBuffer as resolveAudioBuffer } from "./resources/audio.js";
+export { default as AssetPool } from "./resources/AssetPool.svelte";
+export { default as AudioBufferedAsset } from "./resources/AudioBufferedAsset.svelte";
+export { default as AudioMediaAsset } from "./resources/AudioMediaAsset.svelte";
+export { default as ImageAsset } from "./resources/ImageAsset.svelte";
 export { default as SensibleDefaultStyles } from "./extras/SensibleDefaultStyles.svelte";
 export { default as Empty } from "./extras/Empty.svelte";
 export { default as LayerPortal } from "./extras/LayerPortal.svelte";
@@ -21,3 +24,11 @@ export { default as SceneSwitcher } from "./extras/SceneSwitcher.svelte";
 export { default as SceneTransition } from "./extras/SceneTransition.svelte";
 export { default as Rotate } from "./extras/Rotate.svelte";
 export { default as Tweened } from "./extras/Tweened.svelte";
+export { default as DefaultFontFace } from "./extras/DefaultFontFace.svelte";
+export { getAudioContext, getConnector as getAudioConnector } from "./audio/context.js";
+export { default as AudioListenerPosition } from "./audio/AudioListenerPosition.svelte";
+export { default as BufferedAudioSource } from "./audio/BufferedAudioSource.svelte";
+export { default as MediaAudioSource } from "./audio/MediaAudioSource.svelte";
+export { default as AudioGain } from "./audio/AudioGain.svelte";
+export { default as AudioPanner } from "./audio/AudioPanner.svelte";
+export { default as AudioCompressor } from "./audio/AudioCompressor.svelte";

package/dist/index.js

@@ -14,6 +14,11 @@ export * as Drawables from "./drawables/index.js";
 // RESOURCES
 export { resolve as resolveImage } from "./resources/images.js";
 export { useTileSet, getTile } from "./resources/tileset.js";
+export { resolveBuffer as resolveAudioBuffer } from "./resources/audio.js";
+export { default as AssetPool } from "./resources/AssetPool.svelte";
+export { default as AudioBufferedAsset } from "./resources/AudioBufferedAsset.svelte";
+export { default as AudioMediaAsset } from "./resources/AudioMediaAsset.svelte";
+export { default as ImageAsset } from "./resources/ImageAsset.svelte";
 // EXTRAS
 export { default as SensibleDefaultStyles } from "./extras/SensibleDefaultStyles.svelte";
 export { default as Empty } from "./extras/Empty.svelte";
@@ -23,3 +28,12 @@ export { default as SceneSwitcher } from "./extras/SceneSwitcher.svelte";
 export { default as SceneTransition } from "./extras/SceneTransition.svelte";
 export { default as Rotate } from "./extras/Rotate.svelte";
 export { default as Tweened } from "./extras/Tweened.svelte";
+export { default as DefaultFontFace } from "./extras/DefaultFontFace.svelte";
+// AUDIO
+export { getAudioContext, getConnector as getAudioConnector } from "./audio/context.js";
+export { default as AudioListenerPosition } from "./audio/AudioListenerPosition.svelte";
+export { default as BufferedAudioSource } from "./audio/BufferedAudioSource.svelte";
+export { default as MediaAudioSource } from "./audio/MediaAudioSource.svelte";
+export { default as AudioGain } from "./audio/AudioGain.svelte";
+export { default as AudioPanner } from "./audio/AudioPanner.svelte";
+export { default as AudioCompressor } from "./audio/AudioCompressor.svelte";

package/dist/resources/AssetPool.svelte

@@ -0,0 +1,11 @@
+<script></script>
+
+<div class="-llama-asset-pool--">
+    <slot />
+</div>
+
+<style>
+    .-llama-asset-pool-- {
+        display: none;
+    }
+</style>

package/dist/resources/AssetPool.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: Record<string, never>;
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {
+        default: {};
+    };
+};
+export type AssetPoolProps = typeof __propDef.props;
+export type AssetPoolEvents = typeof __propDef.events;
+export type AssetPoolSlots = typeof __propDef.slots;
+export default class AssetPool extends SvelteComponent<AssetPoolProps, AssetPoolEvents, AssetPoolSlots> {
+}
+export {};

package/dist/resources/AudioBufferedAsset.svelte

@@ -0,0 +1,7 @@
+<script>import { onMount } from "svelte";
+import { pushBufferAsset } from "./audio.js";
+export let url;
+onMount(() => {
+  pushBufferAsset(url);
+});
+</script>

package/dist/resources/AudioBufferedAsset.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        url: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type AudioBufferedAssetProps = typeof __propDef.props;
+export type AudioBufferedAssetEvents = typeof __propDef.events;
+export type AudioBufferedAssetSlots = typeof __propDef.slots;
+export default class AudioBufferedAsset extends SvelteComponent<AudioBufferedAssetProps, AudioBufferedAssetEvents, AudioBufferedAssetSlots> {
+}
+export {};

package/dist/resources/AudioMediaAsset.svelte

@@ -0,0 +1,4 @@
+<script>export let url;
+</script>
+
+<audio src={url} muted preload="auto" />

package/dist/resources/AudioMediaAsset.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        url: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type AudioMediaAssetProps = typeof __propDef.props;
+export type AudioMediaAssetEvents = typeof __propDef.events;
+export type AudioMediaAssetSlots = typeof __propDef.slots;
+export default class AudioMediaAsset extends SvelteComponent<AudioMediaAssetProps, AudioMediaAssetEvents, AudioMediaAssetSlots> {
+}
+export {};

package/dist/resources/ImageAsset.svelte

@@ -0,0 +1,12 @@
+<script>import { pushAsset } from "./images.js";
+import { onMount } from "svelte";
+export let url;
+let element;
+onMount(() => {
+  if (!element)
+    return;
+  pushAsset(url, element);
+});
+</script>
+
+<img src={url} alt="A Game Asset" bind:this={element} />

package/dist/resources/ImageAsset.svelte.d.ts

@@ -0,0 +1,16 @@
+import { SvelteComponent } from "svelte";
+declare const __propDef: {
+    props: {
+        url: any;
+    };
+    events: {
+        [evt: string]: CustomEvent<any>;
+    };
+    slots: {};
+};
+export type ImageAssetProps = typeof __propDef.props;
+export type ImageAssetEvents = typeof __propDef.events;
+export type ImageAssetSlots = typeof __propDef.slots;
+export default class ImageAsset extends SvelteComponent<ImageAssetProps, ImageAssetEvents, ImageAssetSlots> {
+}
+export {};

package/dist/resources/audio.d.ts

@@ -0,0 +1,3 @@
+export declare const pushBufferAsset: (url: string) => void;
+export declare const decodeAllBuffers: (context: AudioContext) => void;
+export declare const resolveBuffer: (url: string) => Promise<AudioBuffer | undefined>;

package/dist/resources/audio.js

@@ -0,0 +1,34 @@
+const encodedBinaryBuffers = new Map();
+const decodedBuffers = new Map();
+let instantDecode = null;
+export const pushBufferAsset = (url) => {
+    fetch(url).then(response => {
+        return response.arrayBuffer();
+    }).then(buffer => {
+        encodedBinaryBuffers.set(url, buffer);
+        if (instantDecode) {
+            instantDecode.decodeAudioData(buffer).then(audio => {
+                decodedBuffers.set(url, audio);
+            });
+        } // otherwise there's no audioContext
+    });
+};
+export const decodeAllBuffers = (context) => {
+    instantDecode = context;
+    for (let [url, binary] of encodedBinaryBuffers.entries()) {
+        instantDecode.decodeAudioData(binary).then(audio => {
+            decodedBuffers.set(url, audio);
+        });
+    }
+};
+export const resolveBuffer = async (url) => {
+    if (decodedBuffers.has(url))
+        return decodedBuffers.get(url);
+    if (encodedBinaryBuffers.has(url)) {
+        if (instantDecode) {
+            const audio = await instantDecode.decodeAudioData(encodedBinaryBuffers.get(url));
+            decodedBuffers.set(url, audio);
+            return audio;
+        }
+    }
+};

package/dist/resources/images.d.ts

@@ -1 +1,2 @@
-export declare const resolve: (src: string) => HTMLImageElement;
+export declare const pushAsset: (url: string, element: HTMLImageElement) => void;
+export declare const resolve: (url: string) => HTMLImageElement | undefined;

package/dist/resources/images.js

@@ -1,9 +1,13 @@
-let list = new Map();
-export const resolve = function (src) {
-    if (list.has(src))
-        return list.get(src);
-    let img = document.createElement("img");
-    img.src = src;
-    list.set(src, img);
+const assets = new Map();
+export const pushAsset = (url, element) => {
+    assets.set(url, element);
+};
+export const resolve = (url) => {
+    if (assets.has(url)) {
+        return assets.get(url);
+    }
+    const img = document.createElement("img");
+    img.src = url;
+    assets.set(url, img);
     return img;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hi-ashleyj/llama",
   "description": "A (Very Incomplete) 2D Canvas Game Engine powered by Svelte",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "type": "module",
   "scripts": {
     "dev": "vite dev",
@@ -22,9 +22,9 @@
   },
   "homepage": "https://github.com/hi-ashleyj/llama-game-engine#readme",
   "devDependencies": {
-    "@sveltejs/adapter-static": "latest",
-    "@sveltejs/kit": "latest",
-    "@sveltejs/package": "latest",
+    "@sveltejs/adapter-static": "^2.0.3",
+    "@sveltejs/kit": "^1.25.0",
+    "@sveltejs/package": "^2.2.2",
     "sass": "^1.58.0",
     "svelte": "^3.44.0",
     "svelte-check": "^3.4.6",