bloody-engine 1.0.3 → 1.0.5

package/dist/node/index.js

@@ -1,4 +1,5 @@
 import createGL from "gl";
+import sdl from "@kmamal/sdl";
 import * as fs from "fs/promises";
 import * as path from "path";
 class BrowserRenderingContext {
@@ -365,6 +366,99 @@ class GraphicsDevice {
     );
   }
 }
+class SDLWindow {
+  constructor(width, height, title = "Bloody Engine") {
+    this.closed = false;
+    this.width = width;
+    this.height = height;
+    this.title = title;
+    try {
+      this.window = sdl.video.createWindow({
+        width: this.width,
+        height: this.height,
+        title: this.title
+      });
+      if (!this.window) {
+        throw new Error("Failed to create SDL window");
+      }
+      this.window.on("close", () => {
+        this.closed = true;
+      });
+      console.log(`✓ SDL Window created (${width}x${height}): "${title}"`);
+    } catch (error) {
+      this.cleanup();
+      throw new Error(`Window creation failed: ${error}`);
+    }
+  }
+  /**
+   * Get window dimensions
+   */
+  getDimensions() {
+    return { width: this.width, height: this.height };
+  }
+  /**
+   * Display pixel data in the window
+   * @param pixels Uint8Array of RGBA pixel data
+   */
+  updatePixels(pixels) {
+    if (!this.window || this.closed) {
+      return;
+    }
+    try {
+      const buffer2 = Buffer.from(pixels);
+      const stride = this.width * 4;
+      this.window.render(this.width, this.height, stride, "rgba32", buffer2);
+    } catch (error) {
+      console.error("Failed to update pixels:", error);
+    }
+  }
+  /**
+   * Register an event handler
+   */
+  on(eventName, handler) {
+    if (!this.window || this.closed) {
+      return;
+    }
+    try {
+      this.window.on(eventName, (event) => {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`Error in ${eventName} handler:`, error);
+        }
+      });
+    } catch (error) {
+      console.error(`Error registering ${eventName} handler:`, error);
+    }
+  }
+  /**
+   * Check if window is still open
+   */
+  isOpen() {
+    return this.window !== null && !this.closed;
+  }
+  /**
+   * Cleanup and close window
+   */
+  cleanup() {
+    if (this.window && !this.closed) {
+      try {
+        this.window.destroy();
+      } catch (error) {
+        console.warn("Error destroying window:", error);
+      }
+      this.window = null;
+      this.closed = true;
+    }
+    console.log("✓ SDL Window cleaned up");
+  }
+  /**
+   * Destroy the window (alias for cleanup)
+   */
+  destroy() {
+    this.cleanup();
+  }
+}
 class Texture {
   /**
    * Create a texture from pixel data
@@ -1132,6 +1226,301 @@ class SpriteBatchRenderer {
     }
   }
 }
+class GPUBasedSpriteBatchRenderer {
+  /**
+   * Create a new GPU-based sprite batch renderer (V3)
+   * @param gl WebGL rendering context
+   * @param shader Shader program to use (should be SHADERS_V3)
+   * @param maxQuads Maximum number of quads to batch (default 1000)
+   * @param tileSize Tile size for isometric projection (default {width: 64, height: 32})
+   * @param zScale Scale factor for Z height (default 1.0)
+   */
+  constructor(gl, shader, maxQuads = 1e3, tileSize = { width: 64, height: 32 }, zScale = 1) {
+    this.vertexBuffer = null;
+    this.quads = [];
+    this.isDirty = false;
+    this.verticesPerQuad = 6;
+    this.floatsPerVertex = 12;
+    this.texture = null;
+    this.depthTestEnabled = true;
+    this.gl = gl;
+    this.shader = shader;
+    this.maxQuads = maxQuads;
+    this.tileSize = tileSize;
+    this.zScale = zScale;
+    this.resolution = { width: gl.canvas.width, height: gl.canvas.height };
+    const totalFloats = maxQuads * this.verticesPerQuad * this.floatsPerVertex;
+    this.vertexData = new Float32Array(totalFloats);
+    const buf = gl.createBuffer();
+    if (!buf) {
+      throw new Error("Failed to create vertex buffer");
+    }
+    this.vertexBuffer = buf;
+    gl.bindBuffer(gl.ARRAY_BUFFER, this.vertexBuffer);
+    gl.bufferData(gl.ARRAY_BUFFER, this.vertexData.byteLength, gl.DYNAMIC_DRAW);
+    gl.bindBuffer(gl.ARRAY_BUFFER, null);
+  }
+  /**
+   * Set the texture for batch rendering
+   * @param texture The texture to use when rendering
+   */
+  setTexture(texture) {
+    this.texture = texture;
+  }
+  /**
+   * Add a sprite quad to the batch
+   * If gridX and gridY are provided, uses GPU transformation.
+   * Otherwise, converts x, y to grid coordinates.
+   * @param quad Sprite quad instance to add
+   */
+  addQuad(quad) {
+    if (this.quads.length >= this.maxQuads) {
+      console.warn(`Sprite batch renderer at max capacity (${this.maxQuads})`);
+      return;
+    }
+    this.quads.push(quad);
+    this.isDirty = true;
+  }
+  /**
+   * Clear all quads from the batch
+   */
+  clear() {
+    this.quads = [];
+    this.isDirty = true;
+  }
+  /**
+   * Get number of quads currently in batch
+   */
+  getQuadCount() {
+    return this.quads.length;
+  }
+  /**
+   * Update the batch - rebuilds vertex buffer if quads changed
+   */
+  update() {
+    if (!this.isDirty || this.quads.length === 0) {
+      return;
+    }
+    let vertexIndex = 0;
+    for (const quad of this.quads) {
+      const {
+        x,
+        y,
+        z = 0,
+        width,
+        height,
+        color = { r: 1, g: 1, b: 1, a: 1 },
+        uvRect = { uMin: 0, vMin: 0, uMax: 1, vMax: 1 },
+        texIndex = 0,
+        gridX,
+        gridY
+      } = quad;
+      let gx, gy;
+      if (gridX !== void 0 && gridY !== void 0) {
+        gx = gridX;
+        gy = gridY;
+      } else {
+        gx = (x / (this.tileSize.width * 0.5) + y / (this.tileSize.height * 0.5)) * 0.5;
+        gy = (y / (this.tileSize.height * 0.5) - x / (this.tileSize.width * 0.5)) * 0.5;
+      }
+      const halfW = width / 2;
+      const halfH = height / 2;
+      const corners = [
+        [-halfW, -halfH],
+        // bottom-left
+        [halfW, -halfH],
+        // bottom-right
+        [halfW, halfH],
+        // top-right
+        [halfW, halfH],
+        // top-right (duplicate)
+        [-halfH, halfH],
+        // top-left
+        [-halfW, -halfH]
+        // bottom-left (duplicate)
+      ];
+      const texCoords = [
+        [uvRect.uMin, uvRect.vMin],
+        [uvRect.uMax, uvRect.vMin],
+        [uvRect.uMax, uvRect.vMax],
+        [uvRect.uMax, uvRect.vMax],
+        [uvRect.uMin, uvRect.vMax],
+        [uvRect.uMin, uvRect.vMin]
+      ];
+      for (let i = 0; i < corners.length; i++) {
+        const [localX, localY] = corners[i];
+        const [u, v] = texCoords[i];
+        this.vertexData[vertexIndex++] = gx;
+        this.vertexData[vertexIndex++] = gy;
+        this.vertexData[vertexIndex++] = z;
+        this.vertexData[vertexIndex++] = localX;
+        this.vertexData[vertexIndex++] = localY;
+        this.vertexData[vertexIndex++] = u;
+        this.vertexData[vertexIndex++] = v;
+        this.vertexData[vertexIndex++] = color.r;
+        this.vertexData[vertexIndex++] = color.g;
+        this.vertexData[vertexIndex++] = color.b;
+        this.vertexData[vertexIndex++] = color.a;
+        this.vertexData[vertexIndex++] = texIndex;
+      }
+    }
+    if (this.vertexBuffer) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      this.gl.bufferSubData(
+        this.gl.ARRAY_BUFFER,
+        0,
+        this.vertexData.subarray(0, vertexIndex)
+      );
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+    this.isDirty = false;
+  }
+  /**
+   * Set whether depth testing is enabled
+   * @param enabled Whether to enable depth testing (default true)
+   */
+  setDepthTestEnabled(enabled) {
+    this.depthTestEnabled = enabled;
+  }
+  /**
+   * Render the batch with GPU-based transformation
+   * @param camera Camera for view transform
+   */
+  render(camera) {
+    if (this.quads.length === 0) {
+      return;
+    }
+    this.update();
+    this.shader.use();
+    if (this.depthTestEnabled) {
+      this.gl.enable(this.gl.DEPTH_TEST);
+      this.gl.depthFunc(this.gl.LEQUAL);
+    } else {
+      this.gl.disable(this.gl.DEPTH_TEST);
+    }
+    if (this.vertexBuffer) {
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, this.vertexBuffer);
+      const stride = this.floatsPerVertex * 4;
+      const attrs = {
+        gridPosition: this.shader.getAttributeLocation("aGridPosition"),
+        zPosition: this.shader.getAttributeLocation("aZPosition"),
+        localOffset: this.shader.getAttributeLocation("aLocalOffset"),
+        texCoord: this.shader.getAttributeLocation("aTexCoord"),
+        color: this.shader.getAttributeLocation("aColor"),
+        texIndex: this.shader.getAttributeLocation("aTexIndex")
+      };
+      if (attrs.gridPosition !== -1) {
+        this.gl.enableVertexAttribArray(attrs.gridPosition);
+        this.gl.vertexAttribPointer(
+          attrs.gridPosition,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          0
+        );
+      }
+      if (attrs.zPosition !== -1) {
+        this.gl.enableVertexAttribArray(attrs.zPosition);
+        this.gl.vertexAttribPointer(
+          attrs.zPosition,
+          1,
+          this.gl.FLOAT,
+          false,
+          stride,
+          2 * 4
+        );
+      }
+      if (attrs.localOffset !== -1) {
+        this.gl.enableVertexAttribArray(attrs.localOffset);
+        this.gl.vertexAttribPointer(
+          attrs.localOffset,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          3 * 4
+        );
+      }
+      if (attrs.texCoord !== -1) {
+        this.gl.enableVertexAttribArray(attrs.texCoord);
+        this.gl.vertexAttribPointer(
+          attrs.texCoord,
+          2,
+          this.gl.FLOAT,
+          false,
+          stride,
+          5 * 4
+        );
+      }
+      if (attrs.color !== -1) {
+        this.gl.enableVertexAttribArray(attrs.color);
+        this.gl.vertexAttribPointer(
+          attrs.color,
+          4,
+          this.gl.FLOAT,
+          false,
+          stride,
+          7 * 4
+        );
+      }
+      if (attrs.texIndex !== -1) {
+        this.gl.enableVertexAttribArray(attrs.texIndex);
+        this.gl.vertexAttribPointer(
+          attrs.texIndex,
+          1,
+          this.gl.FLOAT,
+          false,
+          stride,
+          11 * 4
+        );
+      }
+      if (this.texture) {
+        this.texture.bind(0);
+        const textureUniform = this.shader.getUniformLocation("uTexture");
+        if (textureUniform !== null) {
+          this.gl.uniform1i(textureUniform, 0);
+        }
+      }
+      const tileSizeUniform = this.shader.getUniformLocation("uTileSize");
+      if (tileSizeUniform !== null) {
+        this.gl.uniform2f(tileSizeUniform, this.tileSize.width, this.tileSize.height);
+      }
+      const cameraUniform = this.shader.getUniformLocation("uCamera");
+      if (cameraUniform !== null) {
+        this.gl.uniform3f(cameraUniform, camera.x, camera.y, camera.zoom);
+      }
+      const zScaleUniform = this.shader.getUniformLocation("uZScale");
+      if (zScaleUniform !== null) {
+        this.gl.uniform1f(zScaleUniform, this.zScale);
+      }
+      const resolutionUniform = this.shader.getUniformLocation("uResolution");
+      if (resolutionUniform !== null) {
+        this.gl.uniform2f(resolutionUniform, this.resolution.width, this.resolution.height);
+      }
+      const rotationUniform = this.shader.getUniformLocation("uRotation");
+      if (rotationUniform !== null) {
+        this.gl.uniform1f(rotationUniform, 0);
+      }
+      const quadSizeUniform = this.shader.getUniformLocation("uQuadSize");
+      if (quadSizeUniform !== null) {
+        this.gl.uniform2f(quadSizeUniform, 1, 1);
+      }
+      const vertexCount = this.quads.length * this.verticesPerQuad;
+      this.gl.drawArrays(this.gl.TRIANGLES, 0, vertexCount);
+      this.gl.bindBuffer(this.gl.ARRAY_BUFFER, null);
+    }
+  }
+  /**
+   * Clean up GPU resources
+   */
+  dispose() {
+    if (this.vertexBuffer) {
+      this.gl.deleteBuffer(this.vertexBuffer);
+      this.vertexBuffer = null;
+    }
+  }
+}
 class Matrix4 {
   /**
    * Create an identity matrix
@@ -1399,6 +1788,14 @@ class Camera {
     return { x: screenX, y: screenY };
   }
 }
+class ProjectionConfig {
+  // Scale factor for height (vertical exaggeration)
+  constructor(tileWidth = 64, tileHeight = 32, zScale = 1) {
+    this.tileWidth = tileWidth;
+    this.tileHeight = tileHeight;
+    this.zScale = zScale;
+  }
+}
 class BrowserResourceLoader {
   /**
    * Create a new browser resource loader
@@ -2341,14 +2738,17 @@ export {
   BrowserResourceLoader,
   Camera,
   Environment,
+  GPUBasedSpriteBatchRenderer,
   GraphicsDevice,
   IndexBuffer,
   Matrix4,
   NodeRenderingContext,
   NodeResourceLoader,
+  ProjectionConfig,
   RenderingContextFactory,
   ResourceLoaderFactory,
   ResourcePipeline,
+  SDLWindow,
   Shader,
   SpriteBatchRenderer,
   Texture,

package/dist/web/core/buffer.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Vertex Buffer abstraction
+ * Manages vertex data for rendering
+ */
+export declare class VertexBuffer {
+    private buffer;
+    private gl;
+    private vertexCount;
+    private stride;
+    constructor(gl: WebGLRenderingContext, data: Float32Array, stride?: number);
+    /**
+     * Bind buffer for rendering
+     */
+    bind(): void;
+    /**
+     * Unbind buffer
+     */
+    unbind(): void;
+    /**
+     * Get vertex count
+     */
+    getVertexCount(): number;
+    /**
+     * Get stride
+     */
+    getStride(): number;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+/**
+ * Index Buffer abstraction
+ * Manages index data for indexed rendering
+ */
+export declare class IndexBuffer {
+    private buffer;
+    private gl;
+    private indexCount;
+    constructor(gl: WebGLRenderingContext, data: Uint16Array);
+    /**
+     * Bind buffer for rendering
+     */
+    bind(): void;
+    /**
+     * Unbind buffer
+     */
+    unbind(): void;
+    /**
+     * Get index count
+     */
+    getIndexCount(): number;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+}
+//# sourceMappingURL=buffer.d.ts.map

package/dist/web/core/buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffer.d.ts","sourceRoot":"","sources":["../../../src/core/buffer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,EAAE,CAAwB;IAClC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,MAAM,CAAS;gBAGrB,EAAE,EAAE,qBAAqB,EACzB,IAAI,EAAE,YAAY,EAClB,MAAM,GAAE,MAAU;IAoBpB;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;OAEG;IACH,cAAc,IAAI,MAAM;IAIxB;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,OAAO,IAAI,IAAI;CAGhB;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,MAAM,CAAc;IAC5B,OAAO,CAAC,EAAE,CAAwB;IAClC,OAAO,CAAC,UAAU,CAAS;gBAEf,EAAE,EAAE,qBAAqB,EAAE,IAAI,EAAE,WAAW;IAgBxD;;OAEG;IACH,IAAI,IAAI,IAAI;IAIZ;;OAEG;IACH,MAAM,IAAI,IAAI;IAId;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;OAEG;IACH,OAAO,IAAI,IAAI;CAGhB"}

package/dist/web/core/grahpic-device.d.ts

@@ -0,0 +1,66 @@
+import { RenderingContext } from '../rendering/rendering-context';
+import { Shader } from './shader';
+/**
+ * Graphics device that manages rendering context and WebGL operations
+ * Uses standardized RenderingContext interface, never directly references DOM
+ */
+export declare class GraphicsDevice {
+    private context;
+    constructor(width: number, height: number);
+    /**
+     * Get the underlying WebGL rendering context
+     */
+    getGLContext(): WebGLRenderingContext;
+    /**
+     * Get the rendering context
+     */
+    getRenderingContext(): RenderingContext;
+    /**
+     * Get current width
+     */
+    getWidth(): number;
+    /**
+     * Get current height
+     */
+    getHeight(): number;
+    /**
+     * Get viewport dimensions
+     */
+    getViewport(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Check if running in browser
+     */
+    isBrowser(): boolean;
+    /**
+     * Resize the graphics device
+     */
+    resize(width: number, height: number): void;
+    /**
+     * Clear the rendering surface
+     */
+    clear(color?: {
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+    }): void;
+    /**
+     * Present the rendered frame
+     */
+    present(): void;
+    /**
+     * Cleanup and release resources
+     */
+    dispose(): void;
+    /**
+     * Create a shader program
+     * @param vertexSource Vertex shader source code
+     * @param fragmentSource Fragment shader source code
+     * @returns Compiled and linked shader program
+     */
+    createShader(vertexSource: string, fragmentSource: string): Shader;
+}
+//# sourceMappingURL=grahpic-device.d.ts.map

package/dist/web/core/grahpic-device.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grahpic-device.d.ts","sourceRoot":"","sources":["../../../src/core/grahpic-device.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAEvE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAElC;;;GAGG;AACH,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAmB;gBAEtB,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IASzC;;OAEG;IACH,YAAY,IAAI,qBAAqB;IAIrC;;OAEG;IACH,mBAAmB,IAAI,gBAAgB;IAIvC;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,WAAW,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAIhD;;OAEG;IACH,SAAS,IAAI,OAAO;IAIpB;;OAEG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAI3C;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,EAAE;QAAE,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;IAInE;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;OAEG;IACH,OAAO,IAAI,IAAI;IAIf;;;;;OAKG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,GAAG,MAAM;CAQnE"}

package/dist/web/core/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Bloody Engine - Browser Entry Point
+ *
+ * Demo is disabled by default for npm package.
+ * To run the demo locally, uncomment the code below or run:
+ *   npm run dev
+ */
+//# sourceMappingURL=index.d.ts.map

package/dist/web/core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG"}

package/dist/web/core/resource-loader-factory.d.ts

@@ -0,0 +1,90 @@
+import { IResourceLoader } from './resource-loader';
+/**
+ * Environment type enumeration
+ */
+export declare enum Environment {
+    /** Browser environment (DOM APIs available) */
+    BROWSER = "browser",
+    /** Node.js environment (file system APIs available) */
+    NODE = "node",
+    /** Unknown environment */
+    UNKNOWN = "unknown"
+}
+/**
+ * Resource loader factory configuration
+ */
+export interface ResourceLoaderFactoryOptions {
+    /**
+     * Force a specific environment (useful for testing)
+     * If not specified, the factory will auto-detect the environment
+     */
+    forceEnvironment?: Environment;
+    /**
+     * Base URL for browser resource loader
+     */
+    baseUrl?: string;
+    /**
+     * Request timeout for browser resource loader (in milliseconds)
+     */
+    timeout?: number;
+    /**
+     * Base directory for Node.js resource loader
+     */
+    baseDir?: string;
+}
+/**
+ * Factory class for creating resource loaders
+ * Automatically detects the runtime environment and creates the appropriate loader
+ */
+export declare class ResourceLoaderFactory {
+    /**
+     * Detect the current runtime environment
+     * @returns The detected environment type
+     */
+    static detectEnvironment(): Environment;
+    /**
+     * Check if the current environment is a browser
+     * @returns true if running in a browser
+     */
+    static isBrowser(): boolean;
+    /**
+     * Check if the current environment is Node.js
+     * @returns true if running in Node.js
+     */
+    static isNode(): boolean;
+    /**
+     * Create a resource loader for the current environment
+     * @param options Optional factory configuration
+     * @returns A resource loader instance appropriate for the current platform
+     * @throws Error if the environment is not supported
+     */
+    static create(options?: ResourceLoaderFactoryOptions): Promise<IResourceLoader>;
+    /**
+     * Create a browser resource loader
+     * @param options Optional factory configuration
+     * @returns A browser resource loader instance
+     */
+    static createBrowserLoader(options?: ResourceLoaderFactoryOptions): Promise<IResourceLoader>;
+    /**
+     * Create a Node.js resource loader
+     * @param options Optional factory configuration
+     * @returns A Node.js resource loader instance
+     */
+    static createNodeLoader(options?: ResourceLoaderFactoryOptions): Promise<IResourceLoader>;
+    /**
+     * Create a resource loader with automatic fallback
+     * If the preferred loader is not available, falls back to the available loader
+     * @param preferredEnvironment Preferred environment
+     * @param options Optional factory configuration
+     * @returns A resource loader instance
+     */
+    static createWithFallback(preferredEnvironment: Environment, options?: ResourceLoaderFactoryOptions): Promise<IResourceLoader>;
+}
+/**
+ * Convenience function to create a resource loader
+ * Shortcut for ResourceLoaderFactory.create()
+ * @param options Optional factory configuration
+ * @returns A resource loader instance
+ */
+export declare function createResourceLoader(options?: ResourceLoaderFactoryOptions): Promise<IResourceLoader>;
+//# sourceMappingURL=resource-loader-factory.d.ts.map

package/dist/web/core/resource-loader-factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-loader-factory.d.ts","sourceRoot":"","sources":["../../../src/core/resource-loader-factory.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEzD;;GAEG;AACH,oBAAY,WAAW;IACrB,+CAA+C;IAC/C,OAAO,YAAY;IACnB,uDAAuD;IACvD,IAAI,SAAS;IACb,0BAA0B;IAC1B,OAAO,YAAY;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,4BAA4B;IAC3C;;;OAGG;IACH,gBAAgB,CAAC,EAAE,WAAW,CAAC;IAE/B;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,qBAAa,qBAAqB;IAChC;;;OAGG;IACH,MAAM,CAAC,iBAAiB,IAAI,WAAW;IAsBvC;;;OAGG;IACH,MAAM,CAAC,SAAS,IAAI,OAAO;IAI3B;;;OAGG;IACH,MAAM,CAAC,MAAM,IAAI,OAAO;IAIxB;;;;;OAKG;WACU,MAAM,CAAC,OAAO,CAAC,EAAE,4BAA4B,GAAG,OAAO,CAAC,eAAe,CAAC;IAuBrF;;;;OAIG;WACU,mBAAmB,CAC9B,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,eAAe,CAAC;IAQ3B;;;;OAIG;WACU,gBAAgB,CAC3B,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,eAAe,CAAC;IAQ3B;;;;;;OAMG;WACU,kBAAkB,CAC7B,oBAAoB,EAAE,WAAW,EACjC,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,eAAe,CAAC;CAS5B;AAED;;;;;GAKG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,CAAC,EAAE,4BAA4B,GACrC,OAAO,CAAC,eAAe,CAAC,CAE1B"}