@weasel-js/core 1.4.4 → 1.5.0

package/dist/{types-ei3UMl9R.d.ts → types-DMyo7dnM.d.ts}

@@ -1,20 +1,6 @@
 import { Op } from '@weasel-js/history';
-import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-DEALFt5F.js';
-
-/**
- * Snapshot of modifier-key state at gesture dispatch.
- *
- * Lives in core rather than beside the gesture types that produce it because
- * `core/selection/chromeState.ts` reads it, and core may not import from
- * `interactions/`. Re-exported from `interactions/gestures/types.ts`, which
- * is still where gesture code names it.
- */
-interface ModifierState {
-    alt: boolean;
-    shift: boolean;
-    meta: boolean;
-    ctrl: boolean;
-}
+import { S as SnapTarget, M as MoveAdapter, I as InsertAdapter } from './types-DtjCJA5r.js';
+import { Bounds, ModifierState, ResizeAnchor } from '@weasel-js/routing';
 
 /** Pointer position in both world and client coords. */
 interface PointerState {
@@ -130,31 +116,20 @@ type BehaviorMoveResult<TPose> = BehaviorResult<TPose>;
  *  `useMove`) and return a `BehaviorResult` shaping it (or, legacy, an
  *  override pose run through the back-compat shim). */
 type MoveBehavior<TPose> = ActionBehavior<TPose, GroupTransform, BehaviorResult<TPose>>;
-/** Which corner/edge of the rect stays fixed during a resize. */
-type ResizeAnchor = {
-    x: 'min' | 'max' | 'free';
-    y: 'min' | 'max' | 'free';
-};
-/** Minimum rect-shaped pose required by the resize machinery. */
-interface ResizePose {
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-}
+
 /** Per-frame proposed resize: pose plus the anchor pinning the opposite corner. */
