@next2d/webgpu 3.0.4 → 3.1.0

package/src/Filter/ConvolutionFilterShader.js

@@ -1,115 +0,0 @@
-export const getConvolutionFilterFragmentShader = (matrixX, matrixY, preserveAlpha, clamp) => {
-    const halfX = Math.floor(matrixX * 0.5);
-    const halfY = Math.floor(matrixY * 0.5);
-    const size = matrixX * matrixY;
-    let matrixStatement = "";
-    for (let idx = 0; idx < size; idx++) {
-        matrixStatement += `
-    result = result + getWeightedColor(${idx}, getMatrixWeight(${idx}));`;
-    }
-    const preserveAlphaStatement = preserveAlpha
-        ? "result.a = textureSample(sourceTexture, sourceSampler, input.texCoord).a;"
-        : "";
-    const clampStatement = clamp
-        ? ""
-        : `
-    let substituteColor = uniforms.substituteColor;
-    color = mix(substituteColor, color, isInside(uv));`;
-    return `
-struct ConvolutionUniforms {
-    rcpSize: vec2<f32>,
-    rcpDivisor: f32,
-    bias: f32,
-    substituteColor: vec4<f32>,
-    matrix: array<vec4<f32>, ${Math.ceil(size / 4)}>,
-}
-
-@group(0) @binding(0) var<uniform> uniforms: ConvolutionUniforms;
-@group(0) @binding(1) var sourceSampler: sampler;
-@group(0) @binding(2) var sourceTexture: texture_2d<f32>;
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texCoord: vec2<f32>,
-}
-
-fn isInside(uv: vec2<f32>) -> f32 {
-    let inside = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));
-    return inside.x * inside.y;
-}
-
-fn getMatrixWeight(index: i32) -> f32 {
-    let vecIndex = index / 4;
-    let component = index % 4;
-    let vec = uniforms.matrix[vecIndex];
-
-    if (component == 0) { return vec.x; }
-    else if (component == 1) { return vec.y; }
-    else if (component == 2) { return vec.z; }
-    else { return vec.w; }
-}
-
-fn getWeightedColor(i: i32, weight: f32) -> vec4<f32> {
-    let rcpSize = uniforms.rcpSize;
-
-    let iDivX = i / ${matrixX};
-    let iModX = i - ${matrixX} * iDivX;
-    let offset = vec2<f32>(f32(iModX - ${halfX}), f32(${halfY} - iDivX));
-    var uv = input.texCoord + offset * rcpSize;
-
-    var color = textureSample(sourceTexture, sourceSampler, uv);
-    color = vec4<f32>(color.rgb / max(0.0001, color.a), color.a);
-    ${clampStatement}
-
-    return color * weight;
-}
-
-var<private> input: VertexOutput;
-
-@vertex
-fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
-    var positions = array<vec2<f32>, 6>(
-        vec2<f32>(-1.0, -1.0),
-        vec2<f32>(1.0, -1.0),
-        vec2<f32>(-1.0, 1.0),
-        vec2<f32>(-1.0, 1.0),
-        vec2<f32>(1.0, -1.0),
-        vec2<f32>(1.0, 1.0)
-    );
-
-    var texCoords = array<vec2<f32>, 6>(
-        vec2<f32>(0.0, 1.0),
-        vec2<f32>(1.0, 1.0),
-        vec2<f32>(0.0, 0.0),
-        vec2<f32>(0.0, 0.0),
-        vec2<f32>(1.0, 1.0),
-        vec2<f32>(1.0, 0.0)
-    );
-
-    var output: VertexOutput;
-    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
-    output.texCoord = texCoords[vertexIndex];
-    return output;
-}
-
-@fragment
-fn fs_main(fragInput: VertexOutput) -> @location(0) vec4<f32> {
-    input = fragInput;
-
-    let rcpDivisor = uniforms.rcpDivisor;
-    let bias = uniforms.bias;
-
-    var result = vec4<f32>(0.0);
-    ${matrixStatement}
-
-    result = clamp(result * rcpDivisor + bias, vec4<f32>(0.0), vec4<f32>(1.0));
-    ${preserveAlphaStatement}
-
-    result = vec4<f32>(result.rgb * result.a, result.a);
-    return result;
-}
-`;
-};
-export const getConvolutionFilterShaderKey = (matrixX, matrixY, preserveAlpha, clamp) => {
-    return `convolution_${matrixX}x${matrixY}_${preserveAlpha ? "pa" : "npa"}_${clamp ? "c" : "nc"}`;
-};

