melonjs 20.2.0 → 20.3.0

package/skills/melonjs-sprites-and-animation/SKILL.md

@@ -0,0 +1,173 @@
+---
+name: melonjs-sprites-and-animation
+description: "Use this skill when creating sprites, playing frame animations, or working with texture atlases in melonJS. Covers Sprite construction from a plain image or an atlas region, addAnimation/setCurrentAnimation, TextureAtlas for TexturePacker/ShoeBox/Aseprite, tint, flip, NineSliceSprite, and the centred anchorPoint that offsets naive positioning. Triggers on: Sprite, new Sprite, addAnimation, setCurrentAnimation, isCurrentAnimation, TextureAtlas, TexturePacker, Aseprite, ShoeBox, atlas, region, framewidth, frameheight, tint, flipX, flipY, NineSliceSprite, animation."
+license: MIT
+---
+
+# Sprites, animation and atlases
+
+> Creating sprites from images or atlases, driving frame animation, and the
+> positioning trap that catches almost everyone.
+
+## `pos` is the centre, not the top-left
+
+`Renderable.anchorPoint` defaults to **`(0.5, 0.5)`**, so a sprite's `pos` is its
+**centre**. `Container` forces `(0, 0)` instead, which is why containers and
+sprites appear to disagree.
+
+```js
+// a 64×64 sprite at (100, 100) covers 68..132, not 100..164
+const s = new Sprite(100, 100, { image: "hero", framewidth: 64, frameheight: 64 });
+
+s.anchorPoint.set(0, 0);   // switch to top-left positioning if you prefer
+```
+
+Writing top-left maths against the centred default puts everything half a sprite
+off, with no error. It is the most common source of "close but subtly wrong"
+placement.
+
+## Constructing a sprite
+
+From a plain image:
+
+```js
+const hero = new Sprite(x, y, {
+    image: "hero",          // preloaded asset name
+    framewidth: 32,
+    frameheight: 32,
+});
+```
+
+From a texture atlas region:
+
+```js
+const atlas = new TextureAtlas(loader.getJSON("sprites"), loader.getImage("sprites"));
+const coin = new Sprite(x, y, { image: atlas, region: "coin_01.png" });
+```
+
+`framewidth` / `frameheight` define the animation grid on a sheet. Omit them and
+the whole image is one frame.
+
+## Animation
+
+```js
+hero.addAnimation("idle", [0, 1, 2, 3], 100);   // frames, ms per frame
+hero.addAnimation("walk", [4, 5, 6, 7]);
+hero.addAnimation("die",  [8, 9], 150);
+
+hero.setCurrentAnimation("walk");
+hero.setCurrentAnimation("die", "idle");                          // chain to idle when it ends
+hero.setCurrentAnimation("die", { loop: false });                 // play once, hold the last frame
+hero.setCurrentAnimation("die", { loop: false, onComplete: fn }); // …and call fn when it does
+
+if (hero.isCurrentAnimation("walk")) { /* … */ }
+```
+
+Frame indices are into the `framewidth`/`frameheight` grid. With an atlas, use
+`atlas.getAnimationSettings([regionNames])` and spread it into the Sprite
+settings, or `atlas.createAnimationFromName([regionNames])`, which returns a
+ready-made Sprite. On a fixed-cell spritesheet only numeric indices are
+accepted — passing region names throws.
+
+The second argument to `setCurrentAnimation` is polymorphic. A **string** chains
+to that animation when this one ends. An **options object** takes
+`{ loop, next, speed, onComplete }`, and only an explicit `loop: false` stops the
+looping. A **bare function** is the legacy form: it fires at *every* cycle end,
+and only holds the last frame if it returns `false`. Omit the argument entirely
+and the animation loops forever.
+
+Re-selecting the animation that is already current is a no-op, so calling
+`setCurrentAnimation` every frame is safe. An unknown id throws.
+
+## Texture atlases
+
+`TextureAtlas` reads several formats:
+
+| source | how |
+|---|---|
+| TexturePacker / Free Texture Packer JSON | `new TextureAtlas(loader.getJSON(name), loader.getImage(name))` |
+| Aseprite **JSON export** | same as TexturePacker — the format is detected from `meta.app` |
+| Aseprite **`.aseprite` / `.ase` binary** | loader type `"aseprite"`, which stores the composited image *and* a JSON sidecar under the one asset name |
+| ShoeBox | JSON export using the melonJS exporter settings file; same call as TexturePacker |
+| fixed-cell spritesheet | `new TextureAtlas({ framewidth, frameheight, anchorPoint }, loader.getImage(name))` |
+| multi-page | pass an array of atlas JSON objects as the first argument |
+
+Helpers: `createSpriteFromName(name)`, `createAnimationFromName([names])`,
+`getAnimationSettings([names])`.
+
+Atlases matter for performance: the GPU batchers bind several textures at once
+(up to `renderer.maxTextures`), so a handful of separate images still batch —
+but once a frame crosses that many distinct textures the batch has to flush.
+Packing into one atlas keeps everything on a single binding.
+
+## Visual properties
+
+```js
+sprite.tint.setColor(255, 128, 0);   // multiply tint
+sprite.alpha = 0.5;
+sprite.flipX(true);                   // mirror horizontally
+sprite.flipY(true);
+sprite.blendMode = "additive";        // see the effects skill for the full list
+sprite.scale(2, 2);                   // ← multiplicative, see below
+```
+
+**`scale()` is multiplicative, not absolute.** Calling it every frame compounds.
+For absolute scaling reset first:
+
+```js
+sprite.currentTransform.identity();
+sprite.currentTransform.scale(s, s, 1);
+```
+
+This bites hardest with pooled sprites, which arrive carrying their previous
+life's transform.
+
+## `NineSliceSprite`
+
+For panels and dialogue boxes that stretch without distorting their corners:
+
+```js
+new NineSliceSprite(x, y, {
+    image: "panel", width: 300, height: 120,
+    insetx: 12, insety: 12,     // lowercase x/y — `insetX` is silently ignored
+});
+```
+
+`width` and `height` are mandatory and the constructor throws without them.
+The insets default to a quarter of the frame.
+
+## Pooling
+
+Frequently spawned sprites should be pooled:
+
+```js
+pool.register("bullet", Bullet, true);      // true = recyclable
+const b = pool.pull("bullet", x, y);        // new Bullet(x, y), or onResetEvent(x, y) on a reused one
+world.removeChild(b);                       // returns it to the pool automatically
+```
+
+Two consequences:
+
+- A recyclable class's `onResetEvent` must reset **everything** its lifetime
+  mutates — alpha, tint, scale, animation state. Anything you forget carries
+  over to the next use.
+- Pool-recycled objects do **not** fire `onDestroyEvent` on removal. Pair event
+  subscriptions with `onActivateEvent` / `onDeactivateEvent` instead.
+
+## Symptom → cause
+
+| symptom | cause |
+|---|---|
+| everything offset by half a sprite | top-left maths against the centred `anchorPoint` |
+| sprite grows every frame | `scale()` is multiplicative — reset the transform |
+| a recycled sprite keeps its old look | `onResetEvent` does not restore every mutated property |
+| event handlers leak on pooled objects | bound in the constructor rather than `onActivateEvent` |
+| animation never advances | no `framewidth`/`frameheight`, so the sheet is one frame |
+| animation plays once and stops | `{ loop: false }`, or a callback that returned `false` |
+| sprites do not batch | more distinct textures in one frame than `renderer.maxTextures` |
+| nine-slice corners stretch anyway | `insetX`/`insetY` instead of `insetx`/`insety` |
+
+## Related skills
+
+- `melonjs-renderables` — anchors, draw order, custom draw
+- `melonjs-getting-started` — preloading images and atlases

