@doki-land/live2d-renderer 0.0.17 → 0.0.18

package/dist/index.d.ts

@@ -138,123 +138,6 @@ declare class WebGpuRendererImpl implements WebGpuRenderer {
 declare function createWebGpuRenderer(options?: WebGpuRendererOptions): WebGpuRenderer;
 declare function isWebGpuAvailable(): boolean;
 
-/**
- * Map Live2D blend modes to WebGL / Canvas compositing.
- */
-
-/** Apply premultiplied-friendly Live2D blend factors on a WebGL2 context. */
-declare function applyWebGl2BlendMode(gl: WebGL2RenderingContext, mode: BlendMode): void;
-/** Canvas2D globalCompositeOperation for Live2D blend modes. */
-declare function canvasCompositeForBlendMode(mode: BlendMode): GlobalCompositeOperation;
-/** WebGPU blend state for Live2D modes (straight alpha draw path). */
-declare function webGpuBlendState(mode: BlendMode): GPUBlendState;
-
-/**
- * Clipping-mask context grouping + mask atlas layout.
- *
- * Two packing modes:
- * - `uv-grid`: √N UV cells, alpha channel only (Canvas2D / simple path)
- * - `rgba`: Cubism-style channel × UV packing (≤4 → full UV on R/G/B/A)
- */
-interface ClippingDrawableRef {
-    readonly index: number;
-    readonly maskIndices: readonly number[];
-    readonly invertedMask: boolean;
-}
-interface ClippingContext {
-    /** Stable key: invert flag + sorted mask drawable indices. */
-    readonly key: string;
-    readonly maskIndices: readonly number[];
-    readonly clippedIndices: readonly number[];
-    readonly invertedMask: boolean;
-}
-/** UV-space rectangle inside the shared mask atlas (0..1). */
-interface MaskLayoutRect {
-    readonly x: number;
-    readonly y: number;
-    readonly width: number;
-    readonly height: number;
-}
-/** R/G/B/A write/sample selector (Cubism channelFlag). */
-type MaskChannelFlag = readonly [number, number, number, number];
-declare const MASK_CHANNEL_FLAGS: readonly MaskChannelFlag[];
-type MaskAtlasMode = "uv-grid" | "rgba";
-interface MaskAtlasOptions {
-    /** Packing strategy. Default `rgba` (Cubism density). */
-    readonly mode?: MaskAtlasMode;
-    /** Cell inset for `uv-grid` only (reduces neighbour bleed). */
-    readonly inset?: number;
-    /** Render-texture count for `rgba` (default 1 → max 36). */
-    readonly renderTextureCount?: number;
-}
-interface LaidOutClippingContext extends ClippingContext {
-    readonly layout: MaskLayoutRect;
-    /** 0=R … 3=A. `uv-grid` always uses A (3). */
-    readonly channelIndex: number;
-    readonly channelFlag: MaskChannelFlag;
-    /** Cubism multi-RT buffer index; currently always 0. */
-    readonly bufferIndex: number;
-    /**
-     * Expanded AABB of clipped drawables in vertex/NDC space.
-     * Mask write/sample map this rect into `layout` (Cubism bounds-fit).
-     * Default before `fitClippingContexts`: full NDC (-1..1)².
-     */
-    readonly modelBounds: MaskLayoutRect;
-}
-/** Full clip-space quad used when no valid clipped bounds exist. */
-declare const FULL_NDC_BOUNDS: MaskLayoutRect;
-interface ClippingPartition {
-    readonly contexts: readonly LaidOutClippingContext[];
-    /** Drawables that consume a mask (drawn after mask pass). */
-    readonly clipped: ReadonlySet<number>;
-    /** Drawables used as masks (mask buffer only, not color target). */
-    readonly maskOnly: ReadonlySet<number>;
-}
-/**
- * Group drawables that consume clipping masks into shared contexts.
- * Drawables with empty maskIndices are omitted.
- */
-declare function buildClippingContexts(drawables: readonly ClippingDrawableRef[]): ClippingContext[];
-/**
- * Pack clipping contexts into a square-ish UV grid on one atlas (alpha only).
- */
-declare function layoutMaskAtlasUvGrid(contexts: readonly ClippingContext[], options?: {
-    inset?: number;
-}): LaidOutClippingContext[];
-/**
- * Cubism `setupLayoutBounds`: pack across R/G/B/A then UV cells.
- * Single RT → max 36 (4×9); multi-RT → 32 per sheet.
- */
-declare function layoutMaskAtlasRgba(contexts: readonly ClippingContext[], options?: {
-    renderTextureCount?: number;
-}): LaidOutClippingContext[];
-/** Pack clipping contexts (default: Cubism RGBA density). */
-declare function layoutMaskAtlas(contexts: readonly ClippingContext[], options?: MaskAtlasOptions): LaidOutClippingContext[];
-/** Partition drawables and assign atlas layouts. */
-declare function partitionForClipping(drawables: readonly ClippingDrawableRef[], options?: MaskAtlasOptions): ClippingPartition;
-/** Axis-aligned bounds of interleaved xy vertex positions. */
-declare function calcVertexBounds(positions: Float32Array): MaskLayoutRect | null;
-/** Expand bounds by a relative margin on each axis (Cubism uses 0.05). */
-declare function expandBounds(bounds: MaskLayoutRect, margin?: number): MaskLayoutRect;
-interface MaskBoundsMeshRef {
-    readonly index: number;
-    readonly vertexPositions: Float32Array;
-}
-/**
- * Union AABB of clipped drawables, expanded by margin (Cubism
- * `calcClippedDrawableTotalBounds` + 0.05 expand).
- */
-declare function calcClippedDrawableBounds(clippedIndices: readonly number[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): MaskLayoutRect;
-/**
- * Attach per-context `modelBounds` so mask write/sample fit the clipped
- * drawable AABB into the atlas cell (higher mask texel density).
- */
-declare function fitClippingContexts(contexts: readonly LaidOutClippingContext[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): LaidOutClippingContext[];
-/** Flatten layout to `[x, y, w, h]` for GPU uniforms. */
-declare function maskLayoutVec4(layout: MaskLayoutRect): Float32Array;
-/** Flatten channel flag to `[r, g, b, a]` for GPU uniforms. */
-declare function maskChannelVec4(flag: MaskChannelFlag): Float32Array;
-
 declare const CPU_PROGRAM_KIND: "cpu-program";
 interface CpuProgramFile {
     readonly kind: typeof CPU_PROGRAM_KIND;
@@ -299,22 +182,6 @@ declare function evaluateFrame(instance: ModelInstance): FrameSnapshot;
 /** Stable fingerprint for golden tests (positions + topology). */
 declare function fingerprintSnapshot(snapshot: FrameSnapshot): string;
 
-interface CreateRendererOptions {
-    /**
-     * Backend try order at initialize time.
-     * Default: `["webgpu", "webgl2", "canvas2d"]`.
-     */
-    prefer?: RendererKind[];
-    webgpu?: WebGpuRendererOptions;
-    webgl2?: WebGl2RendererOptions;
-    canvas2d?: Canvas2DRendererOptions;
-}
-/**
- * Create a renderer provider. Actual backend is chosen on `initialize`
- * (WebGPU → WebGL2 → Canvas2D by default).
- */
-declare function createRenderer(options?: CreateRendererOptions): Renderer;
-
 /**
  * moc binary format peek. Settings JSON detection lives in live2d-core
  * (`detectModelSettingsFormat`) so loader and renderer share one helper.
@@ -522,6 +389,123 @@ declare function applyMoc3Glues(positionsByMesh: Map<number, Float32Array>, glue
 /** Mean Euclidean distance between glued vertex pairs (for tests). */
 declare function meanGlueSeamDistance(positionsByMesh: ReadonlyMap<number, Float32Array>, glue: Moc3GlueDef): number;
 
+/**
+ * Map Live2D blend modes to WebGL / Canvas compositing.
+ */
+
+/** Apply premultiplied-friendly Live2D blend factors on a WebGL2 context. */
+declare function applyWebGl2BlendMode(gl: WebGL2RenderingContext, mode: BlendMode): void;
+/** Canvas2D globalCompositeOperation for Live2D blend modes. */
+declare function canvasCompositeForBlendMode(mode: BlendMode): GlobalCompositeOperation;
+/** WebGPU blend state for Live2D modes (straight alpha draw path). */
+declare function webGpuBlendState(mode: BlendMode): GPUBlendState;
+
+/**
+ * Clipping-mask context grouping + mask atlas layout.
+ *
+ * Two packing modes:
+ * - `uv-grid`: √N UV cells, alpha channel only (Canvas2D / simple path)
+ * - `rgba`: Cubism-style channel × UV packing (≤4 → full UV on R/G/B/A)
+ */
+interface ClippingDrawableRef {
+    readonly index: number;
+    readonly maskIndices: readonly number[];
+    readonly invertedMask: boolean;
+}
+interface ClippingContext {
+    /** Stable key: invert flag + sorted mask drawable indices. */
+    readonly key: string;
+    readonly maskIndices: readonly number[];
+    readonly clippedIndices: readonly number[];
+    readonly invertedMask: boolean;
+}
+/** UV-space rectangle inside the shared mask atlas (0..1). */
+interface MaskLayoutRect {
+    readonly x: number;
+    readonly y: number;
+    readonly width: number;
+    readonly height: number;
+}
+/** R/G/B/A write/sample selector (Cubism channelFlag). */
+type MaskChannelFlag = readonly [number, number, number, number];
+declare const MASK_CHANNEL_FLAGS: readonly MaskChannelFlag[];
+type MaskAtlasMode = "uv-grid" | "rgba";
+interface MaskAtlasOptions {
+    /** Packing strategy. Default `rgba` (Cubism density). */
+    readonly mode?: MaskAtlasMode;
+    /** Cell inset for `uv-grid` only (reduces neighbour bleed). */
+    readonly inset?: number;
+    /** Render-texture count for `rgba` (default 1 → max 36). */
+    readonly renderTextureCount?: number;
+}
+interface LaidOutClippingContext extends ClippingContext {
+    readonly layout: MaskLayoutRect;
+    /** 0=R … 3=A. `uv-grid` always uses A (3). */
+    readonly channelIndex: number;
+    readonly channelFlag: MaskChannelFlag;
+    /** Cubism multi-RT buffer index; currently always 0. */
+    readonly bufferIndex: number;
+    /**
+     * Expanded AABB of clipped drawables in vertex/NDC space.
+     * Mask write/sample map this rect into `layout` (Cubism bounds-fit).
+     * Default before `fitClippingContexts`: full NDC (-1..1)².
+     */
+    readonly modelBounds: MaskLayoutRect;
+}
+/** Full clip-space quad used when no valid clipped bounds exist. */
+declare const FULL_NDC_BOUNDS: MaskLayoutRect;
+interface ClippingPartition {
+    readonly contexts: readonly LaidOutClippingContext[];
+    /** Drawables that consume a mask (drawn after mask pass). */
+    readonly clipped: ReadonlySet<number>;
+    /** Drawables used as masks (mask buffer only, not color target). */
+    readonly maskOnly: ReadonlySet<number>;
+}
+/**
+ * Group drawables that consume clipping masks into shared contexts.
+ * Drawables with empty maskIndices are omitted.
+ */
+declare function buildClippingContexts(drawables: readonly ClippingDrawableRef[]): ClippingContext[];
+/**
+ * Pack clipping contexts into a square-ish UV grid on one atlas (alpha only).
+ */
+declare function layoutMaskAtlasUvGrid(contexts: readonly ClippingContext[], options?: {
+    inset?: number;
+}): LaidOutClippingContext[];
+/**
+ * Cubism `setupLayoutBounds`: pack across R/G/B/A then UV cells.
+ * Single RT → max 36 (4×9); multi-RT → 32 per sheet.
+ */
+declare function layoutMaskAtlasRgba(contexts: readonly ClippingContext[], options?: {
+    renderTextureCount?: number;
+}): LaidOutClippingContext[];
+/** Pack clipping contexts (default: Cubism RGBA density). */
+declare function layoutMaskAtlas(contexts: readonly ClippingContext[], options?: MaskAtlasOptions): LaidOutClippingContext[];
+/** Partition drawables and assign atlas layouts. */
+declare function partitionForClipping(drawables: readonly ClippingDrawableRef[], options?: MaskAtlasOptions): ClippingPartition;
+/** Axis-aligned bounds of interleaved xy vertex positions. */
+declare function calcVertexBounds(positions: Float32Array): MaskLayoutRect | null;
+/** Expand bounds by a relative margin on each axis (Cubism uses 0.05). */
+declare function expandBounds(bounds: MaskLayoutRect, margin?: number): MaskLayoutRect;
+interface MaskBoundsMeshRef {
+    readonly index: number;
+    readonly vertexPositions: Float32Array;
+}
+/**
+ * Union AABB of clipped drawables, expanded by margin (Cubism
+ * `calcClippedDrawableTotalBounds` + 0.05 expand).
+ */
+declare function calcClippedDrawableBounds(clippedIndices: readonly number[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): MaskLayoutRect;
+/**
+ * Attach per-context `modelBounds` so mask write/sample fit the clipped
+ * drawable AABB into the atlas cell (higher mask texel density).
+ */
+declare function fitClippingContexts(contexts: readonly LaidOutClippingContext[], byIndex: ReadonlyMap<number, MaskBoundsMeshRef>, margin?: number): LaidOutClippingContext[];
+/** Flatten layout to `[x, y, w, h]` for GPU uniforms. */
+declare function maskLayoutVec4(layout: MaskLayoutRect): Float32Array;
+/** Flatten channel flag to `[r, g, b, a]` for GPU uniforms. */
+declare function maskChannelVec4(flag: MaskChannelFlag): Float32Array;
+
 /** Shared untextured preview colors (Canvas2D / WebGL2 / WebGPU parity). */
 declare const PREVIEW_FILL: {
     readonly r: number;
@@ -538,6 +522,22 @@ declare const PREVIEW_STROKE: {
 /** Expand triangle indices into a line-list (each edge twice-wound). */
 declare function triangleEdgesToLineList(indices: Uint16Array): Uint16Array;
 
+interface CreateRendererOptions {
+    /**
+     * Backend try order at initialize time.
+     * Default: `["webgpu", "webgl2", "canvas2d"]`.
+     */
+    prefer?: RendererKind[];
+    webgpu?: WebGpuRendererOptions;
+    webgl2?: WebGl2RendererOptions;
+    canvas2d?: Canvas2DRendererOptions;
+}
+/**
+ * Create a renderer provider. Actual backend is chosen on `initialize`
+ * (WebGPU → WebGL2 → Canvas2D by default).
+ */
+declare function createRenderer(options?: CreateRendererOptions): Renderer;
+
 /** One-time decode of moc bytes for stage-level {@link ModelAsset} sharing. */
 declare function compileSharedModelCompile(settings: ModelSettings, mocBytes: ArrayBuffer): SharedModelCompile;
 

package/dist/index.js

@@ -2620,97 +2620,6 @@ function fingerprintSnapshot(snapshot) {
   return parts.join("|");
 }
 
-// src/runtime/create-renderer.ts
-var DEFAULT_PREFER = ["webgpu", "webgl2", "canvas2d"];
-var INIT_TIMEOUT_MS = {
-  webgpu: 2500,
-  webgl2: 1500,
-  canvas2d: 1e3
-};
-function instantiate(kind, options) {
-  if (kind === "webgpu") return createWebGpuRenderer(options.webgpu);
-  if (kind === "webgl2") return createWebGl2Renderer(options.webgl2);
-  return createCanvas2DRenderer(options.canvas2d);
-}
-async function initializeWithTimeout(kind, candidate, canvas) {
-  const ms = INIT_TIMEOUT_MS[kind];
-  let timer;
-  try {
-    await Promise.race([
-      candidate.initialize(canvas),
-      new Promise((_, reject) => {
-        timer = setTimeout(() => {
-          reject(
-            new Error(
-              `@doki-land/live2d-renderer: ${kind} initialize timed out after ${ms}ms`
-            )
-          );
-        }, ms);
-      })
-    ]);
-  } finally {
-    if (timer !== void 0) clearTimeout(timer);
-  }
-}
-var FallbackRenderer = class {
-  #inner = null;
-  #kind = "webgpu";
-  #prefer;
-  #options;
-  constructor(prefer, options) {
-    this.#prefer = prefer;
-    this.#options = options;
-  }
-  get kind() {
-    return this.#inner?.kind ?? this.#kind;
-  }
-  async initialize(canvas) {
-    const errors = [];
-    for (const kind of this.#prefer) {
-      const candidate = instantiate(kind, this.#options);
-      try {
-        await initializeWithTimeout(kind, candidate, canvas);
-        this.#inner = candidate;
-        this.#kind = candidate.kind;
-        return;
-      } catch (err) {
-        candidate.destroy();
-        errors.push(
-          `${kind}: ${err instanceof Error ? err.message : String(err)}`
-        );
-      }
-    }
-    throw new Error(
-      `@doki-land/live2d-renderer: no renderer initialized (${errors.join("; ")})`
-    );
-  }
-  createModelDrawPass() {
-    if (!this.#inner) {
-      throw new Error(
-        "@doki-land/live2d-renderer: renderer not initialized"
-      );
-    }
-    return this.#inner.createModelDrawPass();
-  }
-  beginFrame() {
-    this.#inner?.beginFrame();
-  }
-  endFrame() {
-    this.#inner?.endFrame();
-  }
-  resize(width, height) {
-    this.#inner?.resize(width, height);
-  }
-  destroy() {
-    this.#inner?.destroy();
-    this.#inner = null;
-  }
-};
-function createRenderer(options = {}) {
-  const prefer = options.prefer?.length ? options.prefer : DEFAULT_PREFER;
-  return new FallbackRenderer(prefer, options);
-}
-
 // src/format/detect-format.ts
 import { detectModelSettingsFormat } from "@doki-land/live2d-core";
 function detectMocBinaryFormat(bytes) {
@@ -5512,6 +5421,97 @@ function createMoc3Backend() {
   return new Moc3Backend();
 }
 
+// src/runtime/create-renderer.ts
+var DEFAULT_PREFER = ["webgpu", "webgl2", "canvas2d"];
+var INIT_TIMEOUT_MS = {
+  webgpu: 2500,
+  webgl2: 1500,
+  canvas2d: 1e3
+};
+function instantiate(kind, options) {
+  if (kind === "webgpu") return createWebGpuRenderer(options.webgpu);
+  if (kind === "webgl2") return createWebGl2Renderer(options.webgl2);
+  return createCanvas2DRenderer(options.canvas2d);
+}
+async function initializeWithTimeout(kind, candidate, canvas) {
+  const ms = INIT_TIMEOUT_MS[kind];
+  let timer;
+  try {
+    await Promise.race([
+      candidate.initialize(canvas),
+      new Promise((_, reject) => {
+        timer = setTimeout(() => {
+          reject(
+            new Error(
+              `@doki-land/live2d-renderer: ${kind} initialize timed out after ${ms}ms`
+            )
+          );
+        }, ms);
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+var FallbackRenderer = class {
+  #inner = null;
+  #kind = "webgpu";
+  #prefer;
+  #options;
+  constructor(prefer, options) {
+    this.#prefer = prefer;
+    this.#options = options;
+  }
+  get kind() {
+    return this.#inner?.kind ?? this.#kind;
+  }
+  async initialize(canvas) {
+    const errors = [];
+    for (const kind of this.#prefer) {
+      const candidate = instantiate(kind, this.#options);
+      try {
+        await initializeWithTimeout(kind, candidate, canvas);
+        this.#inner = candidate;
+        this.#kind = candidate.kind;
+        return;
+      } catch (err) {
+        candidate.destroy();
+        errors.push(
+          `${kind}: ${err instanceof Error ? err.message : String(err)}`
+        );
+      }
+    }
+    throw new Error(
+      `@doki-land/live2d-renderer: no renderer initialized (${errors.join("; ")})`
+    );
+  }
+  createModelDrawPass() {
+    if (!this.#inner) {
+      throw new Error(
+        "@doki-land/live2d-renderer: renderer not initialized"
+      );
+    }
+    return this.#inner.createModelDrawPass();
+  }
+  beginFrame() {
+    this.#inner?.beginFrame();
+  }
+  endFrame() {
+    this.#inner?.endFrame();
+  }
+  resize(width, height) {
+    this.#inner?.resize(width, height);
+  }
+  destroy() {
+    this.#inner?.destroy();
+    this.#inner = null;
+  }
+};
+function createRenderer(options = {}) {
+  const prefer = options.prefer?.length ? options.prefer : DEFAULT_PREFER;
+  return new FallbackRenderer(prefer, options);
+}
+
 // src/runtime/model-runtime.ts
 function selectModelBackend(backends, json) {
   const hit = backends.find((b) => b.canHandle(json));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doki-land/live2d-renderer",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Live2D rendering — moc2/moc3 decode + WebGPU, WebGL2, Canvas2D backends for live2d.ts.",
   "type": "module",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "test": "vitest run"
   },
   "dependencies": {
-    "@doki-land/live2d-core": "0.0.17"
+    "@doki-land/live2d-core": "0.0.18"
   },
   "sideEffects": false
 }

package/src/index.ts

@@ -29,34 +29,6 @@ export {
     WebGpuRendererImpl,
     type WebGpuRendererOptions,
 } from "./backends/webgpu.js";
-export {
-    applyWebGl2BlendMode,
-    canvasCompositeForBlendMode,
-    webGpuBlendState,
-} from "./render/blend.js";
-export {
-    buildClippingContexts,
-    type ClippingContext,
-    type ClippingDrawableRef,
-    type ClippingPartition,
-    calcClippedDrawableBounds,
-    calcVertexBounds,
-    expandBounds,
-    FULL_NDC_BOUNDS,
-    fitClippingContexts,
-    type LaidOutClippingContext,
-    layoutMaskAtlas,
-    layoutMaskAtlasRgba,
-    layoutMaskAtlasUvGrid,
-    MASK_CHANNEL_FLAGS,
-    type MaskAtlasMode,
-    type MaskAtlasOptions,
-    type MaskChannelFlag,
-    type MaskLayoutRect,
-    maskChannelVec4,
-    maskLayoutVec4,
-    partitionForClipping,
-} from "./render/clipping.js";
 export {
     CPU_PROGRAM_KIND,
     type CpuProgramFile,
@@ -71,10 +43,6 @@ export {
     fingerprintSnapshot,
     setParameterValue,
 } from "./cpu/evaluate.js";
-export {
-    type CreateRendererOptions,
-    createRenderer,
-} from "./runtime/create-renderer.js";
 export {
     detectMocBinaryFormat,
     detectModelSettingsFormat,
@@ -99,6 +67,43 @@ export {
     type Moc3GluePair,
     meanGlueSeamDistance,
 } from "./moc/moc3-glue.js";
+export {
+    applyWebGl2BlendMode,
+    canvasCompositeForBlendMode,
+    webGpuBlendState,
+} from "./render/blend.js";
+export {
+    buildClippingContexts,
+    type ClippingContext,
+    type ClippingDrawableRef,
+    type ClippingPartition,
+    calcClippedDrawableBounds,
+    calcVertexBounds,
+    expandBounds,
+    FULL_NDC_BOUNDS,
+    fitClippingContexts,
+    type LaidOutClippingContext,
+    layoutMaskAtlas,
+    layoutMaskAtlasRgba,
+    layoutMaskAtlasUvGrid,
+    MASK_CHANNEL_FLAGS,
+    type MaskAtlasMode,
+    type MaskAtlasOptions,
+    type MaskChannelFlag,
+    type MaskLayoutRect,
+    maskChannelVec4,
+    maskLayoutVec4,
+    partitionForClipping,
+} from "./render/clipping.js";
+export {
+    PREVIEW_FILL,
+    PREVIEW_STROKE,
+    triangleEdgesToLineList,
+} from "./render/preview-style.js";
+export {
+    type CreateRendererOptions,
+    createRenderer,
+} from "./runtime/create-renderer.js";
 export {
     type ModelBackend,
     type ModelBackendOptions,
@@ -106,11 +111,6 @@ export {
     type SharedModelCompile,
     selectModelBackend,
 } from "./runtime/model-runtime.js";
-export {
-    PREVIEW_FILL,
-    PREVIEW_STROKE,
-    triangleEdgesToLineList,
-} from "./render/preview-style.js";
 export { compileSharedModelCompile } from "./runtime/shared-compile.js";
 export {
     BlendMode,