package/src/Filter/DisplacementMapFilterShader.d.ts

@@ -1,2 +0,0 @@
-export declare const getDisplacementMapFilterFragmentShader: (componentX: number, componentY: number, mode: number) => string;
-export declare const getDisplacementMapFilterShaderKey: (componentX: number, componentY: number, mode: number) => string;

package/src/Filter/DisplacementMapFilterShader.js

@@ -1,114 +0,0 @@
-const getComponentExpression = (component) => {
-    switch (component) {
-        case 1:
-            return "mapColor.r";
-        case 2:
-            return "mapColor.g";
-        case 4:
-            return "mapColor.b";
-        case 8:
-            return "mapColor.a";
-        default:
-            return "0.5";
-    }
-};
-const getModeStatement = (mode) => {
-    switch (mode) {
-        case 0:
-            return `
-    let sourceColor = textureSample(sourceTexture, sourceSampler, uv);`;
-        case 1:
-            return `
-    let substituteColor = uniforms.substituteColor;
-    let sourceColor = mix(substituteColor, textureSample(sourceTexture, sourceSampler, uv), isInside(uv));`;
-        case 3:
-            return `
-    let fallbackUv = mix(input.texCoord, uv, step(abs(uv - vec2<f32>(0.5)), vec2<f32>(0.5)));
-    let sourceColor = textureSample(sourceTexture, sourceSampler, fallbackUv);`;
-        case 2:
-        default:
-            return `
-    let sourceColor = textureSample(sourceTexture, sourceSampler, fract(uv));`;
-    }
-};
-export const getDisplacementMapFilterFragmentShader = (componentX, componentY, mode) => {
-    const cx = getComponentExpression(componentX);
-    const cy = getComponentExpression(componentY);
-    const modeStatement = getModeStatement(mode);
-    const hasSubstituteColor = mode === 1;
-    return `
-struct DisplacementMapUniforms {
-    uvToStScale: vec2<f32>,
-    uvToStOffset: vec2<f32>,
-    scale: vec2<f32>,
-    _pad: vec2<f32>,
-${hasSubstituteColor ? "    substituteColor: vec4<f32>," : ""}
-}
-
-@group(0) @binding(0) var<uniform> uniforms: DisplacementMapUniforms;
-@group(0) @binding(1) var sourceSampler: sampler;
-@group(0) @binding(2) var sourceTexture: texture_2d<f32>;
-@group(0) @binding(3) var mapTexture: texture_2d<f32>;
-
-struct VertexOutput {
-    @builtin(position) position: vec4<f32>,
-    @location(0) texCoord: vec2<f32>,
-}
-
-fn isInside(uv: vec2<f32>) -> f32 {
-    let inside = step(vec2<f32>(0.0), uv) * step(uv, vec2<f32>(1.0));
-    return inside.x * inside.y;
-}
-
-var<private> input: VertexOutput;
-
-@vertex
-fn vs_main(@builtin(vertex_index) vertexIndex: u32) -> VertexOutput {
-    var positions = array<vec2<f32>, 6>(
-        vec2<f32>(-1.0, -1.0),
-        vec2<f32>(1.0, -1.0),
-        vec2<f32>(-1.0, 1.0),
-        vec2<f32>(-1.0, 1.0),
-        vec2<f32>(1.0, -1.0),
-        vec2<f32>(1.0, 1.0)
-    );
-
-    var texCoords = array<vec2<f32>, 6>(
-        vec2<f32>(0.0, 1.0),
-        vec2<f32>(1.0, 1.0),
-        vec2<f32>(0.0, 0.0),
-        vec2<f32>(0.0, 0.0),
-        vec2<f32>(1.0, 1.0),
-        vec2<f32>(1.0, 0.0)
-    );
-
-    var output: VertexOutput;
-    output.position = vec4<f32>(positions[vertexIndex], 0.0, 1.0);
-    output.texCoord = texCoords[vertexIndex];
-    return output;
-}
-
-@fragment
-fn fs_main(fragInput: VertexOutput) -> @location(0) vec4<f32> {
-    input = fragInput;
-
-    let uvToStScale = uniforms.uvToStScale;
-    let uvToStOffset = uniforms.uvToStOffset;
-    let scale = uniforms.scale;
-
-    let st = input.texCoord * uvToStScale - uvToStOffset;
-    let mapColor = textureSample(mapTexture, sourceSampler, st);
-
-    let offset = vec2<f32>(${cx}, ${cy}) - 0.5;
-    let uv = input.texCoord + offset * scale;
-
-    ${modeStatement}
-
-    let originalColor = textureSample(sourceTexture, sourceSampler, input.texCoord);
-    return mix(originalColor, sourceColor, isInside(st));
-}
-`;
-};
-export const getDisplacementMapFilterShaderKey = (componentX, componentY, mode) => {
-    return `displacement_${componentX}_${componentY}_${mode}`;
-};

