framefields 2.11.0 → 2.13.0

package/dist/{index-BuiZzc6i.d.mts → index-X2u96TEo.d.mts}

@@ -1,4 +1,4 @@
-import { Pt as MeshAudioDeformConfig, ur as VirtualMediaData } from "./index-COYNQ_mf.mjs";
+import { Pt as MeshAudioDeformConfig, an as OutputItem, bt as MediaOperation, ur as VirtualMediaData } from "./index-a6JrbAK0.mjs";
 import { z } from "zod";
 import { Input, VideoSample } from "mediabunny";
 import "fontkit";
@@ -2198,6 +2198,12 @@ declare class WebGPUAudioProcessor {
   private static devicePipelineCache;
   private static getDeviceCache;
   static getCache(device: GPUDevice, renderId: string | undefined, nodeId: string, activeSignalsKey?: string, stateFloatCount?: number): CachedPipelineAndState | undefined;
+  /**
+   * Zeroes the state every effect keeps for `renderId` (delay lines,
+   * envelopes, reverb tails), as on its first use. Pipelines and buffers
+   * stay, so a mix that starts again doesn't compile them again.
+   */
+  static resetState(renderId: string, device: GPUDevice): void;
   static clearCache(renderId: string, device?: GPUDevice): void;
   static process(device: GPUDevice, nodeId: string, channels: Float32Array[], _sampleRate: number, virtualMedia: VirtualMediaData, frame: number, fps: number, shaderTemplate: (params: {
     customSignalWGSL: string;
@@ -2206,6 +2212,12 @@ declare class WebGPUAudioProcessor {
 }
 //#endregion
 //#region src/renderer2d/transform-stack.d.ts
+/**
+ * Target pixels per local unit along the axis `m` stretches most: what a
+ * raster drawn under `m` needs per unit to stay sharp, and what one target
+ * pixel is in local units (its inverse).
+ */
+
 declare class TransformStack {
   private stack;
   push(matrix: DOMMatrix): void;
@@ -2601,16 +2613,27 @@ declare function initHeadlessWebGPU(): Promise<void>;
  * whose font changed.
  */
 
-//#endregion
-//#region src/input-store.d.ts
+/**
+ * Where to read a local media file that isn't on disk: a URL for it (a
+ * project's asset pinned on a bucket), or undefined.
+ */
+type MissingMediaResolver = (filePath: string) => Promise<string | undefined>;
 declare class InputStore {
   private store;
+  private resolveMissing?;
+  /**
+   * Reads local files that are missing from disk from the URL `resolver`
+   * gives, with HTTP range requests, so a clip pinned on a bucket plays
+   * without being downloaded. Unset with no argument.
+   */
+  setMissingMediaResolver(resolver?: MissingMediaResolver): void;
   acquire(url: string): Promise<Input>;
   /**
    * Drops every cached input, including ones a failed render never released.
    * Used between jobs, when the same path may now hold a different file.
    */
   clear(): void;
+  private localSource;
   release(url: string): void;
 }
 declare const inputStore: InputStore;
@@ -3381,6 +3404,21 @@ interface ShardGeometryOptions extends PrimitiveSurface {
   /** How unevenly planes cut toward the center, 0..0.85 (0 = regular polyhedron, 0.5 = jagged). Default 0.35. */
   irregularity?: number;
 }
+/**
+ * A layer's relief: the brightness of `texture` over `uvRect` pushes the
+ * layer's plane toward `eye` by up to `amount` px, along the rays to `eye`, so
+ * from there the surface still looks like the flat layer. Where the
+ * brightness jumps (an object's outline) the surface stretches across.
+ */
+interface Relief3D {
+  texture: GPUTexture;
+  /** Where the layer's box sits in `texture`: [u, v, width, height], 0..1. */
+  uvRect: [number, number, number, number];
+  /** Height of white, in world px. */
+  amount: number;
+  /** The viewpoint the surface keeps its look from: the default camera's eye. */
+  eye: [number, number, number];
+}
 interface ModelUniformData extends SurfaceParams {
   modelMatrix: Float32Array | number[];
   normalMatrix?: Float32Array | number[];
@@ -3397,6 +3435,8 @@ interface ModelUniformData extends SurfaceParams {
   material?: "lit" | "unlit";
   /** Screen-space track matte: the layer shows where this texture's alpha does. */
   matte?: GPUTexture;
+  /** Turns the flat quad into a surface lifted by another picture's brightness. */
+  relief?: Relief3D;
   shininess?: number;
   roughness?: number;
   specularIntensity?: number;
@@ -3420,11 +3460,17 @@ declare class Quad3DPipeline {
   private modelPool;
   private vertexBuffer;
   private indexBuffer;
+  /** The relief grid, built on first use. */
+  private reliefGrid?;
   private modelData;
   constructor(device: GPUDevice, format: GPUTextureFormat, depthFormat?: GPUTextureFormat, /** Samples per pixel of the pass this draws into (MSAA). */
   sampleCount?: number);
   resetPools(): void;
   private packModel;
+  /** Binds the geometry for `data` and draws it: the quad, or the relief grid. */
+  private drawGeometry;
+  /** A RELIEF_GRID² grid over the unit quad, laid out like the quad's vertices. */
+  private createReliefGrid;
   private textureBindGroup;
   draw(pass: GPURenderPassEncoder, cameraBindGroup: GPUBindGroup, lightsBindGroup: GPUBindGroup, texture: GPUTexture, sampler: GPUSampler, data: ModelUniformData, useMrt?: boolean, useBloom?: boolean): void;
   /** Draws the quad into a shadow map (`lightCameraBindGroup` holds the light's view-projection). */
@@ -3653,6 +3699,8 @@ interface DrawQuad3DOpts extends SurfaceParams {
    * this texture's alpha does and keeps its place in the depth buffer.
    */
   matte?: GPUTexture;
+  /** Lifts the layer's plane into a surface by another picture's brightness. */
+  relief?: Relief3D;
 }
 interface DrawMesh3DOpts extends SurfaceParams {
   /** Refractive index for glass materials (default 1.5). */
@@ -4389,5 +4437,114 @@ declare global {
   var __GATEWAI_DELAYS__: Set<number>;
 }
 //#endregion
-export { loadOBJ as $, evaluateSelectorCombination as $n, SelectorShapeSchema as $t, Renderer3D as A, TypewriterAnimator as An, LightKind as Ar, ExpressionSelector as At, SlugPipeline as B, VolumetricFormationMode as Bn, Vec3 as Br, LineSpacingDynamics as Bt, Model3DData as C, TextScrambleConfigSchema as Cn, FrustumPlane as Cr, CubicBezierSegment as Ct, PolyhedronGeometryOptions as D, TextSignalSelectorSchema as Dn, LIGHT_UNIFORM_SIZE_BYTES as Dr, EnhancedTextNode as Dt, Points3DGeometryOptions as E, TextSignalSelector as En, HelixOptions as Er, DynamicStrokePropertiesSchema as Et, ShardGeometryOptions as F, VariableFontAxesSchema as Fn, Path3D as Fr, GlyphAnchorGroupingSchema as Ft, WebGPUAudioProcessor as G, computeRangeSelectorWeight as Gn, ParticleDissolveConfigSchema as Gt, TorusGeometryOptions as H, buildPathLUT as Hn, linearRgb as Hr, LongShadowConfig as Ht, SignalRegistry as I, Vec2 as In, Path3DPoint as Ir, GlyphAnchorPoint as It, ensureDevice as J, ellipseToCubicBeziers as Jn, SelectorBasedOn as Jt, buildWGSLSignalFn as K, deterministicWigglyNoise as Kn, PathChainLUT as Kt, SignalRegistryResource as L, Vec2Schema as Ln, Path3DSample as Lr, GlyphAnchorPointSchema as Lt, RoundedBoxGeometryOptions as M, TypingCadence as Mn, MAX_LIGHTS as Mr, ExtendedGlyphProperties as Mt, SSAOPipeline as N, TypingCadenceSchema as Nn, Mat4 as Nr, ExtendedGlyphPropertiesSchema as Nt, RenderContextValue as O, TextWigglySelector as On, Light3D as Or, EnhancedTextNodeSchema as Ot, ShadowPipeline as P, VariableFontAxes as Pn, Matrix4Math as Pr, GlyphAnchorGrouping as Pt, loadModel3D as Q, evaluateMarqueeOffset as Qn, SelectorShape as Qt, Skeleton3D as R, VolumetricFormationConfig as Rn, ResolvedEnvironment as Rr, KineticMarqueeConfig as Rt, Mesh3DData as S, TextScrambleConfig as Sn, Environment3DOptions as Sr, ChromaticGlitchConfigSchema as St, NodeAnimationTrack3D as T, TextSelectorSchema as Tn, GPULightData as Tr, DynamicStrokeProperties as Tt, TubeGeometryOptions as U, computeAnchorPivotOffset as Un, parseColorToRgb as Ur, LongShadowConfigSchema as Ut, SphereGeometryOptions as V, VolumetricFormationModeSchema as Vn, Vector3Math as Vr, LineSpacingDynamicsSchema as Vt, TubePathSpec as W, computeLineLeadingDisplacement as Wn, resolveEnvironment as Wr, ParticleDissolveConfig as Wt, inputStore as X, evaluateCubicBezierDerivative as Xn, SelectorMode as Xt, initHeadlessWebGPU as Y, evaluateCubicBezier as Yn, SelectorBasedOnSchema as Yt, loadFBX as Z, evaluateExpressionSelector as Zn, SelectorModeSchema as Zt, LatheGeometryOptions as _, TextPathOptionsSchema as _n, CatmullRomOptions as _r, AnimatableGlyphPropsSchema as _t, AudioMeshDeformPipeline as a, Spatial3DPropertiesSchema as an, generatePathSegments as ar, signalRegistry as at, MasterAudioEntry as b, TextRangeSelector as bn, Environment3DFloor as br, AudioSpectrumTypographySchema as bt, AudioSignalComputePipeline as c, TextAnchorConfig as cn, parseSvgPathToCubicBeziers as cr, AETextAnimatorSchema as ct, CapsuleGeometryOptions as d, TextCursorConfig as dn, samplePathChainGeometry as dr, AdvancedTextAnimatorSchema as dt, SelectorUnits as en, evaluateSkewMatrix as er, lutStore as et, CylinderGeometryOptions as f, TextCursorConfigSchema as fn, waveToCubicBeziers as fr, AnchorGrouping as ft, GpuAdapterDescription as g, TextPathOptions as gn, CameraShakeOptions as gr, AnimatableGlyphProps as gt, GlassPipeline as h, TextPathBuilder as hn, Camera3DPose as hr, AnchorPresetSchema as ht, AudioLatentTrackCache as i, Spatial3DProperties as in, generateArcLengthLUT as ir, shaderStore as it, RingGeometryOptions as j, TypewriterAnimatorSchema as jn, LightsUniformData as jr, ExpressionSelectorSchema as jt, Renderer2D as k, TextWigglySelectorSchema as kn, Light3DOptions as kr, ExpressionEvaluationContext as kt, BlendMode as l, TextAnchorConfigSchema as ln, sampleAudioSpectrumScale as lr, AdvancedTextAnimator as lt, ExtrudeShapeGeometryOptions as m, TextCursorStyleSchema as mn, Camera3D as mr, AnchorPreset as mt, AudioLatentData as n, SkewProperties as nn, evaluateTypewriterState as nr, parseMTL as nt, AudioPitchTrackConfig as o, SpringPhysics as on, getScramblePool as or, textureCache as ot, EffectPipeline as p, TextCursorStyle as pn, BezierSegment3D as pr, AnchorGroupingSchema as pt, describeGpu as q, distanceToCurveParameter as qn, PathChainLUTEntry as qt, AudioLatentEngine as r, SkewPropertiesSchema as rn, evaluateVolumetricFormation as rr, parseOBJ as rt, AudioSignalComputeConfig as s, SpringPhysicsSchema as sn, getShuffledOrder as sr, AETextAnimator as st, AnimationClip3D as t, SelectorUnitsSchema as tn, evaluateSpringProgress as tr, parseFBX as tt, Bone3D as u, TextAnimatorBuilder as un, sampleCurveGeometry as ur, AdvancedTextAnimatorBuilder as ut, Line3DGeometryOptions as v, TextPathSource as vn, CirclePathOptions as vr, ArcLengthLUTEntry as vt, MotionBlurPipeline as w, TextSelector as wn, FrustumPlanes as wr, CubicBezierSegmentSchema as wt, Material3D as x, TextRangeSelectorSchema as xn, Environment3DFog as xr, ChromaticGlitchConfig as xt, LoadModelOptions as y, TextPathSourceSchema as yn, ENVIRONMENT_PRESETS as yr, AudioSpectrumTypography as yt, SlugFontCache as z, VolumetricFormationConfigSchema as zn, ShadowUniformInfo as zr, KineticMarqueeConfigSchema as zt };
-//# sourceMappingURL=index-BuiZzc6i.d.mts.map
+//#region ../node-sdk/dist/index-DCPaiCIF.d.mts
+//#endregion
+//#region renderer/index.d.ts
+type GPUCommandEncoder$1 = globalThis.GPUCommandEncoder;
+type GPURenderPassEncoder$1 = globalThis.GPURenderPassEncoder;
+type GPUTextureView$1 = globalThis.GPUTextureView;
+type GPUTexture$1 = globalThis.GPUTexture;
+interface NodeRenderProps<TOperation extends MediaOperation = MediaOperation> {
+  renderId: string;
+  virtualMedia: VirtualMediaData<TOperation>;
+  volume?: number;
+  playbackRateOverride?: number;
+  trimStartOverride?: number;
+  trimEndOverride?: number;
+  containerWidth: number;
+  containerHeight: number;
+  /**
+   * Target pixels per layout pixel, when a compositor runs an effect on a
+   * layer rasterized above layout size so it stays sharp scaled up; unset
+   * means 1. Only renderers that declare `maxPixelScale` get more than 1.
+   */
+  pixelScale?: number;
+  opacity?: number;
+  frame?: number;
+  compositionFrame?: number;
+  /** Absolute source time for a remapped media leaf; effect clocks stay unchanged. */
+  sourceTimeSec?: number;
+  fps?: number;
+  elapsedMs?: number;
+  durationMs?: number;
+  timestampSec?: number;
+  renderingContext?: "visual" | "audio";
+  inheritedSeekOffset?: number;
+  inheritedClockOffset?: number;
+  isHeadless?: boolean;
+  forceWait?: boolean;
+  isVideoMode?: boolean;
+  isPlaying?: boolean;
+  excludeTextures?: GPUTexture$1[];
+  /** Signal values that override the node's own (text animators read them). */
+  signals?: Record<string, unknown>;
+  renderChild?: (child: VirtualMediaData, overrides?: Partial<NodeRenderProps>) => unknown;
+}
+/**
+ * How far an effect draws past the pixels it is given, px, for one of its
+ * operations; `null` when it isn't local (it reads or writes pixels anywhere,
+ * like a mirror or a portal) or can't tell (a size driven by a signal).
+ */
+type EffectReach = (operation: Record<string, unknown>) => number | null;
+/**
+ * How many target pixels per layout pixel (`props.pixelScale`) an effect can
+ * run at and still look as it does at layout size, for one of its operations:
+ * it reads its pixel-unit parameters (a blur radius, a shadow's distance) in
+ * layout px and multiplies them by `pixelScale`, up to its own kernel limits.
+ * `Infinity` when nothing in it is measured in pixels.
+ */
+type EffectMaxPixelScale = (operation: Record<string, unknown>) => number;
+/**
+ * A node's GPU renderer. An effect renderer may carry `reach`: a compositor
+ * then runs it over the layer's own region plus that margin instead of the
+ * whole target. Without it the effect always gets the whole target. It may
+ * also carry `maxPixelScale`: a compositor may then rasterize a layer it
+ * styles above layout size (a layer scaled up stays sharp). Without it such a
+ * layer keeps its layout size.
+ */
+type WebGPUNodeRenderer<TOperation extends MediaOperation = MediaOperation> = WebGPUNodeRenderFn<TOperation> & {
+  reach?: EffectReach;
+  maxPixelScale?: EffectMaxPixelScale;
+};
+type WebGPUNodeRenderFn<TOperation extends MediaOperation> = (args: {
+  ctx: RenderContextValue;
+  encoder: GPUCommandEncoder$1;
+  pass: GPURenderPassEncoder$1;
+  targetView: GPUTextureView$1;
+  targetTexture: GPUTexture$1;
+  targetWidth: number;
+  targetHeight: number;
+  props: NodeRenderProps<TOperation>;
+  drawChild: (child: VirtualMediaData, overrides?: Partial<NodeRenderProps>, targetViewOverride?: GPUTextureView$1, targetTextureOverride?: GPUTexture$1, targetWidthOverride?: number, targetHeightOverride?: number) => Promise<void>;
+}) => Promise<void> | void;
+interface AudioProcessorContext {
+  device?: GPUDevice;
+  frame?: number;
+  compositionFrame?: number;
+  fps?: number;
+  elapsedMs?: number;
+  durationMs?: number;
+  renderId?: string;
+}
+type AudioProcessor<TOperation extends MediaOperation = MediaOperation> = (channels: Float32Array[], sampleRate: number, virtualMedia: VirtualMediaData<TOperation>, ctx?: AudioProcessorContext) => void | Promise<void>;
+/**
+ * A numeric node parameter at `frame`: a number, a signal-like `get(ctx)` or
+ * `{ value }`, a `(ctx) => number` function, or anything `Number()` accepts;
+ * `fallback` when none of those yields a finite number.
+ */
+
+interface NodeRendererPlugin {
+  WebGPURenderer?: WebGPUNodeRenderer;
+  audioProcessor?: AudioProcessor;
+}
+//#endregion
+//#region ../node-sdk/dist/index.d.mts
+declare const SignalResultSchema: z.ZodObject<{
+  selectedOutputIndex: z.ZodLiteral<0>;
+  outputs: z.ZodTuple<[z.ZodObject<{
+    items: z.ZodTuple<[z.ZodType<OutputItem<"Signal">, unknown, z.core.$ZodTypeInternals<OutputItem<"Signal">, unknown>>], null>;
+  }, z.core.$strip>], null>;
+}, z.core.$strip>;
+//#endregion
+export { inputStore as $, evaluateCubicBezierDerivative as $n, SelectorMode as $t, PolyhedronGeometryOptions as A, TextSignalSelectorSchema as An, LIGHT_UNIFORM_SIZE_BYTES as Ar, EnhancedTextNode as At, SignalRegistryResource as B, Vec2Schema as Bn, Path3DSample as Br, GlyphAnchorPointSchema as Bt, MasterAudioEntry as C, TextRangeSelector as Cn, Environment3DFloor as Cr, AudioSpectrumTypographySchema as Ct, MotionBlurPipeline as D, TextSelector as Dn, FrustumPlanes as Dr, CubicBezierSegmentSchema as Dt, Model3DData as E, TextScrambleConfigSchema as En, FrustumPlane as Er, CubicBezierSegment as Et, RoundedBoxGeometryOptions as F, TypingCadence as Fn, MAX_LIGHTS as Fr, ExtendedGlyphProperties as Ft, TorusGeometryOptions as G, buildPathLUT as Gn, linearRgb as Gr, LongShadowConfig as Gt, SlugFontCache as H, VolumetricFormationConfigSchema as Hn, ShadowUniformInfo as Hr, KineticMarqueeConfigSchema as Ht, SSAOPipeline as I, TypingCadenceSchema as In, Mat4 as Ir, ExtendedGlyphPropertiesSchema as It, WebGPUAudioProcessor as J, computeRangeSelectorWeight as Jn, ParticleDissolveConfigSchema as Jt, TubeGeometryOptions as K, computeAnchorPivotOffset as Kn, parseColorToRgb as Kr, LongShadowConfigSchema as Kt, ShadowPipeline as L, VariableFontAxes as Ln, Matrix4Math as Lr, GlyphAnchorGrouping as Lt, Renderer2D as M, TextWigglySelectorSchema as Mn, Light3DOptions as Mr, ExpressionEvaluationContext as Mt, Renderer3D as N, TypewriterAnimator as Nn, LightKind as Nr, ExpressionSelector as Nt, NodeAnimationTrack3D as O, TextSelectorSchema as On, GPULightData as Or, DynamicStrokeProperties as Ot, RingGeometryOptions as P, TypewriterAnimatorSchema as Pn, LightsUniformData as Pr, ExpressionSelectorSchema as Pt, initHeadlessWebGPU as Q, evaluateCubicBezier as Qn, SelectorBasedOnSchema as Qt, ShardGeometryOptions as R, VariableFontAxesSchema as Rn, Path3D as Rr, GlyphAnchorGroupingSchema as Rt, LoadModelOptions as S, TextPathSourceSchema as Sn, ENVIRONMENT_PRESETS as Sr, AudioSpectrumTypography as St, Mesh3DData as T, TextScrambleConfig as Tn, Environment3DOptions as Tr, ChromaticGlitchConfigSchema as Tt, SlugPipeline as U, VolumetricFormationMode as Un, Vec3 as Ur, LineSpacingDynamics as Ut, Skeleton3D as V, VolumetricFormationConfig as Vn, ResolvedEnvironment as Vr, KineticMarqueeConfig as Vt, SphereGeometryOptions as W, VolumetricFormationModeSchema as Wn, Vector3Math as Wr, LineSpacingDynamicsSchema as Wt, describeGpu as X, distanceToCurveParameter as Xn, PathChainLUTEntry as Xt, buildWGSLSignalFn as Y, deterministicWigglyNoise as Yn, PathChainLUT as Yt, ensureDevice as Z, ellipseToCubicBeziers as Zn, SelectorBasedOn as Zt, ExtrudeShapeGeometryOptions as _, TextCursorStyleSchema as _n, Camera3D as _r, AnchorPreset as _t, AudioLatentData as a, SkewProperties as an, evaluateTypewriterState as ar, parseMTL as at, LatheGeometryOptions as b, TextPathOptionsSchema as bn, CatmullRomOptions as br, AnimatableGlyphPropsSchema as bt, AudioMeshDeformPipeline as c, Spatial3DPropertiesSchema as cn, generatePathSegments as cr, signalRegistry as ct, AudioSignalComputePipeline as d, TextAnchorConfig as dn, parseSvgPathToCubicBeziers as dr, AETextAnimatorSchema as dt, SelectorModeSchema as en, evaluateExpressionSelector as er, loadFBX as et, BlendMode as f, TextAnchorConfigSchema as fn, sampleAudioSpectrumScale as fr, AdvancedTextAnimator as ft, EffectPipeline as g, TextCursorStyle as gn, BezierSegment3D as gr, AnchorGroupingSchema as gt, CylinderGeometryOptions as h, TextCursorConfigSchema as hn, waveToCubicBeziers as hr, AnchorGrouping as ht, AnimationClip3D as i, SelectorUnitsSchema as in, evaluateSpringProgress as ir, parseFBX as it, RenderContextValue as j, TextWigglySelector as jn, Light3D as jr, EnhancedTextNodeSchema as jt, Points3DGeometryOptions as k, TextSignalSelector as kn, HelixOptions as kr, DynamicStrokePropertiesSchema as kt, AudioPitchTrackConfig as l, SpringPhysics as ln, getScramblePool as lr, textureCache as lt, CapsuleGeometryOptions as m, TextCursorConfig as mn, samplePathChainGeometry as mr, AdvancedTextAnimatorSchema as mt, NodeRendererPlugin as n, SelectorShapeSchema as nn, evaluateSelectorCombination as nr, loadOBJ as nt, AudioLatentEngine as o, SkewPropertiesSchema as on, evaluateVolumetricFormation as or, parseOBJ as ot, Bone3D as p, TextAnimatorBuilder as pn, sampleCurveGeometry as pr, AdvancedTextAnimatorBuilder as pt, TubePathSpec as q, computeLineLeadingDisplacement as qn, resolveEnvironment as qr, ParticleDissolveConfig as qt, WebGPUNodeRenderer as r, SelectorUnits as rn, evaluateSkewMatrix as rr, lutStore as rt, AudioLatentTrackCache as s, Spatial3DProperties as sn, generateArcLengthLUT as sr, shaderStore as st, SignalResultSchema as t, SelectorShape as tn, evaluateMarqueeOffset as tr, loadModel3D as tt, AudioSignalComputeConfig as u, SpringPhysicsSchema as un, getShuffledOrder as ur, AETextAnimator as ut, GlassPipeline as v, TextPathBuilder as vn, Camera3DPose as vr, AnchorPresetSchema as vt, Material3D as w, TextRangeSelectorSchema as wn, Environment3DFog as wr, ChromaticGlitchConfig as wt, Line3DGeometryOptions as x, TextPathSource as xn, CirclePathOptions as xr, ArcLengthLUTEntry as xt, GpuAdapterDescription as y, TextPathOptions as yn, CameraShakeOptions as yr, AnimatableGlyphProps as yt, SignalRegistry as z, Vec2 as zn, Path3DPoint as zr, GlyphAnchorPoint as zt };
+//# sourceMappingURL=index-X2u96TEo.d.mts.map