package/skills/melonjs-tilemaps/SKILL.md

@@ -0,0 +1,193 @@
+---
+name: melonjs-tilemaps
+description: "Use this skill for Tiled maps in melonJS — loading TMX/TSX levels, spawning entities from Tiled objects, collision shapes authored in Tiled, isometric and hexagonal maps, and image layers. Covers the pool.register name contract, camera bounds, compressed maps needing the inflate plugin, and the level director API. Triggers on: Tiled, TMX, TSX, tilemap, level.load, tileset, ImageLayer, isometric, hexagonal, staggered, pool.register, Collectable, Trigger, object layer, collision layer, parallax."
+license: MIT
+---
+
+# Tiled maps
+
+> melonJS's flagship content pipeline. Maps are authored in
+> [Tiled](https://www.mapeditor.org/) and loaded through the `level` director —
+> you rarely touch the `TMX*` classes directly.
+
+## Loading a level
+
+Preload the map **and** everything it references — the `.tmx`, any external
+`.tsx` tilesets, and the tileset images:
+
+```js
+await loader.preload([
+    { name: "map1",    type: "tmx", src: "data/map/map1.tmx" },
+    { name: "tileset", type: "tsx", src: "data/map/tileset.tsx" },
+    { name: "tiles",   type: "image", src: "data/img/tiles.png" },
+]);
+
+level.load("map1");           // inside Stage.onResetEvent
+```
+
+Asset `type` is `"tmx"` for maps and `"tsx"` for external tilesets — those are
+the only two type strings the loader knows. The *file* can be `.tmx` / `.tsx`
+(XML), or `.json` / `.tmj` / `.tsj`; the parser branches on the extension, not
+on the type. `type: "tmj"` throws `unknown or invalid resource type`. You can
+also skip `src` and pass the map inline via `data` (with `format: "json"` or
+`"xml"`).
+
+`level.load(levelId, options)` accepts `container` (default `game.world`),
+`onLoaded` (default `game.onLevelLoaded`), `flatten` (default `game.mergeGroup`)
+and `setViewportBounds` (default **`true`**). It throws `level <id> not found`
+for an unknown id.
+
+**`level.load` is deferred while the game loop is running.** It calls
+`state.stop()` and finishes the load in a `setTimeout`, so it returns `true`
+before anything is in the world. Do follow-up work from the `onLoaded` callback
+or an `event.LEVEL_LOADED` listener, not on the next line.
+
+`level.reload()`, `level.next()`, `level.previous()`, `level.getCurrentLevelId()`
+and `level.levelCount()` round out the namespace. `flatten: false` wraps each
+Tiled object group in its own `Container` named after the group.
+
+## Spawning entities from Tiled objects
+
+Objects are matched against a factory registry, in this order: the object's
+Tiled **class**, then its **name**, then the structural fallbacks `"text"`,
+`"tile"` and `"shape"`.
+
+```js
+pool.register("mainPlayer", PlayerEntity);   // ← matches Tiled class OR name
+level.load("map1");
+```
+
+`pool.register(className, classObj, recycling)` also registers the class as a
+Tiled object factory (and again under an `me.`-prefixed alias), unless you set
+`pool.autoRegisterTiled = false`. The dedicated entry points are:
+
+```js
+import { registerTiledObjectClass, registerTiledObjectFactory } from "melonjs";
+
+registerTiledObjectClass("Enemy", Enemy);            // new Enemy(x, y, settings)
+registerTiledObjectFactory("Spine", (settings, map) => { /* → Renderable */ });
+```
+
+Register **before** loading. With no match the object falls through to the
+structural factory and becomes a plain `Renderable` with a static body — it does
+not error, it just has none of your behaviour.
+
+`registerTiledObjectClass` **throws** if you register a *different* constructor
+under a name already taken (re-registering the same one is a no-op).
+`registerTiledObjectFactory` overwrites and only `console.warn`s, so it is the
+one to use for overriding a built-in such as `"shape"`.
+
+melonJS pre-registers `Renderable`, `Sprite`, `NineSliceSprite`, `Text`,
+`BitmapText`, `ImageLayer`, `ColorLayer`, `Light2d`, `Collectable` and `Trigger`
+as Tiled classes, so `Collectable` and `Trigger` work out of the box.
+
+## Camera bounds
+
+`level.load` sets the viewport bounds to the map size for you —
+`setViewportBounds` defaults to `true`, and the handler is re-run on every
+viewport resize, centring the map when it is smaller than the screen. You only
+need to do it by hand when you opted out:
+
+```js
+level.load("map1", { setViewportBounds: false });
+app.viewport.setBounds(0, 0, mapWidth, mapHeight);   // now it's on you
+```
+
+The same is true if you drive `TMXTileMap.addTo(container, flatten, setViewportBounds)`
+directly — note that method's `setViewportBounds` defaults to **`false`**, the
+opposite of `level.load`'s.
+
+## Collision shapes
+
+Draw collision geometry in Tiled on an object layer and melonJS turns it into
+world shapes automatically — rectangles, polygons, polylines, ellipses and
+points all work.
+
+The contract is the **layer name**: melonJS lowercases it and checks whether it
+*contains* `"collision"` (so `collision`, `Collision`, `world collision` all
+match). Inside such a layer, objects **with no name** get
+`collisionType = collision.types.WORLD_SHAPE` and `type = "static"`. A *named*
+object in a collision layer keeps whatever its factory gave it — that is how you
+mix triggers into the collision layer.
+
+An object that matches no factory and carries no text or tile data falls to the
+`"shape"` factory: a plain `Renderable` with a static `bodyDef` built from its
+geometry, which the world auto-registers with the active adapter on `addChild`.
+
+For per-object physics, set the object's custom properties in Tiled; they arrive
+on the settings object passed to your entity's constructor.
+
+## Map orientations
+
+Orthogonal, **isometric**, hexagonal, staggered and oblique are all supported;
+anything else throws `<orientation> type TMX Tile Map not supported!` at load.
+Isometric maps need y-sorting so objects overlap correctly:
+
+```js
+app.world.sortOn = "y";       // after level.load
+```
+
+`sortOn` only accepts `"x"`, `"y"`, `"z"` (the default) or `"depth"` and throws
+on anything else. `Vector2d`, `Vector3d`, their observable variants and `Polygon`
+all carry `.toIso()` / `.to2d()` for converting between screen and map space.
+
+## Image layers
+
+`ImageLayer` gives parallax backgrounds with a ratio per axis, set in Tiled or in
+code. Repeat behaviour matches Tiled's.
+
+## Compressed maps need a plugin
+
+A map saved with **gzip, zlib or zstd** compressed layer data throws
+`No inflate function set — GZIP/ZLIB decompression not supported!` at parse time
+without:
+
+```js
+import { plugin } from "melonjs";
+import { TiledInflatePlugin } from "@melonjs/tiled-inflate-plugin";
+
+plugin.register(TiledInflatePlugin);   // before preloading any compressed map
+```
+
+Uncompressed base64 and CSV layer data need no plugin. If a map loads in Tiled
+but not in melonJS, check the layer compression setting first.
+
+## Rendering
+
+Each tile layer resolves to one of three `renderMode`s — `"shader"`,
+`"prerender"` or `"perTile"` — auto-selected in that order of preference, or
+forced per layer. The `"shader"` path is a single quad per tileset with a
+per-pixel GID lookup in the fragment shader. It requires **all** of:
+
+- a renderer that reports GPU tile-layer support (WebGL 2 / WebGPU — not Canvas),
+- `world.gpuTilemap !== false` (the `gpuTilemap` application setting, default `true`),
+- an **orthogonal** layer — isometric, hexagonal, staggered and oblique always
+  fall back,
+- no collection-of-image tileset, no non-zero `tileoffset`, and tile overflow
+  within the shader's 4-cell limit.
+
+When a layer falls back, melonJS `console.warn`s once with the reason. Practical
+consequences: fewer tilesets means fewer batches (one packed tileset beats
+several small ones), and on the Canvas fallback large maps get noticeably
+slower. `world.preRender` (or a `preRender` layer property in Tiled) opts an
+unanimated layer into the offscreen-bake path instead.
+
+## Symptom → cause
+
+| symptom | cause |
+|---|---|
+| a Tiled object becomes a plain shape with no behaviour | its class/name does not match any registered factory, or it was registered after `level.load` |
+| the world is still empty right after `level.load` | the load is deferred via `setTimeout` while the loop runs — use `onLoaded` / `LEVEL_LOADED` |
+| `level <id> not found` | the map was never preloaded, or the asset `name` differs from the id passed to `load` |
+| `unknown or invalid resource type` | asset `type` set to `"tmj"` / `"tsj"` — use `"tmx"` / `"tsx"` with the `.tmj` / `.tsj` file |
+| camera will not scroll | `setViewportBounds: false`, or the map was added with `addTo()` (which defaults to `false`) |
+| `No inflate function set` at parse time | compressed layers without the tiled-inflate plugin |
+| collision shapes are not solid | the object layer's name does not contain `"collision"`, or the objects are named |
+| isometric objects overlap wrongly | `world.sortOn` not set to `"y"` |
+| missing tiles or a blank map | the `.tsx` or tileset image was not preloaded |
+| tilemap slow on some machines | layer fell back off the shader path — check the console warning for the reason |
+
+## Related skills
+
+- `melonjs-physics` — what the collision shapes become once loaded
+- `melonjs-getting-started` — preloading and the asset type list

package/skills/melonjs-ui-and-text/SKILL.md

@@ -0,0 +1,175 @@
+---
+name: melonjs-ui-and-text
+description: "Use this skill for HUDs, buttons, menus, dialogue panels and on-screen text in melonJS. Covers UIBaseElement/UISpriteElement/UITextButton, Draggable and DropTarget, the floating screen-space container pattern, Text and BitmapText, web font loading, and NineSliceSprite panels. Triggers on: UI, HUD, button, UIBaseElement, UISpriteElement, UITextButton, Draggable, DropTarget, menu, dialogue, Text, BitmapText, font, fontface, wordWrapWidth, NineSliceSprite, score display, floating."
+license: MIT
+---
+
+# UI, HUD and text
+
+## The HUD pattern
+
+A HUD is a `floating` container at a high z, built once and re-added:
+
+```js
+class HUD extends Container {
+    constructor(app) {
+        super(0, 0, app.viewport.width, app.viewport.height);
+        this.floating = true;       // screen space, not world space
+        this.isPersistent = true;   // survives a world reset
+    }
+}
+
+app.world.addChild(new HUD(app), 100);   // explicit z — not `.z = Infinity`
+```
+
+There is no `UIContainer` class. Use `Container`, or `UIBaseElement` when the
+panel itself must react to the pointer — it is a `Container` that already sets
+`floating = true` and `isKinematic = false`.
+
+Three things matter here:
+
+- **`floating = true`** opts the container out of camera transforms, so it stays
+  put while the world scrolls. Without it the HUD scrolls away — a silent
+  failure.
+- **Only the parent container needs `floating`.** `addChild` forces
+  `child.floating = false` under a floating parent, and the container applies one
+  projection swap for the whole subtree.
+- **Pass an explicit z.** `this.z = Number.POSITIVE_INFINITY` appears in several
+  shipped examples and does nothing — `renderable.z` is not a real property. The
+  real accessor is `depth` (an alias for `pos.z`); `addChild(child, z)` sets it
+  for you.
+
+Relayout on resize by listening for `event.CANVAS_ONRESIZE`.
+
+## Buttons and interactive elements
+
+Use the built-ins rather than hand-rolling — they set `isKinematic = false` for
+you, which is the trap that stops hand-rolled buttons receiving clicks at all.
+
+```js
+class PlayButton extends UISpriteElement {
+    constructor(x, y) {
+        super(x, y, { image: atlas, region: "play.png" });
+    }
+    onClick()   { state.change(state.PLAY); return false; }
+    onOver()    { this.setOpacity(1.0); }
+    onOut()     { this.setOpacity(0.8); }
+    onRelease() { return false; }
+}
+```
+
+| class | for |
+|---|---|
+| `UIBaseElement` | a `Container` base — clickable, optionally draggable and holdable |
+| `UISpriteElement` | a `Sprite`-backed button with hover/press callbacks |
+| `UITextButton` | a `BitmapText` label on a `RoundRect` background — it needs a **bitmap** font, not a `fontface` |
+| `Draggable` / `DropTarget` | drag-and-drop; `dropTarget.setCheckMethod(dropTarget.CHECKMETHOD_CONTAINS)` to require containment instead of overlap |
+
+The callbacks to override are `onClick`, `onOver`, `onOut`, `onRelease` and
+`onHold`; `UIBaseElement` adds `onMove` while dragging. Returning `false` from
+`onClick` / `onRelease` stops the event propagating further.
+
+## Text
+
+```js
+new Text(x, y, {
+    font: "Arial",
+    size: 32,
+    fillStyle: "#FFFFFF",
+    textAlign: "center",
+    textBaseline: "middle",
+    text: "Score: 0",
+    wordWrapWidth: 400,        // enables wrapping
+});
+```
+
+`text` accepts a string or an array of lines. Update with `setText()`.
+
+**Custom web fonts must be preloaded** with the `"fontface"` asset type:
+
+```js
+{ name: "PressStart2P", type: "fontface", src: "data/font/PressStart2P.ttf" }
+```
+
+Drawing before the font has loaded silently renders in a fallback font — the
+layout looks subtly wrong rather than failing.
+
+## `BitmapText`
+
+For pixel-perfect text that scales without antialiasing, and for text drawn in
+volume: every `BitmapText` sharing a font draws glyph quads from that one page
+image, so they batch together. Each `Text` instead owns a private canvas
+texture (re-rasterised whenever it changes), so a screenful of them is a
+screenful of distinct textures.
+
+```js
+await loader.preload([
+    { name: "PressStart2P", type: "image",  src: "data/font/font.png" },
+    { name: "PressStart2P", type: "binary", src: "data/font/font.fnt" },
+]);
+
+new BitmapText(x, y, {
+    font: "PressStart2P",
+    size: 2,                  // a scale ratio, not a pixel size
+    text: "GAME OVER",
+});
+```
+
+It needs **both** assets, and by default they must share the **same asset
+name** — `settings.font` resolves the image *and*, unless you pass
+`settings.fontData`, the descriptor. Registering the descriptor under a
+different name (`"…-fnt"`) is the usual mistake; either use one name for both,
+or pass `fontData: "PressStart2P-fnt"` explicitly.
+
+The descriptor is AngelCode BMFont in either flavour — the text `.fnt` form or
+the XML form — auto-detected, so an `.xml` export loads as-is.
+
+## Never draw text through the raw context
+
+```js
+// ✗ works on Canvas only — getContext() returns the GL/GPU context on the
+//   GPU backends, and neither has fillText
+app.renderer.getContext().fillText("hi", 10, 10);
+
+// ✓
+world.addChild(new Text(10, 10, { text: "hi", /* … */ }));
+```
+
+`getContext()` hands back the *backend's* context — a
+`CanvasRenderingContext2D` only under the Canvas renderer. On WebGL or WebGPU
+the call throws `TypeError: … .fillText is not a function`, so this fails loudly
+— but only on the machines that picked a GPU backend, which under `video.AUTO`
+is most of them and probably not yours.
+
+## Panels
+
+`NineSliceSprite` stretches a panel without distorting its corners — the right
+tool for dialogue boxes and windows:
+
+```js
+new NineSliceSprite(x, y, {
+    image: "panel", width: 300, height: 120, insetx: 12, insety: 12,
+});
+```
+
+The inset keys are lowercase `insetx` / `insety`; `insetX` is silently ignored
+and the corners fall back to a quarter of the frame. `width` and `height` are
+mandatory — the constructor throws without them.
+
+## Symptom → cause
+
+| symptom | cause |
+|---|---|
+| HUD scrolls away with the camera | missing `floating = true` on the container |
+| HUD drawn under the game | `this.z = …` instead of `addChild(hud, z)` |
+| hand-rolled button never responds | `isKinematic` left `true` — use `UISpriteElement` |
+| text renders in the wrong font | web font not preloaded as `"fontface"` |
+| `BitmapText` renders nothing | the `.fnt` / image pair was loaded under two different asset names |
+| `TypeError: … .fillText is not a function` | drawn via `getContext()` under a GPU backend |
+| `UIContainer is not defined` | no such class — use `Container` or `UIBaseElement` |
+| UI misplaced after a window resize | no `CANVAS_ONRESIZE` relayout |
+
+## Related skills
+
+- `melonjs-input` — the `isKinematic` requirement in full
+- `melonjs-renderables` — `floating`, draw order, containers

package/build/audio/backend.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"backend.d.ts","sourceRoot":"","sources":["../../src/audio/backend.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,IAAI,EAAU,MAAM,QAAQ,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,IAAI,gBAAgB,EAAE,OAAc,CAAC;AAE5C;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAExD;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,KAAK;YACH,MAAM,CAAC,MAAM,EAAE,IAAI,GAAG,SAAS,CAAC;oBACtB,MAAM,GAAG,IAAI;mBAChB,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;eAC1B,MAAM,EAAE;CACzB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAMxD;AAED;;;;;GAKG;AACH,eAAO,MAAM,cAAc,GAC1B,YAAY,MAAM,EAClB,aAAa,MAAM,IAAI,EACvB,cAAa,OAAc,KACzB,IAqBF,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,eAAe,IAAI,YAAY,GAAG,IAAI,CAmBrD;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,IAAI,QAAQ,GAAG,IAAI,CAS/C;AAUD;;;GAGG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,IAAI,CAE/C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAEnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAKvC;AAED;;;GAGG;AACH,wBAAgB,eAAe,IAAI,IAAI,CAEtC;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAO/C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,OAAO,CAE1C"}

package/build/loader/parsers/fetchdata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fetchdata.d.ts","sourceRoot":"","sources":["../../../src/loader/parsers/fetchdata.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,oCALW,MAAM,aACN,MAAM,GACJ,OAAO,CAKnB;AA2DD;;;;;;;;;;;;;;;GAeG;AACH,+BAdW,MAAM,gBACN,MAAM,aACN,MAAM,gBAkDhB"}