package/src/Filter/DropShadowFilterShader.d.ts

@@ -1,4 +0,0 @@
-export declare class DropShadowFilterShader {
-    static getFragmentShader(): string;
-    static getVertexShader(): string;
-}

package/src/Filter/DropShadowFilterShader.js

@@ -1,93 +0,0 @@
-export class DropShadowFilterShader {
-    static getFragmentShader() {
-        return /* wgsl */ `
-            struct VertexOutput {
-                @builtin(position) position: vec4<f32>,
-                @location(0) texCoord: vec2<f32>,
-            }
-
-            struct DropShadowUniforms {
-                shadowColor: vec4<f32>,
-                offset: vec2<f32>,
-                distance: f32,
-                angle: f32,
-                strength: f32,
-                inner: f32,
-                knockout: f32,
-                hideObject: f32,
-            }
-
-            @group(0) @binding(0) var<uniform> uniforms: DropShadowUniforms;
-            @group(0) @binding(1) var textureSampler: sampler;
-            @group(0) @binding(2) var textureData: texture_2d<f32>;
-
-            @fragment
-            fn main(input: VertexOutput) -> @location(0) vec4<f32> {
-                var originalColor = textureSample(textureData, textureSampler, input.texCoord);
-
-                let radian = uniforms.angle * 3.14159265 / 180.0;
-                let offsetX = cos(radian) * uniforms.distance / 100.0;
-                let offsetY = sin(radian) * uniforms.distance / 100.0;
-
-                let shadowCoord = vec2<f32>(
-                    input.texCoord.x + offsetX,
-                    input.texCoord.y + offsetY
-                );
-
-                var shadowAlpha = textureSample(textureData, textureSampler, shadowCoord).a;
-
-                var shadowColor = vec4<f32>(
-                    uniforms.shadowColor.rgb,
-                    shadowAlpha * uniforms.shadowColor.a * uniforms.strength
-                );
-
-                if (uniforms.inner > 0.5) {
-                    let alpha = originalColor.a;
-                    shadowColor.a *= alpha;
-
-                    if (uniforms.knockout > 0.5) {
-                        return shadowColor;
-                    } else {
-                        return mix(shadowColor, originalColor, alpha);
-                    }
-                } else {
-                    if (uniforms.hideObject > 0.5) {
-                        return shadowColor * (1.0 - originalColor.a);
-                    } else if (uniforms.knockout > 0.5) {
-                        return shadowColor;
-                    } else {
-                        let combinedAlpha = originalColor.a + shadowColor.a * (1.0 - originalColor.a);
-                        if (combinedAlpha > 0.0) {
-                            let rgb = (originalColor.rgb * originalColor.a +
-                                      shadowColor.rgb * shadowColor.a * (1.0 - originalColor.a)) / combinedAlpha;
-                            return vec4<f32>(rgb, combinedAlpha);
-                        } else {
-                            return vec4<f32>(0.0);
-                        }
-                    }
-                }
-            }
-        `;
-    }
-    static getVertexShader() {
-        return /* wgsl */ `
-            struct VertexInput {
-                @location(0) position: vec2<f32>,
-                @location(1) texCoord: vec2<f32>,
-            }
-
-            struct VertexOutput {
-                @builtin(position) position: vec4<f32>,
-                @location(0) texCoord: vec2<f32>,
-            }
-
-            @vertex
-            fn main(input: VertexInput) -> VertexOutput {
-                var output: VertexOutput;
-                output.position = vec4<f32>(input.position, 0.0, 1.0);
-                output.texCoord = input.texCoord;
-                return output;
-            }
-        `;
-    }
-}

