rig-play 0.8.0 → 1.1.0

package/dist/DomTexture.js

@@ -1,520 +0,0 @@
-import { Texture, } from '@esotericsoftware/spine-core';
-/**
- * Minimal Texture implementation for the DOM renderer. spine-core only needs
- * it as a handle attached to atlas pages; filtering/wrapping are GPU concepts
- * with no DOM equivalent, so they are no-ops.
- */
-export class DomTexture extends Texture {
-    setFilters(_minFilter, _magFilter) { }
-    setWraps(_uWrap, _vWrap) { }
-    dispose() { }
-}
-/**
- * Blob URLs minted by unpackRegions, i.e. the ones this module owns.
- *
- * Ownership has to be tracked because a RegionImage map is not necessarily
- * ours: callers may hand the renderer a map built from their own URLs (loose
- * part PNGs need no unpacking at all). revokeRegions() therefore frees only
- * what is listed here and leaves caller-owned URLs untouched.
- */
-const ownedUrls = new Set();
-/** Revokes `url` if unpackRegions minted it. Idempotent, caller-safe. */
-function revokeOwned(url) {
-    if (!ownedUrls.delete(url))
-        return;
-    URL.revokeObjectURL(url);
-}
-/**
- * Straight-alpha derivations of `pma: true` page images, one per image.
- *
- * Spine's texture packer premultiplies by default, and an atlas says so with a
- * `pma: true` page line: the file's RGB is already multiplied by its alpha. The
- * DOM and canvas 2D have no such mode — an <img> and `drawImage` composite
- * straight alpha by definition, so they multiply by alpha again and every
- * semi-transparent texel comes out darker than it was authored (#37). Both
- * consumers of that convention here — the region cuts below and the canvas2d
- * mesh raster in SpineHtmlRenderer — therefore read this derivation instead of
- * the page, and it is *shared*: deriving per consumer would pay for the same
- * page once per renderer and once again for the load.
- *
- * (The GL mesh backend needs no derivation. It consumes premultiplied texels by
- * construction, so it just skips `UNPACK_PREMULTIPLY_ALPHA_WEBGL` at upload —
- * lossless, and the reason the two backends differ at all on such a page.)
- *
- * Weak by the page image, exactly like the GL texture cache: this package never
- * pins the caller's image, and a page the caller drops takes its derivation
- * with it. So nothing has to be freed by hand and `dispose()` stays out of it —
- * the ownership boundary is the same one `revokeRegions` respects.
- *
- * **What it costs while alive:** one page-sized canvas per `pma` page image
- * (4 bytes/px — 1 MiB for a 1024×256 page, 16 MiB for a 2048×2048 one), held
- * for as long as the caller holds the page. It is deliberately *not* charged to
- * the cut-backing budget below: that budget bounds the canvases in flight
- * during a load, a peak that appears and drains, while this sits alongside the
- * decoded page itself for the page's whole life — the same category as the
- * decoded pages the budget already documents as resident throughout.
- */
-const straightAlphaPages = new WeakMap();
-/** Derivations performed since load — see straightAlphaDerivations(). */
-let derivationCount = 0;
-/**
- * How many straight-alpha page derivations have been built in this document.
- *
- * Deterministic (no GC in the path) and monotonic, so a test reads it before
- * and after and asserts the *difference*. Exported for the tests only — it is
- * not re-exported from index.ts and the `exports` map denies deep imports, so
- * it is not package API. (The same arrangement as `liveTextureCount` on the GL
- * blitter, and for the same reason: a cache that works is invisible.)
- */
-export function straightAlphaDerivations() {
-    return derivationCount;
-}
-/**
- * The page as a straight-alpha source: the image itself when `pma` is false,
- * otherwise its (cached) un-premultiplied derivation.
- *
- * `rgb = round(rgb * 255 / a)`, clamped, with `a === 0` left at (0,0,0,0) —
- * there is no colour to recover from a fully transparent texel.
- *
- * **Precision.** The division is done in 8 bits and cannot be done anywhere
- * else: a 2D canvas stores premultiplied colour, so `getImageData` hands back
- * `round(round(u * a / 255) * 255 / a)` for a file value `u`, already quantized
- * by the read (measured on both engines: put→get moves a value by up to 127 at
- * a = 1). The colour a low-alpha texel composites to is therefore off by at
- * most ~min(a, 127.5/a + 0.5) of 255 — nothing at a = 255 or a = 0, ≤ 1 above
- * a = 128, worst ~12 around a = 11, and bounded by `a` below that. Writing the
- * values back is exact, not a second premultiply: the canvas quantizer is
- * idempotent, so putting a value that came out of it stores it unchanged
- * (measured: a second round trip moves nothing on either engine). The remaining
- * error is one-way rounding on near-invisible texels, against a defect that
- * darkened every semi-transparent texel by up to 59 luma.
- *
- * A page image that cannot be read — no 2D context, or a cross-origin image
- * without CORS, where `getImageData` throws — falls back to the page itself and
- * caches *that*: the colour is then as wrong as it is today, but it happens
- * once per image instead of once per frame, and no frame throws. (The cut path
- * already fails on such an image at `toBlob`, so only the mesh tier can get
- * here.) An image that has not decoded yet is left uncached, so the derivation
- * happens once it has.
- */
-export function straightAlphaSource(page, pma) {
-    if (!pma)
-        return page;
-    const cached = straightAlphaPages.get(page);
-    if (cached)
-        return cached;
-    const width = page.naturalWidth;
-    const height = page.naturalHeight;
-    // Nothing to read yet: decide later rather than caching an empty canvas.
-    if (!(width > 0) || !(height > 0))
-        return page;
-    const derived = unpremultiply(page, width, height);
-    straightAlphaPages.set(page, derived);
-    if (derived !== page)
-        derivationCount++;
-    return derived;
-}
-/** The pixel pass behind straightAlphaSource; `page` back on any read failure. */
-function unpremultiply(page, width, height) {
-    const canvas = document.createElement('canvas');
-    canvas.width = width;
-    canvas.height = height;
-    // No willReadFrequently: this reads once and is then a drawImage *source*
-    // for the rest of its life, which wants the accelerated surface.
-    const ctx = canvas.getContext('2d');
-    if (!ctx)
-        return page;
-    ctx.drawImage(page, 0, 0);
-    let pixels;
-    try {
-        pixels = ctx.getImageData(0, 0, width, height);
-    }
-    catch {
-        // Tainted canvas (cross-origin page image, no CORS).
-        return page;
-    }
-    const data = pixels.data;
-    for (let i = 0; i < data.length; i += 4) {
-        const a = data[i + 3];
-        if (a === 255)
-            continue;
-        if (a === 0) {
-            // Nothing to divide by, and nothing there to see.
-            data[i] = 0;
-            data[i + 1] = 0;
-            data[i + 2] = 0;
-            continue;
-        }
-        const scale = 255 / a;
-        // Rounded explicitly: assigning a fraction to a Uint8ClampedArray rounds
-        // half-to-even, which is not the rule stated above.
-        data[i] = Math.min(255, Math.round(data[i] * scale));
-        data[i + 1] = Math.min(255, Math.round(data[i + 1] * scale));
-        data[i + 2] = Math.min(255, Math.round(data[i + 2] * scale));
-    }
-    ctx.putImageData(pixels, 0, 0);
-    return canvas;
-}
-/**
- * Backing pixels the cuts still waiting for their PNG encode may hold at once.
- *
- * A started cut keeps its canvas alive until `toBlob` calls back, so starting
- * every region at once peaks at Σ(cut area) of canvas backing — on top of the
- * decoded pages, which stay resident throughout. A cut is allocated at the
- * page image's own resolution, so what is charged here is that area, not the
- * region's atlas-unit area: a half-resolution page costs a quarter of it, an
- * @2x page four times it. Measured by counting the simultaneously-alive cut
- * canvases and their backing at `toBlob` (chromium, 1:1 pages):
- * the demo's 40-region 1024×256 atlas peaks at all 40 cuts and 194,742 px
- * (0.19 Mpx ≈ 0.74 MiB), which is nothing; a synthetic 256-region atlas on
- * four 2048×2048 pages peaks at 16.78 Mpx ≈ 64 MiB, which doubles that
- * atlas's resident cost for the length of the load.
- *
- * So the cuts are started against a budget rather than all at once. 4 Mpx is
- * one 2048×2048 page's worth (≈ 16 MiB at 4 bytes/px): small atlases still run
- * every region concurrently (spineboy: all 40, budget never engaged), and the
- * synthetic one runs 64 cuts at a time — 4 waves instead of 256 serial
- * encodes, for a quarter of the peak. A single region bigger than the budget
- * is started anyway when nothing else is in flight, so the budget can never
- * starve a cut.
- */
-const CUT_BACKING_BUDGET_PX = 4 * 1024 * 1024;
-/**
- * Locates a region on its page image.
- *
- * **The rect is read in the image's own frame, not in declared atlas pixels.**
- * An atlas `size:` line and the image that ships for the page need not agree:
- * projects export textures at half resolution (or @2x) and leave the atlas
- * alone. Every official Spine runtime absorbs that for free, because
- * spine-core turns a region's bounds into *normalized* UVs against the
- * declared page size (`region.u = region.x / page.width`) and a GPU samples
- * normalized coordinates at whatever resolution the texture happens to have.
- * So the rect here is the region's bounds relative to the declared page size,
- * times the image's natural size — the continuous `uv * size` frame both mesh
- * backends already address texels in. No `size - 1`, no half-texel term: this
- * maps a rect, it does not sample.
- *
- * With a page that does ship at its declared size the scale is exactly 1 and
- * every number below is the region's own integer bounds, unchanged.
- *
- * Rotation: a region packed at 90° lies on its side, so it occupies a
- * `height × width` rect on the page — which is how spine-core reads it too
- * (`u2 = (x + height) / page.width` when `degrees === 90`). The cut canvas is
- * the rect turned back upright, so the bitmap comes out in artwork
- * orientation. *Which way* back is `cutRegion`'s, derived there from the UVs
- * spine-core assigns such a region and not from this plan.
- *
- * Rounding: each *edge* is rounded to the nearest image pixel, rather than the
- * width being rounded on its own. Neighbouring regions share an edge, so
- * rounding the edge keeps their cuts tiling the image exactly — no gap, no
- * overlap, and at most half a pixel of either region's own content given up on
- * a boundary that falls mid-pixel. Rounding outward would instead pull a whole
- * neighbouring pixel into every cut on every side, which is bleed the caller
- * can see. A rect that scales down below one pixel still gets a 1×1 bitmap,
- * since a zero-sized canvas is not one.
- *
- * The alternative was measured, not argued away (#35): sampling the
- * *fractional* rect with interpolation — what a GPU does with normalized UVs —
- * buys exact placement with a resample of the whole bitmap. Both rules drew
- * the same frozen rigid-only pose from a rescaled page, diffed against that
- * pose drawn from the 1:1 page. The result is split, so the lossless copy
- * stays: sampling lowers the raw difference and the peak channel delta, while
- * rounding lowers the count of pixels with no in-tolerance match anywhere in
- * the reference's 3×3 — rounding displaces the picture, which a shift-tolerant
- * compare forgives, and sampling blurs it, which it does not. On that
- * shift-tolerant count at 0.5×, the common case, rounding is ahead in every
- * cell measured, by 1.3× to 2.2× (chromium 638 vs 1238, webkit 1443 vs 1888) —
- * an ordering rather than a count, since the counts themselves move with the
- * raster. At an integer page scale the two rules come out bit-identical, there
- * being no fractional part to disagree about, so an @2x page never had a
- * question to answer. `tests/cut-rule.spec.ts` holds the 0.5× half of this.
- */
-function planCut(region, image) {
-    const iw = image.naturalWidth;
-    const ih = image.naturalHeight;
-    // A page with no `size:` line (or a malformed one) declares nothing, so the
-    // image is taken to be its own declared size — which is what this did for
-    // every page before the frame above existed.
-    const pageW = region.page.width > 0 ? region.page.width : iw;
-    const pageH = region.page.height > 0 ? region.page.height : ih;
-    const rotated = region.degrees === 90;
-    const packedW = rotated ? region.height : region.width;
-    const packedH = rotated ? region.width : region.height;
-    // Whole-page pass-through: an unrotated region covering its entire page
-    // would be cut into a pixel-for-pixel copy of the page image, so reuse the
-    // page URL instead — no canvas, no PNG re-encode, no second decoded copy in
-    // memory, and nothing to revoke afterwards. Atlases written as one part per
-    // page (the loose-part-PNG workflow, where every part is declared its own
-    // page) hit this for every single region.
-    //
-    // The test is against the declared page size, at any image resolution: a
-    // whole page is a whole page whether it ships at 1×, half or double, and the
-    // cut would copy the image either way. (It used to be tested against the
-    // image, which was the same rule as long as the two always agreed.)
-    //
-    // Except on a premultiplied page, where the page URL is exactly what must not
-    // be handed through: those pixels are premultiplied and an <img> composites
-    // straight alpha, so passing the URL along would ship the defect to the one
-    // atlas shape that never even allocates a canvas (one part per page). Such a
-    // region is cut like any other — from the straight-alpha derivation — and the
-    // blob it mints is owned and revoked like any other.
-    if (!region.page.pma &&
-        !rotated &&
-        region.x === 0 &&
-        region.y === 0 &&
-        packedW === pageW &&
-        packedH === pageH) {
-        return { passThrough: true, sx: 0, sy: 0, sw: iw, sh: ih, cw: iw, ch: ih };
-    }
-    const scaleX = iw / pageW;
-    const scaleY = ih / pageH;
-    const x0 = Math.round(region.x * scaleX);
-    const y0 = Math.round(region.y * scaleY);
-    const sw = Math.max(1, Math.round((region.x + packedW) * scaleX) - x0);
-    const sh = Math.max(1, Math.round((region.y + packedH) * scaleY) - y0);
-    return {
-        passThrough: false,
-        sx: x0,
-        sy: y0,
-        sw,
-        sh,
-        cw: rotated ? sh : sw,
-        ch: rotated ? sw : sh,
-    };
-}
-/** Backing pixels one cut allocates — the charge against the budget above. */
-function cutBackingPixels(region, pageImages) {
-    const image = pageImages.get(region.page.name);
-    // No image: this region is about to fail in the cut. Charging its atlas
-    // units keeps the walk moving until it does.
-    if (!image)
-        return region.width * region.height;
-    const plan = planCut(region, image);
-    return plan.cw * plan.ch;
-}
-/**
- * One region's bitmap: the whole-page pass-through, or a cut canvas encoded to
- * a blob URL this module then owns.
- *
- * The cut is a **1:1 copy of the source rect** planCut located — never a
- * resample — so the bitmap has the native resolution of those pixels, while
- * the `RegionImage` sizes reported alongside it stay in atlas units. A page
- * shipped at half resolution therefore costs a quarter of the cut pixels and
- * still poses identically; upscaling the cut back to declared size would only
- * quadruple the pixels and add a resample.
- *
- * Everything before the `toBlob` await runs synchronously, so calling this is
- * what "starts" a cut: the canvas is painted and the encode is handed to the
- * browser before control comes back.
- */
-async function cutRegion(region, pageImages) {
-    const image = pageImages.get(region.page.name);
-    if (!image)
-        throw new Error(`Missing page image: ${region.page.name}`);
-    const w = region.width;
-    const h = region.height;
-    const plan = planCut(region, image);
-    if (plan.passThrough)
-        return { url: image.src, width: w, height: h };
-    const canvas = document.createElement('canvas');
-    canvas.width = plan.cw;
-    canvas.height = plan.ch;
-    const ctx = canvas.getContext('2d');
-    if (!ctx)
-        throw new Error('2d context unavailable');
-    if (region.degrees === 90) {
-        // The region is packed rotated. Turn the destination frame back so the
-        // source rect, drawn at its own size, lands upright and fills the canvas —
-        // and turn it *clockwise*, which is derived from spine-core's UVs rather
-        // than from anything this file does.
-        //
-        // `TextureAtlas` takes `u`/`v` from the packed rect's top-left corner and,
-        // at `degrees === 90`, `u2`/`v2` from `x + height` / `y + width` — the
-        // rect's far edges. `RegionAttachment` then hands the artwork's corners out
-        // in the rigid tier's own order, BL, UL, UR, BR, as
-        //
-        //   BL (u2, v2)   UL (u, v2)   UR (u, v)   BR (u2, v)
-        //
-        // so the artwork's top-left corner is the packed rect's *bottom-left* and
-        // its top-right is the rect's *top-left*: the artwork's top edge runs up
-        // the rect's left edge, which is a packer that turned it counter-clockwise.
-        //
-        // `translate(cw, 0); rotate(+π/2)` maps a pixel (x, y) of the source rect —
-        // sw × sh on the page, and cw = sh, ch = sw — to canvas (cw − y, x), which
-        // is that turn undone:
-        //
-        //   packed bottom-left  (0, sh)   → (0, 0)    the cut's top-left     = UL
-        //   packed top-left     (0, 0)    → (cw, 0)   the cut's top-right    = UR
-        //   packed top-right    (sw, 0)   → (cw, ch)  the cut's bottom-right = BR
-        //   packed bottom-right (sw, sh)  → (0, ch)   the cut's bottom-left  = BL
-        //
-        // Until #49 this was `translate(0, ch); rotate(−π/2)`, mapping (x, y) to
-        // (y, ch − x): a *second* counter-clockwise turn, landing the artwork's
-        // top-left at the cut's bottom-right. The bitmap came out 180° round, and
-        // since `renderRegion` pins a bitmap's top-left to the attachment's UL
-        // corner either way, every rotated rigid part was drawn inverted — from the
-        // first commit of this package to 0.7.0. The mesh tier never was: it
-        // samples the page through the UVs above.
-        ctx.translate(plan.cw, 0);
-        ctx.rotate(Math.PI / 2);
-    }
-    // Straight alpha on a premultiplied page, since the cut is encoded to a PNG
-    // and shown in an <img>. The rect was planned against the image, and the
-    // derivation is that image's own size, so the coordinates carry over
-    // unchanged — including on a page that ships at another resolution.
-    const source = straightAlphaSource(image, region.page.pma);
-    ctx.drawImage(source, plan.sx, plan.sy, plan.sw, plan.sh, 0, 0, plan.sw, plan.sh);
-    const blob = await new Promise((resolve, reject) => {
-        canvas.toBlob((b) => (b ? resolve(b) : reject(new Error('toBlob failed'))), 'image/png');
-    });
-    const url = URL.createObjectURL(blob);
-    ownedUrls.add(url);
-    return { url, width: w, height: h };
-}
-/**
- * Cuts every atlas region out of the page image into its own bitmap once at
- * load time, restoring 90° packing rotation, so the per-frame path never
- * touches a canvas. Returns image URLs keyed by region name.
- *
- * This is a loading-pipeline step, not a rendering step: after this runs,
- * rendering is pure DOM (one <img> per slot, one CSS matrix write per frame).
- *
- * A region that covers its whole page unrotated skips the cut and reuses the
- * page image URL — see the pass-through in planCut.
- *
- * **A page may ship at a resolution its atlas does not declare.** Half-size
- * texture builds and @2x variants are normal, and no option is needed for
- * them: a region's bounds are read relative to the declared page size and
- * scaled onto the image's natural size, which is exactly how spine-core
- * derives the UVs the mesh tier already samples with. Each bitmap comes out at
- * the native resolution of the pixels it was cut from, and the `RegionImage`
- * sizes beside it stay in atlas units, so nothing downstream has to know.
- *
- * *Behaviour change (0.5.1 → next).* An atlas whose `size:` line is simply
- * wrong — bounds written in image pixels under a page declared some other size
- * — used to be cut "as the coordinates say", because the cut read the image
- * directly. It is now read the way every other Spine runtime reads it:
- * relative to the declared size. Such an atlas rendered with a skewed mesh
- * tier and an intact rigid tier before; now both tiers agree, and the fix is
- * to correct the `size:` line.
- *
- * **The cuts run concurrently.** PNG encoding is asynchronous and the browser
- * does it off the main thread, so the encodes are started together and awaited
- * together instead of one `toBlob` per iteration: awaited in series a load
- * costs the *sum* of every encode, which a throttled document turns into one
- * full throttle period per region (measured: a single 8×8 `toBlob` took 7.5 s
- * to call back in a hidden desktop Chromium pane). How many run at once is
- * bounded by CUT_BACKING_BUDGET_PX above, not by an option.
- *
- * Concurrency changes nothing a caller can observe:
- *
- * - **Order.** The returned map is keyed in `atlas.regions` order whatever
- *   order the blobs arrive in — the map is built after the cuts settle, from
- *   the region list, not from the arrivals.
- * - **Duplicate names.** The last region of a given name in atlas order wins,
- *   and the shadowed URL is revoked (and dropped from the ledger) rather than
- *   stranded.
- * - **Failure.** Every URL this call minted is revoked before the error
- *   propagates, *including cuts that were still in flight when the first
- *   failure happened* — their blobs arrive later, and a load that walked away
- *   from them would mint owned URLs nobody could ever revoke. So a failure
- *   stops new cuts from starting but still waits for the started ones, and the
- *   error it raises is the one from the earliest region in atlas order (what
- *   the serial loop used to throw). Nothing here rejects unobserved.
- *
- * The blob URLs stay alive until revokeRegions() frees them — a document-wide
- * allocation the GC cannot reclaim on its own. Callers that load and unload
- * skeletons repeatedly (cutscenes, level transitions) must pair every
- * unpackRegions() with a revokeRegions(); a caller that loads once for the
- * page lifetime can ignore it.
- */
-export async function unpackRegions(atlas, pageImages) {
-    const regions = atlas.regions;
-    const cuts = new Array(regions.length);
-    // The earliest-in-atlas-order failure is the one that propagates, so that a
-    // broken atlas reports the same region whichever encode happens to land
-    // first.
-    let failedIndex = -1;
-    let failure;
-    let inFlight = [];
-    let inFlightPixels = 0;
-    for (let index = 0; index < regions.length && failedIndex === -1; index++) {
-        const region = regions[index];
-        if (!region)
-            continue;
-        // A pass-through allocates no canvas, but it also resolves without waiting
-        // for anything, so charging it the page's area costs at most one drain.
-        const pixels = cutBackingPixels(region, pageImages);
-        while (inFlight.length > 0 && inFlightPixels + pixels > CUT_BACKING_BUDGET_PX) {
-            await Promise.race(inFlight.map((job) => job.promise));
-            inFlight = inFlight.filter((job) => !job.done);
-            if (failedIndex !== -1)
-                break;
-        }
-        if (failedIndex !== -1)
-            break;
-        inFlightPixels += pixels;
-        const job = { done: false, promise: Promise.resolve() };
-        // Jobs settle, they never reject: the failure is recorded here so that
-        // nothing is left for an unhandled-rejection handler to find.
-        job.promise = (async () => {
-            try {
-                cuts[index] = await cutRegion(region, pageImages);
-            }
-            catch (error) {
-                if (failedIndex === -1 || index < failedIndex) {
-                    failedIndex = index;
-                    failure = error;
-                }
-            }
-            finally {
-                inFlightPixels -= pixels;
-                job.done = true;
-            }
-        })();
-        inFlight.push(job);
-    }
-    // Every cut this call started is settled after this, so the cleanup below
-    // reaches the blobs that arrived after the first failure too.
-    await Promise.all(inFlight.map((job) => job.promise));
-    if (failedIndex !== -1) {
-        for (const cut of cuts)
-            if (cut)
-                revokeOwned(cut.url);
-        throw failure;
-    }
-    const result = new Map();
-    for (let index = 0; index < regions.length; index++) {
-        const region = regions[index];
-        const cut = cuts[index];
-        if (!region || !cut)
-            continue;
-        // Duplicate region names would otherwise strand the shadowed URL in the
-        // ledger with nothing left pointing at it. Map.set keeps the key where it
-        // first appeared, so atlas order survives the overwrite.
-        const shadowed = result.get(region.name);
-        if (shadowed)
-            revokeOwned(shadowed.url);
-        result.set(region.name, cut);
-    }
-    return result;
-}
-/**
- * Frees the blob URLs unpackRegions minted for `images` — the counterpart of
- * unpackRegions, to call once the skeletons using them are gone (after
- * `renderer.dispose()`, since a live <img> would keep pointing at a dead URL).
- *
- * Only URLs this module created are revoked: entries the caller supplied
- * itself (a hand-built map of loose part PNGs) and page images reused
- * verbatim by the whole-page pass-through are left alone. Idempotent —
- * revoking twice is a no-op, so it is safe on a map that is shared or
- * partially reused.
- *
- * The map keeps its entries; drop the reference (or reload) afterwards, since
- * the URLs no longer resolve.
- */
-export function revokeRegions(images) {
-    for (const image of images.values())
-        revokeOwned(image.url);
-}
-//# sourceMappingURL=DomTexture.js.map

package/dist/DomTexture.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"DomTexture.js","sourceRoot":"","sources":["../src/DomTexture.ts"],"names":[],"mappings":"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"}