pixi-effects 0.48.1 → 0.48.2

package/dist/{chunk-V3VBHSK6.cjs → chunk-Z3DM4ETD.cjs}

@@ -2,27 +2,7 @@
 
 var chunkNGJXVJB7_cjs = require('./chunk-NGJXVJB7.cjs');
 var chunkDOLTCXCL_cjs = require('./chunk-DOLTCXCL.cjs');
-var PIXI = require('pixi.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var PIXI__namespace = /*#__PURE__*/_interopNamespace(PIXI);
+var pixi_js = require('pixi.js');
 
 // src/core/spring.ts
 var SETTLE_TOL = 5e-3;
@@ -948,7 +928,7 @@ function colorNumber(v) {
 }
 function viaPixi(s) {
   try {
-    const [r, g, b, a] = new PIXI.Color(s).toArray();
+    const [r, g, b, a] = new pixi_js.Color(s).toArray();
     return [Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a];
   } catch {
     return null;
@@ -1690,10 +1670,10 @@ fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
 `;
 function toRgb01(input) {
   if (Array.isArray(input)) return [input[0], input[1], input[2]];
-  const c = new PIXI.Color(input);
+  const c = new pixi_js.Color(input);
   return [c.red, c.green, c.blue];
 }
-var ChromaKeyFilter = class extends PIXI.Filter {
+var ChromaKeyFilter = class extends pixi_js.Filter {
   constructor(options = {}) {
     const {
       keyColor = "#00ff00",
@@ -1701,12 +1681,12 @@ var ChromaKeyFilter = class extends PIXI.Filter {
       smoothing = 0.1,
       spill = 0.2
     } = options;
-    const glProgram = PIXI.GlProgram.from({
-      vertex: PIXI.defaultFilterVert,
+    const glProgram = pixi_js.GlProgram.from({
+      vertex: pixi_js.defaultFilterVert,
       fragment: GL_FRAGMENT,
       name: "chroma-key-filter"
     });
-    const gpuProgram = PIXI.GpuProgram.from({
+    const gpuProgram = pixi_js.GpuProgram.from({
       vertex: { source: WGSL_SOURCE, entryPoint: "mainVertex" },
       fragment: { source: WGSL_SOURCE, entryPoint: "mainFragment" }
     });
@@ -1714,7 +1694,7 @@ var ChromaKeyFilter = class extends PIXI.Filter {
       glProgram,
       gpuProgram,
       resources: {
-        chromaUniforms: new PIXI.UniformGroup({
+        chromaUniforms: new pixi_js.UniformGroup({
           uKeyColor: { value: toRgb01(keyColor), type: "vec3<f32>" },
           uThreshold: { value: threshold, type: "f32" },
           uSmoothing: { value: smoothing, type: "f32" },
@@ -1898,17 +1878,17 @@ fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
   return vec4<f32>(rgb * raw.a, raw.a);
 }`;
 var GRAIN_KEYS = ["amount", "size", "seed", "fps", "color", "loop"];
-var GrainFilter = class extends PIXI.Filter {
+var GrainFilter = class extends pixi_js.Filter {
   _fps;
   _loop = 0;
   constructor(options = {}) {
     chunkDOLTCXCL_cjs.warnUnknownOptions("grain filter", options, GRAIN_KEYS);
     const { amount = 0.08, size = 1.5, seed = 0, fps = 24, color = 0, loop } = options;
     super({
-      glProgram: PIXI.GlProgram.from({ vertex: GL_VERTEX, fragment: GL_FRAGMENT2, name: "grain-filter" }),
-      gpuProgram: PIXI.GpuProgram.from({ vertex: { source: WGSL_SOURCE2, entryPoint: "mainVertex" }, fragment: { source: WGSL_SOURCE2, entryPoint: "mainFragment" } }),
+      glProgram: pixi_js.GlProgram.from({ vertex: GL_VERTEX, fragment: GL_FRAGMENT2, name: "grain-filter" }),
+      gpuProgram: pixi_js.GpuProgram.from({ vertex: { source: WGSL_SOURCE2, entryPoint: "mainVertex" }, fragment: { source: WGSL_SOURCE2, entryPoint: "mainFragment" } }),
       resources: {
-        grainUniforms: new PIXI.UniformGroup({
+        grainUniforms: new pixi_js.UniformGroup({
           uAmount: { value: amount, type: "f32" },
           uSize: { value: Math.max(size, 0.25), type: "f32" },
           uSeed: { value: Math.floor(seed), type: "f32" },
@@ -2121,7 +2101,7 @@ fn mainFragment(@location(0) uv : vec2<f32>) -> @location(0) vec4<f32> {
   let suv = clamp(uv + off * gfu.uInputSize.zw, gfu.uInputClamp.xy, gfu.uInputClamp.zw);
   return textureSampleLevel(uTexture, uSampler, suv, 0.0);
 }`;
-var WarpFilter = class extends PIXI.Filter {
+var WarpFilter = class extends pixi_js.Filter {
   constructor(options = {}) {
     chunkDOLTCXCL_cjs.warnUnknownOptions("warp filter", options, OPTION_KEYS);
     let { kind = "wave", strength = 6, scale = 80, speed = 0.5, angle = 0, seed = 0 } = options;
@@ -2143,10 +2123,10 @@ var WarpFilter = class extends PIXI.Filter {
       scale = 1;
     }
     super({
-      glProgram: PIXI.GlProgram.from({ vertex: GL_VERTEX2, fragment: GL_FRAGMENT3, name: "warp-filter" }),
-      gpuProgram: PIXI.GpuProgram.from({ vertex: { source: WGSL_SOURCE3, entryPoint: "mainVertex" }, fragment: { source: WGSL_SOURCE3, entryPoint: "mainFragment" } }),
+      glProgram: pixi_js.GlProgram.from({ vertex: GL_VERTEX2, fragment: GL_FRAGMENT3, name: "warp-filter" }),
+      gpuProgram: pixi_js.GpuProgram.from({ vertex: { source: WGSL_SOURCE3, entryPoint: "mainVertex" }, fragment: { source: WGSL_SOURCE3, entryPoint: "mainFragment" } }),
       resources: {
-        warpUniforms: new PIXI.UniformGroup({
+        warpUniforms: new pixi_js.UniformGroup({
           uStrength: { value: strength, type: "f32" },
           uScale: { value: scale, type: "f32" },
           uSpeed: { value: speed, type: "f32" },
@@ -2206,7 +2186,7 @@ var WarpFilter = class extends PIXI.Filter {
 };
 
 // src/filters/named.ts
-var CORE = { blur: "BlurFilter", noise: "NoiseFilter", alpha: "AlphaFilter" };
+var CORE = { blur: () => pixi_js.BlurFilter, noise: () => pixi_js.NoiseFilter, alpha: () => pixi_js.AlphaFilter };
 var CORE_TYPES = ["blur", "noise", "alpha", "colorMatrix", "grain", "warp"];
 var LIBRARY_TYPES = [
   "adjustment",
@@ -2305,7 +2285,7 @@ async function ensureFilterLibrary(spec, load = () => import('pixi-filters')) {
 var SINGLE_VALUE = { pixelate: "size", emboss: "strength" };
 var MATRIX_PRESETS = ["sepia", "grayscale", "negative", "polaroid", "technicolor", "vintage", "kodachrome", "browni"];
 function colorMatrix(params) {
-  const f = new PIXI__namespace.ColorMatrixFilter();
+  const f = new pixi_js.ColorMatrixFilter();
   const preset = params.preset;
   if (preset !== void 0) {
     if (!MATRIX_PRESETS.includes(preset)) {
@@ -2335,9 +2315,8 @@ function lintBulgeCenter(params) {
 function fixRadialBlurGpu(f) {
   const holder = f;
   const gp = holder.gpuProgram;
-  const GpuProgram5 = PIXI__namespace.GpuProgram;
-  if (!gp || !GpuProgram5 || !/uKernelSize\s*:\s*f32/.test(gp.fragment.source)) return f;
-  holder.gpuProgram = GpuProgram5.from({ name: gp.name, vertex: gp.vertex, fragment: { ...gp.fragment, source: gp.fragment.source.replace(/uKernelSize(\s*):\s*f32/, "uKernelSize$1: i32") } });
+  if (!gp || !/uKernelSize\s*:\s*f32/.test(gp.fragment.source)) return f;
+  holder.gpuProgram = pixi_js.GpuProgram.from({ name: gp.name, vertex: gp.vertex, fragment: { ...gp.fragment, source: gp.fragment.source.replace(/uKernelSize(\s*):\s*f32/, "uKernelSize$1: i32") } });
   return f;
 }
 function createNamedFilter(type, params) {
@@ -2346,7 +2325,7 @@ function createNamedFilter(type, params) {
   if (lower(type) === "grain") return new GrainFilter(params);
   if (lower(type) === "warp") return new WarpFilter(params);
   const core = Object.entries(CORE).find(([k]) => lower(k) === lower(type));
-  if (core) return new PIXI__namespace[core[1]](params);
+  if (core) return new (core[1]())(params);
   if (!isLibraryType(type)) throw unknownType(type);
   const Ctor = library?.get(lower(type));
   if (!Ctor) throw MISSING(`"${type}"`, library ? "not found in the loaded package" : "not loaded yet");
@@ -2441,7 +2420,7 @@ var Sequence = class {
     }
     const fa = this.spec.filterArea;
     if (fa && this.target) {
-      this.target.filterArea = new PIXI.Rectangle(fa.x, fa.y, fa.width, fa.height);
+      this.target.filterArea = new pixi_js.Rectangle(fa.x, fa.y, fa.width, fa.height);
     }
   }
   scope() {
@@ -2506,7 +2485,7 @@ var Sequence = class {
 };
 var NullSequence = class extends Sequence {
   async build() {
-    this.target = new PIXI.Container();
+    this.target = new pixi_js.Container();
     this.buildFilters();
   }
 };
@@ -2788,7 +2767,7 @@ var GradientPainter = class {
     this.size = size;
     this.canvas.width = size;
     this.canvas.height = size;
-    this.tex = PIXI.Texture.from(this.canvas);
+    this.tex = pixi_js.Texture.from(this.canvas);
     globalThis.__gradientPainters = (globalThis.__gradientPainters ?? 0) + 1;
   }
   size;
@@ -2797,7 +2776,7 @@ var GradientPainter = class {
   /** Paint `g` and return what `Graphics.fill(...)` takes. */
   paint(g) {
     const ctx = this.canvas.getContext("2d"), s = this.size;
-    if (!ctx) return new PIXI.FillGradient(gradientOptions({ angle: g.angle, stops: g.stops.map((x) => [x.offset, x.color]) }));
+    if (!ctx) return new pixi_js.FillGradient(gradientOptions({ angle: g.angle, stops: g.stops.map((x) => [x.offset, x.color]) }));
     ctx.clearRect(0, 0, s, s);
     if (g.type === "radial") {
       paintRadial(ctx, s, { stops: g.stops.map((x) => [x.offset, x.color]), center: g.center, innerRadius: g.innerRadius, radius: g.radius });
@@ -2957,7 +2936,7 @@ var TextSequence = class extends Sequence {
   _fillGradient = null;
   _applyGradient() {
     const g = this._grad.grad;
-    const next = new PIXI.FillGradient(gradientOptions({ angle: g.angle, stops: g.stops.map((s) => [s.offset, s.color]) }));
+    const next = new pixi_js.FillGradient(gradientOptions({ angle: g.angle, stops: g.stops.map((s) => [s.offset, s.color]) }));
     this.target.style.fill = next;
     this._fillGradient?.destroy();
     this._fillGradient = next;
@@ -2988,7 +2967,7 @@ var TextSequence = class extends Sequence {
     const baseStyle = { ...TEXT_STYLE_DEFAULTS };
     const initialProps = this.spec.initial ?? {};
     this._template = String(initialProps.text ?? this.spec.text ?? "");
-    const text = new PIXI.Text({
+    const text = new pixi_js.Text({
       text: this._template,
       style: baseStyle,
       label: this.spec.name
@@ -3494,7 +3473,7 @@ var CameraSequence = class extends Sequence {
       this.duration = this.parent?.duration ?? this.root.duration;
     }
     const home = homeCamera(compW, this.compH);
-    const carrier = new PIXI.Container();
+    const carrier = new pixi_js.Container();
     carrier.x = home.x;
     carrier.y = home.y;
     carrier.z = home.z;
@@ -3566,7 +3545,7 @@ var CameraSequence = class extends Sequence {
   fogState() {
     if (!this.fog) return null;
     const c = this.target;
-    const fc = this.fogC ??= new PIXI.Color();
+    const fc = this.fogC ??= new pixi_js.Color();
     try {
       fc.setValue(c.fogColor);
     } catch {
@@ -3678,12 +3657,12 @@ function lightLevel(frame, cam, lights) {
   return 0.2126 * m[0] + 0.7152 * m[1] + 0.0722 * m[2];
 }
 var LightSequence = class extends Sequence {
-  color = new PIXI.Color();
+  color = new pixi_js.Color();
   async build() {
     const w = this.parent?.width ?? this.root.width;
     const h = this.parent?.height ?? this.root.height;
     if (this.duration === void 0) this.duration = this.parent?.duration ?? this.root.duration;
-    const c = new PIXI.Container();
+    const c = new pixi_js.Container();
     c.x = w * 0.3;
     c.y = h * 0.2;
     c.z = homeDistance(h, 40) * 0.6;
@@ -3740,7 +3719,7 @@ var defaultWarn = (m) => console.warn(m);
 var SPAN_STYLE_KEYS = ["fill", "fontWeight", "fontStyle", "fontVariant", "letterSpacing", "dropShadow"];
 var LINE_KEYS = ["fontSize", "fontFamily", "lineHeight", "wordWrap", "wordWrapWidth", "align", "leading", "textBaseline", "whiteSpace", "stroke", "padding"];
 var spansMeta = /* @__PURE__ */ new WeakMap();
-var widthOf = (text, style) => PIXI.CanvasTextMetrics.measureText(text, style).width;
+var widthOf = (text, style) => pixi_js.CanvasTextMetrics.measureText(text, style).width;
 function normalize(spans, who, warn) {
   if (!Array.isArray(spans) || spans.length === 0) {
     warn(`pixi-effects: ${who}: spans is empty: write an array of strings and { text, fill \u2026 } objects (nothing is drawn)`);
@@ -3775,15 +3754,15 @@ function normalize(spans, who, warn) {
 }
 function layoutSpans(spans, style, align2, who, warn = defaultWarn) {
   const clean = normalize(spans, who, warn);
-  const base = new PIXI.TextStyle(style);
-  const m = PIXI.CanvasTextMetrics.measureText("M", base);
+  const base = new pixi_js.TextStyle(style);
+  const m = pixi_js.CanvasTextMetrics.measureText("M", base);
   const lineHeight = m.lineHeight ?? m.height;
   const sentinel = (ts) => widthOf("|", ts);
   const measure = (text, ts) => widthOf(text + "|", ts) - sentinel(ts);
   const pieces = [];
   let line = 0, chars = 0, x = 0;
   clean.forEach((sp, spanIdx) => {
-    const ts = Object.keys(sp.overrides).length ? new PIXI.TextStyle({ ...style, ...sp.overrides }) : base;
+    const ts = Object.keys(sp.overrides).length ? new pixi_js.TextStyle({ ...style, ...sp.overrides }) : base;
     sp.text.split("\n").forEach((part, k) => {
       if (k > 0) {
         line++;
@@ -3887,13 +3866,13 @@ function expandSpans(spec, warn = defaultWarn, scope) {
 var ORIGINAL_SCALE_MODE = /* @__PURE__ */ new WeakMap();
 var ImageSequence = class extends Sequence {
   async build() {
-    const texture = await PIXI.Assets.get(this.spec.asset);
+    const texture = await pixi_js.Assets.get(this.spec.asset);
     const source = texture.source;
     if (source && !ORIGINAL_SCALE_MODE.has(source)) ORIGINAL_SCALE_MODE.set(source, source.scaleMode);
     const mode = this.spec.scaleMode;
     if (mode !== void 0 && mode !== "nearest" && mode !== "linear") console.warn(`pixi-effects: ${chunkNGJXVJB7_cjs.describeLayer(this.spec)}: scaleMode "${String(mode)}" is not "nearest" or "linear": ignored`);
     if (source) source.scaleMode = mode === "nearest" || mode === "linear" ? mode : ORIGINAL_SCALE_MODE.get(source);
-    const sprite = new PIXI.Sprite({ texture, label: this.spec.name });
+    const sprite = new pixi_js.Sprite({ texture, label: this.spec.name });
     sprite.cullable = true;
     this.target = sprite;
     this.intrinsicWidth = texture.width;
@@ -3989,7 +3968,7 @@ var AudioSequence = class extends Sequence {
     if (this.spec.sfx !== void 0) return this._buildSfx(this.spec);
     const spec = this.spec;
     this._source = `asset "${spec.asset}"`;
-    const data = await PIXI.Assets.get(spec.asset);
+    const data = await pixi_js.Assets.get(spec.asset);
     this._audioBuffer = data.audioBuffer;
     this._remap = remapOf(spec, "time", data.duration ?? null);
     const constant = this._remap && this._remap.timeKfs.length === 0 ? Math.abs(this._remap.speed ?? 1) : 1;
@@ -4526,7 +4505,7 @@ var VideoSequence = class extends Sequence {
   /** Movie asks this layer to draw the frame its own timeline is at, not the one for a time it computed. */
   selfTimed = true;
   async build() {
-    const data = await PIXI.Assets.get(this.spec.asset);
+    const data = await pixi_js.Assets.get(this.spec.asset);
     this._sourceDuration = data.duration;
     this._remap = remapOf(this.spec, "currentTime", this._sourceDuration);
     this._audioBuffer = this.spec.audio !== false ? data.audioBuffer : null;
@@ -4540,8 +4519,8 @@ var VideoSequence = class extends Sequence {
     this._canvas = canvas;
     this._ctx = canvas.getContext("2d", { alpha: true });
     if (probeFrame && this._ctx) this._ctx.drawImage(probeFrame, 0, 0);
-    const texture = PIXI.Texture.from(canvas);
-    const sprite = new PIXI.Sprite({ texture, label: this.spec.name });
+    const texture = pixi_js.Texture.from(canvas);
+    const sprite = new pixi_js.Sprite({ texture, label: this.spec.name });
     sprite.cullable = true;
     this.target = sprite;
     this.intrinsicWidth = w;
@@ -4648,15 +4627,15 @@ function makeGradientFill(g) {
     const ctx = canvas.getContext("2d");
     if (ctx) {
       paintRadial(ctx, RADIAL_SIZE, g);
-      return { texture: PIXI.Texture.from(canvas), textureSpace: "local" };
+      return { texture: pixi_js.Texture.from(canvas), textureSpace: "local" };
     }
   }
-  return new PIXI.FillGradient(gradientOptions(g));
+  return new pixi_js.FillGradient(gradientOptions(g));
 }
 var CURVE_STEPS = 24;
 var ELLIPSE_STEPS = 128;
 function flattenSvgPath(d) {
-  const prims = new PIXI.GraphicsPath(d).shapePath.shapePrimitives;
+  const prims = new pixi_js.GraphicsPath(d).shapePath.shapePrimitives;
   const out = [];
   for (const { shape } of prims) {
     const poly = shape;
@@ -4900,7 +4879,7 @@ var ShapeSequence = class extends Sequence {
   };
   _liveKeys = new Set(STYLE_KEYS);
   async build() {
-    const graphics = new PIXI.Graphics({ label: this.spec.name });
+    const graphics = new pixi_js.Graphics({ label: this.spec.name });
     graphics.cullable = true;
     this.target = graphics;
     if (this.duration === void 0) {
@@ -5014,13 +4993,13 @@ var ShapeSequence = class extends Sequence {
     applyFill(g, s);
     for (const hole of holes) {
       g.beginPath();
-      g.path(new PIXI.GraphicsPath(hole));
+      g.path(new pixi_js.GraphicsPath(hole));
       g.cut();
     }
     if (s.strokeColor !== void 0 && s.strokeWidth > 0) {
       g.beginPath();
-      g.path(new PIXI.GraphicsPath(main));
-      for (const hole of holes) g.path(new PIXI.GraphicsPath(hole));
+      g.path(new pixi_js.GraphicsPath(main));
+      for (const hole of holes) g.path(new pixi_js.GraphicsPath(hole));
       applyStroke(g, s);
     }
   }
@@ -5264,7 +5243,7 @@ function makePolygonDraw(spec, scope) {
 function makePathDraw(spec) {
   const d = spec.fillRule === "evenodd" ? splitEvenOdd(spec.d).main : spec.d;
   return (g) => {
-    g.path(new PIXI.GraphicsPath(d));
+    g.path(new pixi_js.GraphicsPath(d));
   };
 }
 var STATE_DRAWERS = {
@@ -5628,7 +5607,7 @@ var ShaderSequence = class extends Sequence {
     this.c2d = document.createElement("canvas");
     this.c2d.width = this.w;
     this.c2d.height = this.h;
-    const sprite = new PIXI.Sprite({ texture: PIXI.Texture.from(this.c2d), label: spec.name });
+    const sprite = new pixi_js.Sprite({ texture: pixi_js.Texture.from(this.c2d), label: spec.name });
     sprite.width = width;
     sprite.height = height;
     this.target = sprite;
@@ -5891,7 +5870,7 @@ var CanvasSequence = class extends Sequence {
     this.canvas = document.createElement("canvas");
     this.canvas.width = this.w;
     this.canvas.height = this.h;
-    const sprite = new PIXI.Sprite({ texture: PIXI.Texture.from(this.canvas), label: spec.name });
+    const sprite = new pixi_js.Sprite({ texture: pixi_js.Texture.from(this.canvas), label: spec.name });
     if (!this.smoothing) sprite.texture.source.scaleMode = "nearest";
     sprite.width = this.layerW;
     sprite.height = this.layerH;
@@ -6093,13 +6072,13 @@ var CanvasSequence = class extends Sequence {
 var _CompositionSequence = null;
 async function getCompositionSequence() {
   if (!_CompositionSequence) {
-    _CompositionSequence = (await import('./Composition-ZZEOEETS.cjs')).CompositionSequence;
+    _CompositionSequence = (await import('./Composition-TJ5D7Z63.cjs')).CompositionSequence;
   }
   return _CompositionSequence;
 }
 var _SpansSequence = null;
 async function getSpansSequence() {
-  if (!_SpansSequence) _SpansSequence = (await import('./Spans-MWYFG7RI.cjs')).SpansSequence;
+  if (!_SpansSequence) _SpansSequence = (await import('./Spans-5ENZ3XGS.cjs')).SpansSequence;
   return _SpansSequence;
 }
 var staticTypes = {
@@ -6199,5 +6178,5 @@ exports.spansMeta = spansMeta;
 exports.springDuration = springDuration;
 exports.timeRemapOf = timeRemapOf;
 exports.trimPolylines = trimPolylines;
-//# sourceMappingURL=chunk-V3VBHSK6.cjs.map
-//# sourceMappingURL=chunk-V3VBHSK6.cjs.map
+//# sourceMappingURL=chunk-Z3DM4ETD.cjs.map
+//# sourceMappingURL=chunk-Z3DM4ETD.cjs.map