package/src/Filter/GlowFilterShader.d.ts

@@ -1,4 +0,0 @@
-export declare class GlowFilterShader {
-    static getFragmentShader(): string;
-    static getVertexShader(): string;
-}

package/src/Filter/GlowFilterShader.js

@@ -1,66 +0,0 @@
-export class GlowFilterShader {
-    static getFragmentShader() {
-        return /* wgsl */ `
-            struct VertexOutput {
-                @builtin(position) position: vec4<f32>,
-                @location(0) texCoord: vec2<f32>,
-            }
-
-            struct GlowUniforms {
-                glowColor: vec4<f32>,
-                strength: f32,
-                inner: f32,
-                knockout: f32,
-                _padding: f32,
-            }
-
-            @group(0) @binding(0) var<uniform> uniforms: GlowUniforms;
-            @group(0) @binding(1) var textureSampler: sampler;
-            @group(0) @binding(2) var textureData: texture_2d<f32>;
-
-            @fragment
-            fn main(input: VertexOutput) -> @location(0) vec4<f32> {
-                var originalColor = textureSample(textureData, textureSampler, input.texCoord);
-
-                let alpha = originalColor.a;
-
-                var glowColor = uniforms.glowColor * uniforms.strength * alpha;
-
-                if (uniforms.inner > 0.5) {
-                    if (uniforms.knockout > 0.5) {
-                        return glowColor;
-                    } else {
-                        return mix(originalColor, glowColor, alpha);
-                    }
-                } else {
-                    if (uniforms.knockout > 0.5) {
-                        return vec4<f32>(glowColor.rgb, glowColor.a * (1.0 - alpha));
-                    } else {
-                        return originalColor + glowColor;
-                    }
-                }
-            }
-        `;
-    }
-    static getVertexShader() {
-        return /* wgsl */ `
-            struct VertexInput {
-                @location(0) position: vec2<f32>,
-                @location(1) texCoord: vec2<f32>,
-            }
-
-            struct VertexOutput {
-                @builtin(position) position: vec4<f32>,
-                @location(0) texCoord: vec2<f32>,
-            }
-
-            @vertex
-            fn main(input: VertexInput) -> VertexOutput {
-                var output: VertexOutput;
-                output.position = vec4<f32>(input.position, 0.0, 1.0);
-                output.texCoord = input.texCoord;
-                return output;
-            }
-        `;
-    }
-}

package/src/FrameBufferManager/service/FrameBufferManagerFlushPendingReleasesService.d.ts

@@ -1,11 +0,0 @@
-import type { IAttachmentObject } from "../../interface/IAttachmentObject";
-/**
- * @description フレーム終了時に保留中のテクスチャを解放
- *              Release pending textures at end of frame (after submit)
- *
- * @param  {IAttachmentObject[]} pendingReleases
- * @return {void}
- * @method
- * @protected
- */
-export declare const execute: (pendingReleases: IAttachmentObject[]) => void;

package/src/FrameBufferManager/service/FrameBufferManagerFlushPendingReleasesService.js

@@ -1,19 +0,0 @@
-/**
- * @description フレーム終了時に保留中のテクスチャを解放
- *              Release pending textures at end of frame (after submit)
- *
- * @param  {IAttachmentObject[]} pendingReleases
- * @return {void}
- * @method
- * @protected
- */
-export const execute = (pendingReleases) => {
-    for (const att of pendingReleases) {
-        if (att.texture) {
-            att.texture.resource.destroy();
-        }
-        if (att.stencil) {
-            att.stencil.resource.destroy();
-        }
-    }
-};

package/src/Mask/usecase/MaskBindUseCase.d.ts

@@ -1,10 +0,0 @@
-/**
- * @description マスクOn/Offに合わせたバインド処理
- *              Binding process according to mask On/Off
- *
- * @param  {boolean} mask
- * @return {void}
- * @method
- * @protected
- */
-export declare const execute: (mask: boolean) => void;