-interface ResizeProposed<TPose extends ResizePose> {
+interface ResizeProposed<TPose extends Bounds> {
     pose: TPose;
     anchor: ResizeAnchor;
 }
 /** Per-frame result a `BoundsConstraint.onMove` can return to override the proposed pose. */
-interface ResizeMoveResult<TPose extends ResizePose> {
+interface ResizeMoveResult<TPose extends Bounds> {
     pose?: TPose;
 }
 /** A bounds-frame constraint plugged into `useResize` / `resizeAction`.
  *  Reads/writes `{x,y,width,height}` and can override the proposed pose
  *  on each frame (e.g. lock-aspect, clamp-min-size, snap-to-grid). */
-type BoundsConstraint<TPose extends ResizePose> = ActionBehavior<TPose, ResizeProposed<TPose>, ResizeMoveResult<TPose>>;
+type BoundsConstraint<TPose extends Bounds> = ActionBehavior<TPose, ResizeProposed<TPose>, ResizeMoveResult<TPose>>;
 /** Live overlay state exposed by `useResize` for rendering the in-flight resize ghost. */
 interface ResizeOverlay<TPose> {
     id: string;
@@ -168,11 +143,7 @@ interface ResizeOverlay<TPose> {
      *  resizes. */
     leafPoses?: Map<string, TPose>;
 }
-/** ResizePose extended with a rotation angle (radians). Pivot is the AABB
- *  center of the unrotated `{x, y, width, height}`. */
-interface RotatedPose extends ResizePose {
-    rotation: number;
-}
+
 /** Per-frame proposed rotation: pose plus the candidate angle in radians. */
 interface RotateProposed<TPose> {
     pose: TPose;
@@ -203,7 +174,7 @@ interface InsertPoint {
 interface InsertProposed<TPose> {
     start: InsertPoint;
     current: InsertPoint;
-    bounds: ResizePose;
+    bounds: Bounds;
     pose: TPose;
 }
 /** Per-frame result an `InsertBehavior.onMove` can return to override the start/current points. */
@@ -221,7 +192,7 @@ interface InsertOverlay<TPose> {
     start: InsertPoint;
     current: InsertPoint;
     /** Axis-aligned bounding rect derived from `start`/`current`. */
-    bounds: ResizePose;
+    bounds: Bounds;
     /** TPose constructed from `bounds` via the hook's `posefromBounds`. */
     pose: TPose;
 }
@@ -276,7 +247,7 @@ type PointSnapFrame = 'dragged-corner' | 'fixed-corner' | 'center' | 'origin';
  *  `draggedCorner` and `fixedCorner` are `null` for edge drags
  *  (`anchor.x === 'free'` or `anchor.y === 'free'`). `center` and
  *  `origin` are always present. */
-interface PointSnapContext<TPose extends ResizePose> {
+interface PointSnapContext<TPose extends Bounds> {
     draggedCorner: {
         worldX: number;
         worldY: number;
@@ -305,7 +276,7 @@ interface PointSnapResult {
     worldY: number;
 }
 /** A point-snap behavior plugged into `useResize`'s `pointSnapBehaviors`. */
-interface PointSnapBehavior<TPose extends ResizePose> {
+interface PointSnapBehavior<TPose extends Bounds> {
     id?: string;
     onMove(ctx: PointSnapContext<TPose>): PointSnapResult | null | undefined;
 }
@@ -336,4 +307,4 @@ interface CloneBehavior {
     }) => Op[];
 }
 
-export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, RotateOverlay as D, RotateProposed as E, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, ModifierState as M, PointSnapBehavior as P, ResizePose as R, SnapStrategy as S, RotatedPose as a, MoveBehavior as b, ResizeAnchor as c, PointSnapFrame as d, RotateBehavior as e, AreaSelectOverlay as f, BehaviorMoveResult as g, BehaviorResult as h, CloneLayer as i, ClonePose as j, GroupTransform as k, InsertMoveResult as l, InsertOverlay as m, InsertPoint as n, InsertProposed as o, LassoSelectMoveResult as p, LassoSelectOverlay as q, LassoSelectPose as r, LassoSelectProposed as s, PointSnapContext as t, PointSnapResult as u, PointerState as v, ResizeMoveResult as w, ResizeOverlay as x, ResizeProposed as y, RotateMoveResult as z };
+export type { ActionBehavior as A, BoundsConstraint as B, CloneBehavior as C, GestureContext as G, InsertBehavior as I, LassoSelectBehavior as L, MoveBehavior as M, PointSnapBehavior as P, RotateBehavior as R, SnapStrategy as S, PointSnapFrame as a, AreaSelectOverlay as b, BehaviorMoveResult as c, BehaviorResult as d, CloneLayer as e, ClonePose as f, GroupTransform as g, InsertMoveResult as h, InsertOverlay as i, InsertPoint as j, InsertProposed as k, LassoSelectMoveResult as l, LassoSelectOverlay as m, LassoSelectPose as n, LassoSelectProposed as o, PointSnapContext as p, PointSnapResult as q, PointerState as r, ResizeMoveResult as s, ResizeOverlay as t, ResizeProposed as u, RotateMoveResult as v, RotateOverlay as w, RotateProposed as x };

package/dist/{types-DEALFt5F.d.ts → types-DtjCJA5r.d.ts}

@@ -133,9 +133,10 @@ interface SnapTarget<TPose = unknown> {
  *
  * **Pose semantics:** `getPose` / `setPose` work in **local** coordinates —
  * relative to the node's direct parent (or world, for root-parented nodes).
- * The kit composes world poses via `composeWorldPose` when it needs to
- * render, hit-test, or snap. For the common axis-aligned rect pose,
- * `composeRectPose` / `decomposeRectPose` ship as the canonical compose pair.
+ * `getWorldPose` is the composed reading, and is what the render walk, picking
+ * and chrome consume. For the common axis-aligned rect pose, `composeRectPose`
+ * (translation only) and `composeRigidPose` (a container's pose is a frame, so
+ * its rotation reaches its children) ship as the two canonical strategies.
  */
 interface SceneAdapter<TNode extends {
     id: string;
@@ -145,6 +146,11 @@ interface SceneAdapter<TNode extends {
     getSelection(): string[];
     hitTest(worldX: number, worldY: number): string | null;
     getPose(id: string): TPose;
+    /** The node's pose in world coordinates, with every ancestor's frame folded
+     *  in. Equal to `getPose` under the absolute-pose model; anything reasoning
+     *  about where a node actually is — picking, chrome, snapping, export —
+     *  wants this rather than `getPose`. */
+    getWorldPose?(id: string): TPose;
     getParent(id: string): string | null;
     setPose(id: string, pose: TPose): void;
     setParent(id: string, parentId: string | null): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weasel-js/core",
-  "version": "1.4.4",
+  "version": "1.5.0",
   "description": "Domain-agnostic 2D scene graph primitives for React: viewport math, drag/resize/insert/clone interactions, layered canvas rendering.",
   "license": "MIT",
   "author": "orochi235",
@@ -72,16 +72,16 @@
   },
   "peerDependencies": {
     "react": ">=18",
-    "@weasel-js/font": "1.4.4"
+    "@weasel-js/font": "1.5.0"
   },
   "dependencies": {
-    "@weasel-js/cursor": "1.4.4",
-    "@weasel-js/geom": "1.4.4",
-    "@weasel-js/gestures": "1.4.4",
-    "@weasel-js/history": "1.4.4",
-    "@weasel-js/modes": "1.4.4",
-    "@weasel-js/paint": "1.4.4",
-    "@weasel-js/text": "1.4.4",
+    "@weasel-js/cursor": "1.5.0",
+    "@weasel-js/geom": "1.5.0",
+    "@weasel-js/gestures": "1.5.0",
+    "@weasel-js/history": "1.5.0",
+    "@weasel-js/paint": "1.5.0",
+    "@weasel-js/routing": "1.5.0",
+    "@weasel-js/text": "1.5.0",
     "earcut": "2.2.4",
     "polygon-clipping": "^0.15.7"
   },
@@ -97,5 +97,8 @@
     "resize",
     "viewport",
     "2d"
-  ]
+  ],
+  "devDependencies": {
+    "@weasel-js/modes": "1.5.0"
+  }
 }

package/dist/DrawCommand-CD-ug3d9.d.ts

@@ -1,332 +0,0 @@
-import { P as Path } from './path-JEV2c5If.js';
-import { TextureHandle, FillStyle, Stroke } from '@weasel-js/paint';
-import { ResolvedRun, TextStyle, TextVerticalAlign } from '@weasel-js/text';
-
-/**
- * 2D affine matrix utilities. Column-major 9-element Float32Array, matching
- * `WebGL2RenderingContext.uniformMatrix3fv` byte order so we can pass the
- * array directly without a transpose flag.
- *
- * Layout (column-major):
- *   [m00, m10, 0,
- *    m01, m11, 0,
- *    tx,  ty,  1]
- *
- * `apply(m, x, y)` returns `[m * (x, y, 1)] = [m00*x + m01*y + tx,
- *                                              m10*x + m11*y + ty]`.
- */
-type Mat3 = Float32Array;
-declare function identity(): Mat3;
-declare function multiply(out: Mat3, m: Mat3): Mat3;
-declare function translate(m: Mat3, tx: number, ty: number): Mat3;
-declare function scale(m: Mat3, sx: number, sy: number): Mat3;
-/**
- * Inverse of an affine matrix. Returns identity for a singular matrix
- * (determinant 0) — a degenerate transform collapses every point onto a
- * line, so there is no meaningful inverse and callers get an unmapped
- * space rather than NaNs propagating into a shader uniform.
- */
-declare function invert(m: Mat3): Mat3;
-declare function apply(m: Mat3, x: number, y: number): [number, number];
-/**
- * Map screen pixel coords (0..width on X, 0..height on Y, top-left origin)
- * into clip space (-1..1 on X, 1..-1 on Y — note Y flip so screen-down
- * matches clip-down).
- */
-declare function screenToClip(width: number, height: number): Mat3;
-/**
- * Uniform-equivalent scale factor: the square root of the absolute
- * determinant of the linear part, i.e. the geometric mean of the two axis
- * scales. Rotation-invariant. Under non-uniform scale it is between the two
- * axes and exact on neither — the same compromise `meanScale` documents.
- */
-declare function meanScaleOf(m: Mat3): number;
-/** The renderer's 3x3 matrix operations, as one namespace. These work on the
- *  9-element `Float32Array` form the GL uniform upload wants — distinct from
- *  `@weasel-js/geom`'s 6-element affine `Mat3`, though the logical element
- *  order is the same. */
-declare const mat3: {
-    identity: typeof identity;
-    multiply: typeof multiply;
-    translate: typeof translate;
-    scale: typeof scale;
-    invert: typeof invert;
-    apply: typeof apply;
-    screenToClip: typeof screenToClip;
-    meanScaleOf: typeof meanScaleOf;
-};
-
-/**
- * registerProgram — public API for registering custom shader programs.
- *
- * Stores raw GLSL source strings in a module-level registry. GL compilation
- * happens on each WeaselRenderer via WeaselRenderer.registerProgram(), which
- * calls getProgramSource() and compiles the result. This keeps registerProgram
- * GL-context-agnostic — identical pattern to registerFont storing ImageBitmap.
- *
- * Module-level state = source strings only; compiled GL
- * programs live on each renderer's programRegistry (Map<id, ShaderProgram>).
- *
- * Lifecycle: program sources live for the module lifetime. No unregister in v1.
- */
-
-/** Opaque handle to a compiled custom shader program. */
-interface ShaderProgramHandle {
-    readonly id: string;
-}
-/**
- * Scalar and vector uniform types accepted by the custom shader uniform binder.
- *
- * | TS type                 | GL call                              |
- * |-------------------------|--------------------------------------|
- * | number                  | uniform1f                            |
- * | [n, n]                  | uniform2fv                           |
- * | [n, n, n]               | uniform3fv                           |
- * | [n, n, n, n]            | uniform4fv                           |
- * | Float32Array length 9   | uniformMatrix3fv (column-major)      |
- * | Float32Array length 16  | uniformMatrix4fv (column-major)      |
- * | TextureHandle           | bind to next tex unit + uniform1i    |
- */
-type ShaderUniform = number | [number, number] | [number, number, number] | [number, number, number, number] | Float32Array | TextureHandle;
-/**
- * Register a custom shader program by id.
- *
- * Pass an empty string for `vert` to use the kit's default vertex shader
- * (recommended). The kit's vertex shader exposes `v_uv`, `v_screen`, and
- * `v_world` varyings plus `u_bounds` and `u_view` uniforms.
- *
- * **IMPORTANT — Premultiplied alpha:**
- * Your fragment shader MUST output premultiplied alpha:
- *   `outColor = vec4(rgb * a, a);`  ← correct
- *   `outColor = vec4(rgb, a);`      ← WRONG — over-brightens translucent regions
- *
- * The renderer uses `gl.blendFunc(ONE, ONE_MINUS_SRC_ALPHA)` to match.
- * Opaque fragments (a=1) are unaffected; only fragments with a < 1 differ.
- *
- * **Re-registration behavior:**
- * - Dev mode (`NODE_ENV !== 'production'`): calling with an existing id replaces
- *   the source (hot-reload). Each renderer must call `WeaselRenderer.registerProgram(handle)`
- *   again to pick up the new source.
- * - Prod mode: calling with an existing id throws.
- *
- * Actual GL compilation and `ShaderCompileError` throwing happen in
- * `WeaselRenderer.registerProgram()`, not here.
- *
- * @experimental API may break before v2.
- */
-declare function registerProgram(id: string, vert: string, frag: string): ShaderProgramHandle;
-
-/**
- * One full-screen pass over what a group has already drawn.
- *
- * The renderer runs a group's effects in order, each reading the previous
- * one's output through `u_source` and writing a whole new buffer — so an
- * effect is free to read neighbouring pixels, which is the entire point and
- * the one thing `colorMatrix` can never do.
- *
- * `uniforms` are the effect's own; `u_source`, `u_resolution` and `u_texel`
- * come from the renderer and must not be passed here.
- */
-interface Effect {
-    program: ShaderProgramHandle;
-    uniforms?: Record<string, ShaderUniform>;
-}
-/**
- * Register a fragment shader as an effect. Sugar over `registerProgram` with
- * the effect vertex shader, and the reason a consumer never imports the
- * prelude: an effect that registers with the *custom-shader* vertex shader
- * compiles, runs, and samples its source upside down.
- *
- * The fragment shader reads `v_uv` and `u_source`, and may declare
- * `u_resolution` / `u_texel`. See `effectPrelude.ts` for the full contract,
- * including the premultiplied-alpha requirement.
- *
- * @experimental
- */
-declare function registerEffect(id: string, frag: string): ShaderProgramHandle;
-
-/**
- * Solid-fill paint variant (subset of the full `FillStyle` union from
- * `@weasel-js/core`). Kept for back-compat with step-1/2 consumers and
- * because some code reads `fill.color` directly. Through step 4, fills can
- * be any `FillStyle` variant — solid, pattern, or gradient.
- */
-interface SolidPaint {
-    fill?: 'solid';
-    /** Any CSS color string accepted by `parseColor`: hex, `rgb()`/`rgba()`, `hsl()`/`hsla()`, named, or `transparent`. */
-    color: string;
-    opacity?: number;
-}
-/** DrawCommand variants implemented through step 6. */
-type DrawCommand = PathDrawCommand | GroupDrawCommand | TextDrawCommand | ImageDrawCommand | SpritesDrawCommand | ShaderDrawCommand;
-/** Draw a path, filled and/or stroked. The workhorse command: every shape the
- *  kit draws that is not text, an image, or a custom shader is one of these. */
-interface PathDrawCommand {
-    kind: 'path';
-    path: Path;
-    /** Any `FillStyle` variant: solid, pattern, or gradient (linear/radial/conic). */
-    fill?: FillStyle;
-    /** Stroke spec. Only solid `paint` supported through step 4. */
-    stroke?: Stroke;
-    /**
-     * Optional flat RGBA-per-path-anchor color array (length =
-     * `4 × countPathAnchors(path)`, floats in 0..1). The renderer
-     * arc-length-interpolates these per-anchor colors across the
-     * flattened/triangulated mesh between consecutive anchors using the
-     * mesh's `anchorA` / `anchorB` / `anchorT` parameterization.
-     *
-     * **`fill` must also be set when using `vertexColors`.** The renderer
-     * only enters the per-vertex shader path when the command has a fill
-     * (the fill provides the opacity uniform; the vertex colors override
-     * the fill's color). Pass any solid `fill` (e.g. `{ color: '#fff' }`)
-     * as the placeholder; the per-vertex colors win in the shader.
-     */
-    vertexColors?: number[];
-}
-/** Draw a list of commands under a shared transform, opacity, color matrix
- *  and clip. Groups nest, and their effects accumulate down the stack — this
- *  is how a container node's transform reaches its descendants. */
-interface GroupDrawCommand {
-    kind: 'group';
-    transform?: Mat3;
-    alpha?: number;
-    /**
-     * Optional 4×5 color matrix (row-major, 20 numbers) — `out = M₄ₓ₄ * in + bias`.
-     * Accumulated multiplicatively down the group stack. Defaults to identity.
-     */
-    colorMatrix?: number[];
-    /** Optional clip path. When set, the renderer rasterizes this path into
-     *  the stencil buffer before drawing `children`; the children paint only
-     *  where the clip covers. Nested groups with clips intersect — a child
-     *  cannot escape an ancestor's clip. Max 7 nesting levels; the renderer
-     *  throws if exceeded. */
-    clip?: Path;
-    /**
-     * Full-screen passes run over this group's own pixels, in order, before it
-     * is composited into its parent.
-     *
-     * Unlike every other field here, this does not accumulate down the group
-     * stack — it is a render-target boundary. The children draw into a buffer of
-     * their own, each effect reads the previous one's output, and the result is
-     * composited back under this group's `transform`, `alpha`, `colorMatrix` and
-     * whatever clip encloses it. So a blur here blurs this group and nothing
-     * around it, which is what a CSS `filter` on the canvas cannot do.
-     *
-     * An empty or absent list costs nothing: no buffer is allocated until a
-     * group asks for one.
-     */
-    effects?: readonly Effect[];
-    children: DrawCommand[];
-}
-/**
- * Text draw command. Renders one or more runs at (`x`, `y`) in screen
- * space, optionally word-wrapping at `maxWidth`. The renderer resolves
- * each run's `(fontFamily, fontWeight, fontStyle)` to an MSDF atlas via
- * `resolveFontVariant` and bucket-draws by atlas + color group.
- *
- * `style` carries node-level defaults (`lineHeight`, anti-alias width)
- * that don't belong on individual runs.
- */
-interface TextDrawCommand {
-    kind: 'text';
-    x: number;
-    y: number;
-    runs: ResolvedRun[];
-    maxWidth?: number;
-    align?: 'left' | 'center' | 'right';
-    style: TextStyle;
-    /** Box height for vertical alignment. When set with `verticalAlign`,
-     *  the laid-out block shifts within `[y, y+height]`. */
-    height?: number;
-    /** Default 'top' — the legacy top-anchored behavior. */
-    verticalAlign?: TextVerticalAlign;
-}
-/**
- * Image draw command — renders `image` at screen-space rect (x, y, w, h).
- * The image is stretched to fit; no tiling. Use a pattern FillStyle on a path
- * for tiling.
- */
-interface ImageDrawCommand {
-    kind: 'image';
-    image: ImageBitmap;
-    x: number;
-    y: number;
-    w: number;
-    h: number;
-    opacity?: number;
-    /** Magnification filter. `'linear'` (default) smooths; `'nearest'` shows
-     *  device pixels as hard squares — required by anything magnifying a
-     *  framebuffer readback, where blur destroys the point of the readback. */
-    sampling?: 'linear' | 'nearest';
-    /** Sub-rectangle of `image` to draw, in bitmap pixels from the top-left.
-     *  Omitted draws the whole bitmap. Not range-checked: a rect past the edge
-     *  samples outside [0..1], which CLAMP_TO_EDGE smears. With
-     *  `sampling: 'linear'` the filter reaches half a texel beyond `source`, so
-     *  atlas frames need a gutter (see `SpriteSheet.spacing`) or `'nearest'`. */
-    source?: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-    /** Mirror the sampled region within the destination rect. The quad does not
-     *  move — a flipped draw covers exactly the pixels an unflipped one does. */
-    flipX?: boolean;
-    flipY?: boolean;
-}
-/** Floats per sprite in `SpritesDrawCommand.sprites`. */
-declare const SPRITE_STRIDE = 9;
-/**
- * Draw many quads sampling one bitmap — an atlas, a sprite sheet, a wall of
- * thumbnails. The same picture as a run of `ImageDrawCommand`s the renderer
- * would coalesce anyway, handed over already packed so it never walks a
- * command object per quad.
- *
- * Reach for it past a few thousand sprites. Below that a plain run of image
- * commands merges into the same single draw and reads better; the packed form
- * exists because at 20,000 the object walk is about half the frame.
- *
- * The sprites are one run: they share a texture, a filter, and whatever group
- * transform, alpha, color matrix and clip are live, exactly as a merged run of
- * image commands would. Anything varying per sprite is in the array.
- */
-interface SpritesDrawCommand {
-    kind: 'sprites';
-    image: ImageBitmap;
-    /** Magnification filter for the whole run, as `ImageDrawCommand.sampling`. */
-    sampling?: 'linear' | 'nearest';
-    /**
-     * `SPRITE_STRIDE` floats per sprite:
-     * `dx, dy, dw, dh, sx, sy, sw, sh, opacity`.
-     *
-     * Destination is in the group's coordinates; source is in bitmap pixels,
-     * like `ImageDrawCommand.source`. A negative `sw` or `sh` mirrors that axis
-     * within the source rect, which is what `flipX` / `flipY` do. A trailing
-     * partial sprite is ignored.
-     */
-    sprites: Float32Array;
-}
-/**
- * Custom shader draw command. The renderer generates a quad over `bounds`
- * and dispatches the consumer's fragment shader with the kit's vertex prelude.
- *
- * `uniforms` keys must match names declared in the consumer's fragment shader.
- * The kit automatically sets `u_bounds`, `u_view`, and `u_proj` — do not
- * declare those in `uniforms`.
- *
- * @experimental API may change before v2.
- */
-interface ShaderDrawCommand {
-    kind: 'shader';
-    program: ShaderProgramHandle;
-    uniforms: Record<string, ShaderUniform>;
-    /** Screen-space bounding rect in CSS pixels. */
-    bounds: {
-        x: number;
-        y: number;
-        w: number;
-        h: number;
-    };
-}
-
-export { type DrawCommand as D, type Effect as E, type GroupDrawCommand as G, type ImageDrawCommand as I, type Mat3 as M, type PathDrawCommand as P, SPRITE_STRIDE as S, type TextDrawCommand as T, type ShaderDrawCommand as a, type ShaderProgramHandle as b, type ShaderUniform as c, type SolidPaint as d, type SpritesDrawCommand as e, registerProgram as f, mat3 as m, registerEffect as r };