modern-canvas 0.4.34 → 0.4.36

package/dist/index.mjs

@@ -1106,6 +1106,24 @@ class Color {
   constructor(value = 0) {
     this.value = value;
   }
+  toHex() {
+    return this._colord.toHex();
+  }
+  toRgb() {
+    return this._colord.toRgb();
+  }
+  toRgbString() {
+    return this._colord.toRgbString();
+  }
+  toHsl() {
+    return this._colord.toHsl();
+  }
+  toHslString() {
+    return this._colord.toHslString();
+  }
+  toHsv() {
+    return this._colord.toHsv();
+  }
   toArgb(alpha = this.a, applyToRGB = true) {
     if (alpha === 1) {
       return (255 << 24) + this.rgb;
@@ -1123,9 +1141,6 @@ class Color {
     }
     return (alpha * 255 << 24) + (r << 16) + (g << 8) + b;
   }
-  toHex() {
-    return this._colord.toHex();
-  }
   toArray() {
     return [this.r, this.g, this.b, this.a];
   }
@@ -1722,6 +1737,468 @@ class ColorMatrix extends Matrix {
   }
 }
 
+var GradientParser = GradientParser || {};
+GradientParser.parse = /* @__PURE__ */ function() {
+  const tokens = {
+    linearGradient: /^(-(webkit|o|ms|moz)-)?(linear-gradient)/i,
+    repeatingLinearGradient: /^(-(webkit|o|ms|moz)-)?(repeating-linear-gradient)/i,
+    radialGradient: /^(-(webkit|o|ms|moz)-)?(radial-gradient)/i,
+    repeatingRadialGradient: /^(-(webkit|o|ms|moz)-)?(repeating-radial-gradient)/i,
+    sideOrCorner: /^to (left (top|bottom)|right (top|bottom)|top (left|right)|bottom (left|right)|left|right|top|bottom)/i,
+    extentKeywords: /^(closest-side|closest-corner|farthest-side|farthest-corner|contain|cover)/,
+    positionKeywords: /^(left|center|right|top|bottom)/i,
+    pixelValue: /^(-?((\d*\.\d+)|(\d+\.?)))px/,
+    percentageValue: /^(-?((\d*\.\d+)|(\d+\.?)))%/,
+    emValue: /^(-?((\d*\.\d+)|(\d+\.?)))em/,
+    angleValue: /^(-?((\d*\.\d+)|(\d+\.?)))deg/,
+    radianValue: /^(-?((\d*\.\d+)|(\d+\.?)))rad/,
+    startCall: /^\(/,
+    endCall: /^\)/,
+    comma: /^,/,
+    hexColor: /^#([0-9a-f]+)/i,
+    literalColor: /^([a-z]+)/i,
+    rgbColor: /^rgb/i,
+    rgbaColor: /^rgba/i,
+    varColor: /^var/i,
+    calcValue: /^calc/i,
+    variableName: /^(--[a-z0-9-,\s#]+)/i,
+    number: /^((\d*\.\d+)|(\d+\.?))/,
+    hslColor: /^hsl/i,
+    hslaColor: /^hsla/i
+  };
+  let input = "";
+  function error(msg) {
+    const err = new Error(`${input}: ${msg}`);
+    err.source = input;
+    throw err;
+  }
+  function getAST() {
+    const ast = matchListDefinitions();
+    if (input.length > 0) {
+      error("Invalid input not EOF");
+    }
+    return ast;
+  }
+  function matchListDefinitions() {
+    return matchListing(matchDefinition);
+  }
+  function matchDefinition() {
+    return matchGradient(
+      "linear-gradient",
+      tokens.linearGradient,
+      matchLinearOrientation
+    ) || matchGradient(
+      "repeating-linear-gradient",
+      tokens.repeatingLinearGradient,
+      matchLinearOrientation
+    ) || matchGradient(
+      "radial-gradient",
+      tokens.radialGradient,
+      matchListRadialOrientations
+    ) || matchGradient(
+      "repeating-radial-gradient",
+      tokens.repeatingRadialGradient,
+      matchListRadialOrientations
+    );
+  }
+  function matchGradient(gradientType, pattern, orientationMatcher) {
+    return matchCall(pattern, (captures) => {
+      const orientation = orientationMatcher();
+      if (orientation) {
+        if (!scan(tokens.comma)) {
+          error("Missing comma before color stops");
+        }
+      }
+      return {
+        type: gradientType,
+        orientation,
+        colorStops: matchListing(matchColorStop)
+      };
+    });
+  }
+  function matchCall(pattern, callback) {
+    const captures = scan(pattern);
+    if (captures) {
+      if (!scan(tokens.startCall)) {
+        error("Missing (");
+      }
+      const result = callback(captures);
+      if (!scan(tokens.endCall)) {
+        error("Missing )");
+      }
+      return result;
+    }
+  }
+  function matchLinearOrientation() {
+    const sideOrCorner = matchSideOrCorner();
+    if (sideOrCorner) {
+      return sideOrCorner;
+    }
+    const legacyDirection = match("position-keyword", tokens.positionKeywords, 1);
+    if (legacyDirection) {
+      return {
+        type: "directional",
+        value: legacyDirection.value
+      };
+    }
+    return matchAngle();
+  }
+  function matchSideOrCorner() {
+    return match("directional", tokens.sideOrCorner, 1);
+  }
+  function matchAngle() {
+    return match("angular", tokens.angleValue, 1) || match("angular", tokens.radianValue, 1);
+  }
+  function matchListRadialOrientations() {
+    let radialOrientations;
+    let radialOrientation = matchRadialOrientation();
+    let lookaheadCache;
+    if (radialOrientation) {
+      radialOrientations = [];
+      radialOrientations.push(radialOrientation);
+      lookaheadCache = input;
+      if (scan(tokens.comma)) {
+        radialOrientation = matchRadialOrientation();
+        if (radialOrientation) {
+          radialOrientations.push(radialOrientation);
+        } else {
+          input = lookaheadCache;
+        }
+      }
+    }
+    return radialOrientations;
+  }
+  function matchRadialOrientation() {
+    let radialType = matchCircle() || matchEllipse();
+    if (radialType) {
+      radialType.at = matchAtPosition();
+    } else {
+      const extent = matchExtentKeyword();
+      if (extent) {
+        radialType = extent;
+        const positionAt = matchAtPosition();
+        if (positionAt) {
+          radialType.at = positionAt;
+        }
+      } else {
+        const atPosition = matchAtPosition();
+        if (atPosition) {
+          radialType = {
+            type: "default-radial",
+            at: atPosition
+          };
+        } else {
+          const defaultPosition = matchPositioning();
+          if (defaultPosition) {
+            radialType = {
+              type: "default-radial",
+              at: defaultPosition
+            };
+          }
+        }
+      }
+    }
+    return radialType;
+  }
+  function matchCircle() {
+    const circle = match("shape", /^(circle)/i, 0);
+    if (circle) {
+      circle.style = matchLength() || matchExtentKeyword();
+    }
+    return circle;
+  }
+  function matchEllipse() {
+    const ellipse = match("shape", /^(ellipse)/i, 0);
+    if (ellipse) {
+      ellipse.style = matchPositioning() || matchDistance() || matchExtentKeyword();
+    }
+    return ellipse;
+  }
+  function matchExtentKeyword() {
+    return match("extent-keyword", tokens.extentKeywords, 1);
+  }
+  function matchAtPosition() {
+    if (match("position", /^at/, 0)) {
+      const positioning = matchPositioning();
+      if (!positioning) {
+        error("Missing positioning value");
+      }
+      return positioning;
+    }
+  }
+  function matchPositioning() {
+    const location = matchCoordinates();
+    if (location.x || location.y) {
+      return {
+        type: "position",
+        value: location
+      };
+    }
+  }
+  function matchCoordinates() {
+    return {
+      x: matchDistance(),
+      y: matchDistance()
+    };
+  }
+  function matchListing(matcher) {
+    let captures = matcher();
+    const result = [];
+    if (captures) {
+      result.push(captures);
+      while (scan(tokens.comma)) {
+        captures = matcher();
+        if (captures) {
+          result.push(captures);
+        } else {
+          error("One extra comma");
+        }
+      }
+    }
+    return result;
+  }
+  function matchColorStop() {
+    const color = matchColor();
+    if (!color) {
+      error("Expected color definition");
+    }
+    color.length = matchDistance();
+    return color;
+  }
+  function matchColor() {
+    return matchHexColor() || matchHSLAColor() || matchHSLColor() || matchRGBAColor() || matchRGBColor() || matchVarColor() || matchLiteralColor();
+  }
+  function matchLiteralColor() {
+    return match("literal", tokens.literalColor, 0);
+  }
+  function matchHexColor() {
+    return match("hex", tokens.hexColor, 1);
+  }
+  function matchRGBColor() {
+    return matchCall(tokens.rgbColor, () => {
+      return {
+        type: "rgb",
+        value: matchListing(matchNumber)
+      };
+    });
+  }
+  function matchRGBAColor() {
+    return matchCall(tokens.rgbaColor, () => {
+      return {
+        type: "rgba",
+        value: matchListing(matchNumber)
+      };
+    });
+  }
+  function matchVarColor() {
+    return matchCall(tokens.varColor, () => {
+      return {
+        type: "var",
+        value: matchVariableName()
+      };
+    });
+  }
+  function matchHSLColor() {
+    return matchCall(tokens.hslColor, () => {
+      const lookahead = scan(tokens.percentageValue);
+      if (lookahead) {
+        error("HSL hue value must be a number in degrees (0-360) or normalized (-360 to 360), not a percentage");
+      }
+      const hue = matchNumber();
+      scan(tokens.comma);
+      let captures = scan(tokens.percentageValue);
+      const sat = captures ? captures[1] : null;
+      scan(tokens.comma);
+      captures = scan(tokens.percentageValue);
+      const light = captures ? captures[1] : null;
+      if (!sat || !light) {
+        error("Expected percentage value for saturation and lightness in HSL");
+      }
+      return {
+        type: "hsl",
+        value: [hue, sat, light]
+      };
+    });
+  }
+  function matchHSLAColor() {
+    return matchCall(tokens.hslaColor, () => {
+      const hue = matchNumber();
+      scan(tokens.comma);
+      let captures = scan(tokens.percentageValue);
+      const sat = captures ? captures[1] : null;
+      scan(tokens.comma);
+      captures = scan(tokens.percentageValue);
+      const light = captures ? captures[1] : null;
+      scan(tokens.comma);
+      const alpha = matchNumber();
+      if (!sat || !light) {
+        error("Expected percentage value for saturation and lightness in HSLA");
+      }
+      return {
+        type: "hsla",
+        value: [hue, sat, light, alpha]
+      };
+    });
+  }
+  function matchVariableName() {
+    return scan(tokens.variableName)[1];
+  }
+  function matchNumber() {
+    return scan(tokens.number)[1];
+  }
+  function matchDistance() {
+    return match("%", tokens.percentageValue, 1) || matchPositionKeyword() || matchCalc() || matchLength();
+  }
+  function matchPositionKeyword() {
+    return match("position-keyword", tokens.positionKeywords, 1);
+  }
+  function matchCalc() {
+    return matchCall(tokens.calcValue, () => {
+      let openParenCount = 1;
+      let i = 0;
+      while (openParenCount > 0 && i < input.length) {
+        const char = input.charAt(i);
+        if (char === "(") {
+          openParenCount++;
+        } else if (char === ")") {
+          openParenCount--;
+        }
+        i++;
+      }
+      if (openParenCount > 0) {
+        error("Missing closing parenthesis in calc() expression");
+      }
+      const calcContent = input.substring(0, i - 1);
+      consume(i - 1);
+      return {
+        type: "calc",
+        value: calcContent
+      };
+    });
+  }
+  function matchLength() {
+    return match("px", tokens.pixelValue, 1) || match("em", tokens.emValue, 1);
+  }
+  function match(type, pattern, captureIndex) {
+    const captures = scan(pattern);
+    if (captures) {
+      return {
+        type,
+        value: captures[captureIndex]
+      };
+    }
+  }
+  function scan(regexp) {
+    let captures, blankCaptures;
+    blankCaptures = /^\s+/.exec(input);
+    if (blankCaptures) {
+      consume(blankCaptures[0].length);
+    }
+    captures = regexp.exec(input);
+    if (captures) {
+      consume(captures[0].length);
+    }
+    return captures;
+  }
+  function consume(size) {
+    input = input.substr(size);
+  }
+  return function(code) {
+    input = code.toString().trim();
+    if (input.endsWith(";")) {
+      input = input.slice(0, -1);
+    }
+    return getAST();
+  };
+}();
+const parseGradient = GradientParser.parse.bind(GradientParser);
+
+class LinearGradient {
+  constructor(x0, y0, x1, y1, stops) {
+    this.x0 = x0;
+    this.y0 = y0;
+    this.x1 = x1;
+    this.y1 = y1;
+    this.stops = stops;
+  }
+  static from(css) {
+    let angleDeg = 0;
+    const stops = [];
+    const ast = parseGradient(css)[0];
+    if (ast.type === "linear-gradient") {
+      switch (ast?.orientation?.type) {
+        case "angular":
+          angleDeg = Number(ast.orientation.value);
+          break;
+      }
+      ast.colorStops.forEach((stop) => {
+        let offset = 0;
+        let color = "rgba(0, 0, 0, 0)";
+        switch (stop.type) {
+          case "rgb":
+            color = `rgb(${stop.value[0]}, ${stop.value[1]}, ${stop.value[2]})`;
+            break;
+          case "rgba":
+            color = `rgba(${stop.value[0]}, ${stop.value[1]}, ${stop.value[2]}, ${stop.value[3]})`;
+            break;
+          case "literal":
+            color = stop.value;
+            break;
+          case "hex":
+            color = stop.value;
+            break;
+        }
+        switch (stop.length?.type) {
+          case "%":
+            offset = Number(stop.length.value) / 100;
+            break;
+        }
+        stops.push({ offset, color });
+      });
+    }
+    const angleRad = (angleDeg + 90) * Math.PI / 180;
+    const width = 1;
+    const height = 1;
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const length = Math.sqrt(width * width + height * height) / 2;
+    const x0 = halfWidth + length * Math.cos(angleRad + Math.PI);
+    const y0 = halfHeight + length * Math.sin(angleRad + Math.PI);
+    const x1 = halfWidth + length * Math.cos(angleRad);
+    const y1 = halfHeight + length * Math.sin(angleRad);
+    return new LinearGradient(x0, y0, x1, y1, stops);
+  }
+  parse(width, height) {
+    return this._parseByCanvas(width, height);
+  }
+  _parseByCanvas(width, height) {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to parse linear gradient, get canvas context is null.");
+    }
+    const gradient = ctx.createLinearGradient(
+      this.x0 * width,
+      this.y0 * height,
+      this.x1 * width,
+      this.y1 * height
+    );
+    this.stops.forEach((stop) => {
+      gradient.addColorStop(stop.offset, stop.color);
+    });
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    return {
+      width: imageData.width,
+      height: imageData.height,
+      pixels: new Uint8Array(imageData.data.buffer)
+    };
+  }
+}
+
 class Matrix2 extends Matrix {
   constructor(array) {
     super(2, 2, array);
@@ -1826,6 +2303,47 @@ class Projection2D extends Matrix3 {
   }
 }
 
+class RadialGradient {
+  constructor(x0, y0, r0, x1, y1, r1, stops) {
+    this.x0 = x0;
+    this.y0 = y0;
+    this.r0 = r0;
+    this.x1 = x1;
+    this.y1 = y1;
+    this.r1 = r1;
+    this.stops = stops;
+  }
+  parse(width, height) {
+    return this._parseByCanvas(width, height);
+  }
+  _parseByCanvas(width, height) {
+    const canvas = document.createElement("canvas");
+    const ctx = canvas.getContext("2d");
+    if (!ctx) {
+      throw new Error("Failed to parse radial gradient, get canvas context is null.");
+    }
+    const gradient = ctx.createRadialGradient(
+      this.x0 * width,
+      this.y0 * height,
+      this.r0,
+      this.x1 * width,
+      this.y1 * height,
+      this.r1
+    );
+    this.stops.forEach((stop) => {
+      gradient.addColorStop(stop.offset, stop.color);
+    });
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, canvas.width, canvas.height);
+    const imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
+    return {
+      width: imageData.width,
+      height: imageData.height,
+      pixels: new Uint8Array(imageData.data.buffer)
+    };
+  }
+}
+
 class Vector2 extends Vector {
   get x() {
     return this._array[0];
@@ -5130,6 +5648,23 @@ class ColorTexture extends Texture2D {
   }
 }
 
+class GradientTexture extends Texture2D {
+  // |(radial-gradient)
+  static regExp = /(linear-gradient)/;
+  static test(value) {
+    return this.regExp.test(value);
+  }
+  constructor(value, width, height) {
+    if (width === Infinity)
+      width = 0;
+    if (height === Infinity)
+      height = 0;
+    super(
+      LinearGradient.from(value).parse(width, height)
+    );
+  }
+}
+
 function resolveOptions$1(options) {
   return {
     autoLoad: Boolean(options?.autoLoad ?? true),
@@ -5572,6 +6107,21 @@ let Node = class extends CoreObject {
     }).append(nodes);
     this.on("treeEnter", this._onTreeEnter).on("treeExit", this._onTreeExit).on("parented", this._onParented).on("unparented", this._onUnparented).on("ready", this._onReady).on("process", this._onProcess);
   }
+  setProperties(properties) {
+    if (properties) {
+      const {
+        meta,
+        ...restProperties
+      } = properties;
+      if (meta) {
+        for (const key in meta) {
+          this.setMeta(key, meta[key]);
+        }
+      }
+      super.setProperties(restProperties);
+    }
+    return this;
+  }
   /** Name */
   getName() {
     return this.name;
@@ -7066,20 +7616,27 @@ class CanvasContext extends Path2D {
   miterLimit;
   _defaultStyle = Texture2D.EMPTY;
   _draws = [];
+  _colorToTexture(color, width, height) {
+    if (color instanceof Texture2D) {
+      return color;
+    } else if (typeof color === "string" && GradientTexture.test(color)) {
+      return new GradientTexture(color, width, height);
+    } else {
+      return new ColorTexture(color);
+    }
+  }
   stroke(options) {
+    const path = new Path2D(this);
     let texture = this._defaultStyle;
     if (this.strokeStyle) {
-      if (this.strokeStyle instanceof Texture2D) {
-        texture = this.strokeStyle;
-      } else {
-        texture = new ColorTexture(this.strokeStyle);
-      }
+      const { width, height } = path.getBoundingBox();
+      texture = this._colorToTexture(this.strokeStyle, width, height);
     }
     if (this.curves.length) {
       this._draws.push({
         ...options,
         type: "stroke",
-        path: new Path2D(this),
+        path,
         texture,
         textureTransform: this.textureTransform,
         style: {
@@ -7100,18 +7657,16 @@ class CanvasContext extends Path2D {
     this.rect(x, y, width, height).stroke();
   }
   fill(options) {
+    const path = new Path2D(this);
     let texture = this._defaultStyle;
     if (this.fillStyle) {
-      if (this.fillStyle instanceof Texture2D) {
-        texture = this.fillStyle;
-      } else {
-        texture = new ColorTexture(this.fillStyle);
-      }
+      const { width, height } = path.getBoundingBox();
+      texture = this._colorToTexture(this.fillStyle, width, height);
     }
     this._draws.push({
       ...options,
       type: "fill",
-      path: new Path2D(this),
+      path,
       texture,
       textureTransform: this.textureTransform
     });
@@ -14019,4 +14574,4 @@ async function render(options) {
   });
 }
 
-export { AnimatedTexture, Animation, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, BaseElement2D, BaseElement2DBackground, BaseElement2DFill, BaseElement2DForeground, BaseElement2DGeometry, BaseElement2DOutline, BaseElement2DShadow, BaseElement2DStyle, BaseElement2DText, CanvasContext, CanvasItem, CanvasItemEditor, CanvasTexture, Color, ColorAdjustEffect, ColorFilterEffect, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, Control, CoreObject, DEG_TO_RAD, DEVICE_PIXEL_RATIO, DropShadowEffect, Effect, EffectMaterial, Element2D, Element2DStyle, EmbossEffect, Engine, EventEmitter, FlexElement2D, FlexElement2DStyle, FlexLayout, FontLoader, GIFLoader, GaussianBlurEffect, Geometry, GlitchEffect, GodrayEffect, Graphics2D, HTMLAudio, HTMLAudioContext, HTMLSound, IN_BROWSER, Image2D, ImageTexture, IndexBuffer, Input, InputEvent, JSONLoader, KawaseBlurEffect, KawaseTransition, LeftEraseTransition, Loader, Lottie2D, LottieLoader, MainLoop, MaskEffect, Material, Matrix, Matrix2, Matrix3, Matrix4, MouseInputEvent, Node, Node2D, OutlineEffect, PI, PI_2, PixelateEffect, PixelsTexture, PointerInputEvent, Projection2D, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, Range, RawWeakMap, Rect2, RefCounted, Renderer, Resource, Ruler, SUPPORTS_AUDIO_CONTEXT, SUPPORTS_CLICK_EVENTS, SUPPORTS_CREATE_IMAGE_BITMAP, SUPPORTS_IMAGE_BITMAP, SUPPORTS_MOUSE_EVENTS, SUPPORTS_OFFLINE_AUDIO_CONTEXT, SUPPORTS_POINTER_EVENTS, SUPPORTS_RESIZE_OBSERVER, SUPPORTS_TOUCH_EVENTS, SUPPORTS_WEBGL2, SUPPORTS_WEBKIT_AUDIO_CONTEXT, SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT, SUPPORTS_WEB_AUDIO, SUPPORTS_WHEEL_EVENTS, Scaler, SceneTree, ScrollBar, Text2D, TextLoader, Texture2D, TextureLoader, TextureRect2D, Ticker, TiltShiftTransition, Timeline, TimelineNode, Transform2D, TransformRect2D, Transition, TwistTransition, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, VertexAttribute, VertexBuffer, Video2D, VideoLoader, VideoTexture, Viewport, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, WebGLBufferModule, WebGLFramebufferModule, WebGLMaskModule, WebGLModule, WebGLProgramModule, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, WebGLTextureModule, WebGLVertexArrayModule, WebGLViewportModule, WebSound, WheelInputEvent, XScrollBar, YScrollBar, ZoomBlurEffect, assets, clamp, clampFrag, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, defineProperty, determineCrossOrigin, ease, easeIn, easeInOut, easeOut, frag$1 as frag, getDeclarations, getDefaultCssPropertyValue, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, parseCSSFilter, parseCSSTransform, parseCSSTransformOrigin, parseCssFunctions, parseCssProperty, property, protectedProperty, render, timingFunctions, uid };
+export { AnimatedTexture, Animation, Assets, Audio, AudioPipeline, AudioProcessor, AudioSpectrum, AudioWaveform, BaseElement2D, BaseElement2DBackground, BaseElement2DFill, BaseElement2DForeground, BaseElement2DGeometry, BaseElement2DOutline, BaseElement2DShadow, BaseElement2DStyle, BaseElement2DText, CanvasContext, CanvasItem, CanvasItemEditor, CanvasTexture, Color, ColorAdjustEffect, ColorFilterEffect, ColorMatrix, ColorOverlayEffect, ColorRemoveEffect, ColorReplaceEffect, ColorTexture, Control, CoreObject, DEG_TO_RAD, DEVICE_PIXEL_RATIO, DropShadowEffect, Effect, EffectMaterial, Element2D, Element2DStyle, EmbossEffect, Engine, EventEmitter, FlexElement2D, FlexElement2DStyle, FlexLayout, FontLoader, GIFLoader, GaussianBlurEffect, Geometry, GlitchEffect, GodrayEffect, GradientTexture, Graphics2D, HTMLAudio, HTMLAudioContext, HTMLSound, IN_BROWSER, Image2D, ImageTexture, IndexBuffer, Input, InputEvent, JSONLoader, KawaseBlurEffect, KawaseTransition, LeftEraseTransition, LinearGradient, Loader, Lottie2D, LottieLoader, MainLoop, MaskEffect, Material, Matrix, Matrix2, Matrix3, Matrix4, MouseInputEvent, Node, Node2D, OutlineEffect, PI, PI_2, PixelateEffect, PixelsTexture, PointerInputEvent, Projection2D, QuadGeometry, QuadUvGeometry, RAD_TO_DEG, RadialGradient, Range, RawWeakMap, Rect2, RefCounted, Renderer, Resource, Ruler, SUPPORTS_AUDIO_CONTEXT, SUPPORTS_CLICK_EVENTS, SUPPORTS_CREATE_IMAGE_BITMAP, SUPPORTS_IMAGE_BITMAP, SUPPORTS_MOUSE_EVENTS, SUPPORTS_OFFLINE_AUDIO_CONTEXT, SUPPORTS_POINTER_EVENTS, SUPPORTS_RESIZE_OBSERVER, SUPPORTS_TOUCH_EVENTS, SUPPORTS_WEBGL2, SUPPORTS_WEBKIT_AUDIO_CONTEXT, SUPPORTS_WEBKIT_OFFLINE_AUDIO_CONTEXT, SUPPORTS_WEB_AUDIO, SUPPORTS_WHEEL_EVENTS, Scaler, SceneTree, ScrollBar, Text2D, TextLoader, Texture2D, TextureLoader, TextureRect2D, Ticker, TiltShiftTransition, Timeline, TimelineNode, Transform2D, TransformRect2D, Transition, TwistTransition, UvGeometry, UvMaterial, Vector, Vector2, Vector3, Vector4, VertexAttribute, VertexBuffer, Video2D, VideoLoader, VideoTexture, Viewport, ViewportTexture, WebAudio, WebAudioContext, WebGLBatch2DModule, WebGLBlendMode, WebGLBufferModule, WebGLFramebufferModule, WebGLMaskModule, WebGLModule, WebGLProgramModule, WebGLRenderer, WebGLScissorModule, WebGLState, WebGLStateModule, WebGLStencilModule, WebGLTextureModule, WebGLVertexArrayModule, WebGLViewportModule, WebSound, WheelInputEvent, XScrollBar, YScrollBar, ZoomBlurEffect, assets, clamp, clampFrag, createHTMLCanvas, createNode, crossOrigin, cubicBezier, curves, customNode, customNodes, defaultOptions, defineProperty, determineCrossOrigin, ease, easeIn, easeInOut, easeOut, frag$1 as frag, getDeclarations, getDefaultCssPropertyValue, isCanvasElement, isElementNode, isImageElement, isPow2, isVideoElement, isWebgl2, lerp, linear, log2, mapWebGLBlendModes, nextPow2, nextTick, parseCSSFilter, parseCSSTransform, parseCSSTransformOrigin, parseCssFunctions, parseCssProperty, property, protectedProperty, render, timingFunctions, uid };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "modern-canvas",
   "type": "module",
-  "version": "0.4.34",
+  "version": "0.4.36",
   "packageManager": "pnpm@9.15.1",
   "description": "A JavaScript WebGL rendering engine.",
   "author": "wxm",
@@ -70,7 +70,7 @@
     "colord": "^2.9.3",
     "earcut": "^3.0.1",
     "modern-font": "^0.4.1",
-    "modern-idoc": "^0.5.3",
+    "modern-idoc": "^0.5.4",
     "modern-path2d": "^1.2.19",
     "modern-text": "^1.3.10",
     "yoga-layout": "^3.2.1"