package/src/Mask/usecase/MaskBindUseCase.js

@@ -1,20 +0,0 @@
-import { execute as maskEndMaskService } from "../service/MaskEndMaskService";
-import { $isMaskDrawing, $setMaskDrawing } from "../../Mask";
-/**
- * @description マスクOn/Offに合わせたバインド処理
- *              Binding process according to mask On/Off
- *
- * @param  {boolean} mask
- * @return {void}
- * @method
- * @protected
- */
-export const execute = (mask) => {
-    if (!mask && $isMaskDrawing()) {
-        $setMaskDrawing(false);
-    }
-    else if (mask && !$isMaskDrawing()) {
-        $setMaskDrawing(true);
-        maskEndMaskService();
-    }
-};

package/src/Mesh/service/MeshLerpService.d.ts

@@ -1,13 +0,0 @@
-import type { IPoint } from "../../interface/IPoint";
-/**
- * @description 線形補間
- *              Linear interpolation
- *
- * @param  {IPoint} pointA
- * @param  {IPoint} pointB
- * @param  {number} t
- * @return {IPoint}
- * @method
- * @protected
- */
-export declare const execute: (pointA: IPoint, pointB: IPoint, t: number) => IPoint;

package/src/Mesh/service/MeshLerpService.js

@@ -1,17 +0,0 @@
-/**
- * @description 線形補間
- *              Linear interpolation
- *
- * @param  {IPoint} pointA
- * @param  {IPoint} pointB
- * @param  {number} t
- * @return {IPoint}
- * @method
- * @protected
- */
-export const execute = (pointA, pointB, t) => {
-    return {
-        "x": pointA.x + (pointB.x - pointA.x) * t,
-        "y": pointA.y + (pointB.y - pointA.y) * t
-    };
-};

package/src/Mesh/usecase/MeshSplitQuadraticBezierUseCase.d.ts

@@ -1,14 +0,0 @@
-import type { IPoint } from "../../interface/IPoint";
-/**
- * @description 二次ベジェ曲線を分割する
- *              Split a quadratic Bezier curve
- *
- * @param  {IPoint} start_point
- * @param  {IPoint} control_point
- * @param  {IPoint} end_point
- * @param  {number} [t = 0.5]
- * @return {Array<IPoint[]>}
- * @method
- * @protected
- */
-export declare const execute: (start_point: IPoint, control_point: IPoint, end_point: IPoint, t?: number) => Array<IPoint[]>;

package/src/Mesh/usecase/MeshSplitQuadraticBezierUseCase.js

@@ -1,28 +0,0 @@
-import { execute as meshLerpService } from "../service/MeshLerpService";
-/**
- * @description 二次ベジェ曲線を分割する
- *              Split a quadratic Bezier curve
- *
- * @param  {IPoint} start_point
- * @param  {IPoint} control_point
- * @param  {IPoint} end_point
- * @param  {number} [t = 0.5]
- * @return {Array<IPoint[]>}
- * @method
- * @protected
- */
-export const execute = (start_point, control_point, end_point, t = 0.5) => {
-    // 二次ベジエ曲線の分割
-    // M0  = lerp(P0, P1, t)
-    // M1  = lerp(P1, P2, t)
-    // M01 = lerp(M0, M1, t)
-    const M0 = meshLerpService(start_point, control_point, t);
-    const M1 = meshLerpService(control_point, end_point, t);
-    const M01 = meshLerpService(M0, M1, t);
-    // 左サブ (0...t): [P0,  M0, M01]
-    // 右サブ (t...1): [M01, M1, P2]
-    return [
-        [start_point, M0, M01],
-        [M01, M1, end_point]
-    ];
-};

package/src/Mesh/usecase/MeshStrokeFillGenerateUseCase.d.ts

@@ -1,18 +0,0 @@
-import type { IPath } from "../../interface/IPath";
-import type { IMeshResult } from "../../interface/IMeshResult";
-/**
- * @description ストローク塗りつぶし用のメッシュを生成する
- *              Generate a stroke fill mesh
- *
- * 頂点フォーマット（4 floats per vertex）:
- * - position: x, y (2 floats)
- * - bezier: u, v (2 floats) - 常に (0.5, 0.5)
- *
- * color/matrixはuniform bufferで供給される
- *
- * @param  {IPath[]} vertices
- * @return {IMeshResult}
- * @method
- * @protected
- */
-export declare const execute: (vertices: IPath[]) => IMeshResult;

package/src/Mesh/usecase/MeshStrokeFillGenerateUseCase.js

@@ -1,54 +0,0 @@
-import { execute as meshStrokeFillGenerateService } from "../service/MeshStrokeFillGenerateService";
-/**
- * @description メッシュ生成用の再利用可能な一時バッファ（GC回避）
- */
-let $meshTempBuffer = new Float32Array(32);
-const $upperPowerOfTwo = (v) => {
-    v--;
-    v |= v >> 1;
-    v |= v >> 2;
-    v |= v >> 4;
-    v |= v >> 8;
-    v |= v >> 16;
-    v++;
-    return v;
-};
-/**
- * @description ストローク塗りつぶし用のメッシュを生成する
- *              Generate a stroke fill mesh
- *
- * 頂点フォーマット（4 floats per vertex）:
- * - position: x, y (2 floats)
- * - bezier: u, v (2 floats) - 常に (0.5, 0.5)
- *
- * color/matrixはuniform bufferで供給される
- *
- * @param  {IPath[]} vertices
- * @return {IMeshResult}
- * @method
- * @protected
- */
-export const execute = (vertices) => {
-    // 頂点数を計算（各パスの三角形数 × 3）
-    let totalVertices = 0;
-    for (const vertex of vertices) {
-        const length = vertex.length - 5;
-        for (let idx = 3; idx < length; idx += 3) {
-            totalVertices += 3;
-        }
-    }
-    // バッファを確保（4 floats per vertex、再利用可能バッファ）
-    const requiredSize = totalVertices * 4;
-    if ($meshTempBuffer.length < requiredSize) {
-        $meshTempBuffer = new Float32Array($upperPowerOfTwo(requiredSize));
-    }
-    const buffer = $meshTempBuffer;
-    let index = 0;
-    for (const vertex of vertices) {
-        index = meshStrokeFillGenerateService(vertex, buffer, index);
-    }
-    return {
-        "buffer": buffer.subarray(0, index * 4),
-        "indexCount": index
-    };
-};

package/src/SamplerCache/service/SamplerCacheCreateCommonSamplersService.d.ts

@@ -1,11 +0,0 @@
-/**
- * @description 頻繁に使用されるサンプラーを事前に作成
- *              Pre-create commonly used samplers
- *
- * @param  {GPUDevice} device
- * @param  {Map<string, GPUSampler>} cache
- * @return {void}
- * @method
- * @protected
- */
-export declare const execute: (device: GPUDevice, cache: Map<string, GPUSampler>) => void;

package/src/SamplerCache/service/SamplerCacheCreateCommonSamplersService.js

@@ -1,35 +0,0 @@
-import { execute as samplerCacheGenerateKeyService } from "./SamplerCacheGenerateKeyService";
-/**
- * @description 頻繁に使用されるサンプラーを事前に作成
- *              Pre-create commonly used samplers
- *
- * @param  {GPUDevice} device
- * @param  {Map<string, GPUSampler>} cache
- * @return {void}
- * @method
- * @protected
- */
-export const execute = (device, cache) => {
-    const createAndCache = (minFilter, magFilter, addressModeU, addressModeV) => {
-        const key = samplerCacheGenerateKeyService(minFilter, magFilter, addressModeU, addressModeV);
-        if (!cache.has(key)) {
-            const sampler = device.createSampler({
-                minFilter,
-                magFilter,
-                addressModeU,
-                addressModeV
-            });
-            cache.set(key, sampler);
-        }
-    };
-    // リニアクランプ（最も一般的）
-    createAndCache("linear", "linear", "clamp-to-edge", "clamp-to-edge");
-    // ニアレストクランプ
-    createAndCache("nearest", "nearest", "clamp-to-edge", "clamp-to-edge");
-    // リニアリピート
-    createAndCache("linear", "linear", "repeat", "repeat");
-    // ニアレストリピート
-    createAndCache("nearest", "nearest", "repeat", "repeat");
-    // リニアミラーリピート
-    createAndCache("linear", "linear", "mirror-repeat", "mirror-repeat");
-};