chili3d 0.6.1

package/packages/chili-wasm/src/surface.ts

@@ -0,0 +1,510 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import {
+    type Continuity,
+    gc,
+    type IBezierSurface,
+    type IBoundedSurface,
+    type IBSplineSurface,
+    type ICompositeSurface,
+    type IConicalSurface,
+    type ICurve,
+    type ICylindricalSurface,
+    type IElementarySurface,
+    type IGeometry,
+    type IOffsetSurface,
+    type IPlaneSurface,
+    type IPlateSurface,
+    type IRectangularTrimmedSurface,
+    type ISphericalSurface,
+    type ISurface,
+    type ISurfaceOfLinearExtrusion,
+    type ISurfaceOfRevolution,
+    type ISweptSurface,
+    type IToroidalSurface,
+    type Matrix4,
+    type Plane,
+    XYZ,
+} from "chili-core";
+import type {
+    Geom_BezierSurface,
+    Geom_BSplineSurface,
+    Geom_ConicalSurface,
+    Geom_CylindricalSurface,
+    Geom_ElementarySurface,
+    Geom_OffsetSurface,
+    Geom_Plane,
+    Geom_RectangularTrimmedSurface,
+    Geom_SphericalSurface,
+    Geom_Surface,
+    Geom_SurfaceOfLinearExtrusion,
+    Geom_SurfaceOfRevolution,
+    Geom_SweptSurface,
+    Geom_ToroidalSurface,
+    GeomPlate_Surface,
+    ShapeExtend_CompositeSurface,
+} from "../lib/chili-wasm";
+import { OccCurve } from "./curve";
+import { OccGeometry } from "./geometry";
+import { OcctHelper } from "./helper";
+
+export class OccSurface extends OccGeometry implements ISurface {
+    constructor(readonly surface: Geom_Surface) {
+        super(surface);
+    }
+
+    override copy(): IGeometry {
+        return gc((c) => {
+            const s = c(this.surface.copy());
+            return OcctHelper.wrapSurface(s.get() as Geom_Surface);
+        });
+    }
+
+    override transformed(matrix: Matrix4): IGeometry {
+        return gc((c) => {
+            const s = c(this.surface.transformed(OcctHelper.convertFromMatrix(matrix)));
+            return OcctHelper.wrapSurface(s.get() as Geom_Surface);
+        });
+    }
+
+    projectCurve(curve: ICurve): ICurve | undefined {
+        return gc((c) => {
+            if (!(curve instanceof OccCurve)) return undefined;
+            const handleCurve = c(wasm.Surface.projectCurve(this.surface, curve.curve));
+            return OcctHelper.wrapCurve(handleCurve.get()!);
+        });
+    }
+
+    project(point: XYZ): XYZ[] {
+        return wasm.Surface.projectPoint(this.surface, point)
+            .map((p) => new XYZ(p.x, p.y, p.z))
+            .toSorted((a, b) => a.distanceTo(point) - b.distanceTo(point));
+    }
+
+    isPlanar(): boolean {
+        return wasm.Surface.isPlanar(this.surface);
+    }
+
+    parameter(point: XYZ, maxDistance: number): { u: number; v: number } | undefined {
+        return wasm.Surface.parameters(this.surface, point, maxDistance);
+    }
+
+    nearestPoint(point: XYZ): [XYZ, number] | undefined {
+        const result = wasm.Surface.nearestPoint(this.surface, point);
+        if (result) {
+            return [OcctHelper.toXYZ(result.point), result.parameter];
+        }
+        return undefined;
+    }
+
+    continuity(): Continuity {
+        return OcctHelper.convertToContinuity(this.surface.continuity());
+    }
+
+    uIso(u: number): ICurve {
+        return gc((c) => {
+            const curve = c(this.surface.uIso(u));
+            return OcctHelper.wrapCurve(curve.get()!);
+        });
+    }
+    vIso(v: number): ICurve {
+        return gc((c) => {
+            const curve = c(this.surface.vIso(v));
+            return OcctHelper.wrapCurve(curve.get()!);
+        });
+    }
+    isUClosed(): boolean {
+        return this.surface.isUClosed();
+    }
+    isVClosed(): boolean {
+        return this.surface.isVClosed();
+    }
+    isUPreiodic(): boolean {
+        return this.surface.isUPeriodic();
+    }
+    isVPreiodic(): boolean {
+        return this.surface.isVPeriodic();
+    }
+    vPeriod(): number {
+        return this.surface.vPeriod();
+    }
+    uPeriod(): number {
+        return this.surface.uPeriod();
+    }
+    bounds() {
+        return wasm.Surface.bounds(this.surface);
+    }
+    isCNu(n: number): boolean {
+        return this.surface.isCNu(n);
+    }
+    isCNv(n: number): boolean {
+        return this.surface.isCNv(n);
+    }
+    d0(u: number, v: number): XYZ {
+        return gc((c) => {
+            const pnt = c(new wasm.gp_Pnt(0, 0, 0));
+            this.surface.d0(u, v, pnt);
+            return OcctHelper.toXYZ(pnt);
+        });
+    }
+    d1(
+        u: number,
+        v: number,
+    ): {
+        point: XYZ;
+        d1u: XYZ;
+        d1v: XYZ;
+    } {
+        return gc((c) => {
+            const pnt = c(new wasm.gp_Pnt(0, 0, 0));
+            const d1u = c(new wasm.gp_Vec(0, 0, 0));
+            const d1v = c(new wasm.gp_Vec(0, 0, 0));
+            this.surface.d1(u, v, pnt, d1u, d1v);
+            return {
+                point: OcctHelper.toXYZ(pnt),
+                d1u: OcctHelper.toXYZ(d1u),
+                d1v: OcctHelper.toXYZ(d1v),
+            };
+        });
+    }
+    d2(u: number, v: number) {
+        return gc((c) => {
+            const pnt = c(new wasm.gp_Pnt(0, 0, 0));
+            const d1u = c(new wasm.gp_Vec(0, 0, 0));
+            const d1v = c(new wasm.gp_Vec(0, 0, 0));
+            const d2u = c(new wasm.gp_Vec(0, 0, 0));
+            const d2v = c(new wasm.gp_Vec(0, 0, 0));
+            const d2uv = c(new wasm.gp_Vec(0, 0, 0));
+            this.surface.d2(u, v, pnt, d1u, d1v, d2u, d2v, d2uv);
+
+            return {
+                point: OcctHelper.toXYZ(pnt),
+                d1u: OcctHelper.toXYZ(d1u),
+                d1v: OcctHelper.toXYZ(d1v),
+                d2u: OcctHelper.toXYZ(d2u),
+                d2v: OcctHelper.toXYZ(d2v),
+                d2uv: OcctHelper.toXYZ(d2uv),
+            };
+        });
+    }
+    d3(u: number, v: number) {
+        return gc((c) => {
+            const pnt = c(new wasm.gp_Pnt(0, 0, 0));
+            const d1u = c(new wasm.gp_Vec(0, 0, 0));
+            const d1v = c(new wasm.gp_Vec(0, 0, 0));
+            const d2u = c(new wasm.gp_Vec(0, 0, 0));
+            const d2v = c(new wasm.gp_Vec(0, 0, 0));
+            const d2uv = c(new wasm.gp_Vec(0, 0, 0));
+            const d3u = c(new wasm.gp_Vec(0, 0, 0));
+            const d3v = c(new wasm.gp_Vec(0, 0, 0));
+            const d3uuv = c(new wasm.gp_Vec(0, 0, 0));
+            const d3uvv = c(new wasm.gp_Vec(0, 0, 0));
+            this.surface.d3(u, v, pnt, d1u, d1v, d2u, d2v, d2uv, d3u, d3v, d3uuv, d3uvv);
+
+            return {
+                point: OcctHelper.toXYZ(pnt),
+                d1u: OcctHelper.toXYZ(d1u),
+                d1v: OcctHelper.toXYZ(d1v),
+                d2u: OcctHelper.toXYZ(d2u),
+                d2v: OcctHelper.toXYZ(d2v),
+                d2uv: OcctHelper.toXYZ(d2uv),
+                d3u: OcctHelper.toXYZ(d3u),
+                d3v: OcctHelper.toXYZ(d3v),
+                d3uuv: OcctHelper.toXYZ(d3uuv),
+                d3uvv: OcctHelper.toXYZ(d3uvv),
+            };
+        });
+    }
+    dn(u: number, v: number, nu: number, nv: number): XYZ {
+        return gc((c) => {
+            const vec = c(this.surface.dn(u, v, nu, nv));
+            return OcctHelper.toXYZ(vec);
+        });
+    }
+    value(u: number, v: number): XYZ {
+        return gc((c) => {
+            const pnt = c(this.surface.value(u, v));
+            return OcctHelper.toXYZ(pnt);
+        });
+    }
+}
+
+export class OccPlateSurface extends OccSurface implements IPlateSurface {
+    constructor(private plateSurface: GeomPlate_Surface) {
+        super(plateSurface);
+    }
+
+    setBounds(u1: number, u2: number, v1: number, v2: number): void {
+        this.plateSurface.setBounds(u1, u2, v1, v2);
+    }
+}
+
+export class OccBoundedSurface extends OccSurface implements IBoundedSurface {}
+
+export class OccElementarySurface extends OccSurface implements IElementarySurface {
+    constructor(private elementarySurface: Geom_ElementarySurface) {
+        super(elementarySurface);
+    }
+
+    get location() {
+        return gc((c) => OcctHelper.toXYZ(c(this.elementarySurface.location())));
+    }
+    set location(value: XYZ) {
+        gc((c) => {
+            this.elementarySurface.setLocation(c(OcctHelper.toPnt(value)));
+        });
+    }
+
+    get axis() {
+        return gc((c) => {
+            return OcctHelper.toXYZ(c(c(this.elementarySurface.axis()).direction()));
+        });
+    }
+    set axis(value: XYZ) {
+        gc((c) => {
+            const pnt = c(this.elementarySurface.location());
+            const axis = c(new wasm.gp_Ax1(pnt, c(OcctHelper.toDir(value))));
+            this.elementarySurface.setAxis(axis);
+        });
+    }
+    get coordinates() {
+        return gc((c) => {
+            return OcctHelper.fromAx23(c(this.elementarySurface.position()));
+        });
+    }
+    set coordinates(value: Plane) {
+        gc((c) => {
+            this.elementarySurface.setPosition(c(OcctHelper.toAx3(value)));
+        });
+    }
+}
+
+export class OccOffsetSurface extends OccSurface implements IOffsetSurface {
+    constructor(private offsetSurface: Geom_OffsetSurface) {
+        super(offsetSurface);
+    }
+    get offset(): number {
+        return this.offsetSurface.offset();
+    }
+    set offset(value: number) {
+        this.offsetSurface.setOffsetValue(value);
+    }
+    get basisSurface() {
+        return gc((c) => {
+            const handleSurface = c(this.offsetSurface.basisSurface());
+            return OcctHelper.wrapSurface(handleSurface.get()!);
+        });
+    }
+    set basisSurface(value: ISurface) {
+        gc((c) => {
+            if (value instanceof OccSurface) {
+                const handleSurface = c(new wasm.Handle_Geom_Surface(value.surface));
+                this.offsetSurface.setBasisSurface(handleSurface, true);
+            }
+            throw new Error("Invalid surface type");
+        });
+    }
+}
+
+export class OccSweptSurface extends OccSurface implements ISweptSurface {
+    constructor(private sweptSurface: Geom_SweptSurface) {
+        super(sweptSurface);
+    }
+    direction(): XYZ {
+        return gc((c) => {
+            return OcctHelper.toXYZ(c(this.sweptSurface.direction()));
+        });
+    }
+    basisCurve(): ICurve {
+        return gc((c) => {
+            const handleCurve = this.sweptSurface.basisCurve();
+            return OcctHelper.wrapCurve(handleCurve.get()!);
+        });
+    }
+}
+
+export class OccCompositeSurface extends OccSurface implements ICompositeSurface {
+    constructor(compositeSurface: ShapeExtend_CompositeSurface) {
+        super(compositeSurface as any);
+    }
+}
+
+export class OccBSplineSurface extends OccSurface implements IBSplineSurface {
+    constructor(private bsplineSurface: Geom_BSplineSurface) {
+        super(bsplineSurface);
+    }
+}
+
+export class OccBezierSurface extends OccSurface implements IBezierSurface {
+    constructor(private bezierSurface: Geom_BezierSurface) {
+        super(bezierSurface);
+    }
+}
+
+export class OccRectangularSurface extends OccSurface implements IRectangularTrimmedSurface {
+    constructor(private rectangularSurface: Geom_RectangularTrimmedSurface) {
+        super(rectangularSurface);
+    }
+    basisSurface(): ISurface {
+        return gc((c) => {
+            const handleSurface = c(this.rectangularSurface.basisSurface());
+            return OcctHelper.wrapSurface(handleSurface.get()!);
+        });
+    }
+    setUTrim(u1: number, u2: number): void {
+        this.rectangularSurface.setTrim2(u1, u2, true, true);
+    }
+    setVTrim(v1: number, v2: number): void {
+        this.rectangularSurface.setTrim2(v1, v2, false, true);
+    }
+    setTrim(u1: number, u2: number, v1: number, v2: number): void {
+        this.rectangularSurface.setTrim(u1, u2, v1, v2, true, true);
+    }
+}
+
+export class OccConicalSurface extends OccElementarySurface implements IConicalSurface {
+    constructor(private conicalSurface: Geom_ConicalSurface) {
+        super(conicalSurface);
+    }
+    get semiAngle(): number {
+        return this.conicalSurface.semiAngle();
+    }
+    set semiAngle(value: number) {
+        this.conicalSurface.setSemiAngle(value);
+    }
+    setRadius(value: number) {
+        return this.conicalSurface.setRadius(value);
+    }
+    apex(): XYZ {
+        return gc((c) => {
+            return OcctHelper.toXYZ(c(this.conicalSurface.apex()));
+        });
+    }
+    refRadius(): number {
+        return this.conicalSurface.refRadius();
+    }
+}
+
+export class OccCylindricalSurface extends OccElementarySurface implements ICylindricalSurface {
+    constructor(private cylindricalSurface: Geom_CylindricalSurface) {
+        super(cylindricalSurface);
+    }
+    get radius(): number {
+        return this.cylindricalSurface.radius();
+    }
+    set radius(value: number) {
+        this.cylindricalSurface.setRadius(value);
+    }
+}
+
+export class OccPlane extends OccElementarySurface implements IPlaneSurface {
+    constructor(private geom_plane: Geom_Plane) {
+        super(geom_plane);
+    }
+    get plane(): Plane {
+        return gc((c) => {
+            return OcctHelper.fromPln(c(this.geom_plane.pln()));
+        });
+    }
+    set plane(value: Plane) {
+        gc((c) => {
+            this.geom_plane.setPln(c(OcctHelper.toPln(value)));
+        });
+    }
+}
+
+export class OccSphericalSurface extends OccElementarySurface implements ISphericalSurface {
+    constructor(private sphericalSurface: Geom_SphericalSurface) {
+        super(sphericalSurface);
+    }
+    get radius(): number {
+        return this.sphericalSurface.radius();
+    }
+    set radius(value: number) {
+        this.sphericalSurface.setRadius(value);
+    }
+    area(): number {
+        return this.sphericalSurface.area();
+    }
+    volume(): number {
+        return this.sphericalSurface.volume();
+    }
+}
+
+export class OccToroidalSurface extends OccElementarySurface implements IToroidalSurface {
+    constructor(private toroidalSurface: Geom_ToroidalSurface) {
+        super(toroidalSurface);
+    }
+    area(): number {
+        return this.toroidalSurface.area();
+    }
+    volume(): number {
+        return this.toroidalSurface.volume();
+    }
+    get majorRadius(): number {
+        return this.toroidalSurface.majorRadius();
+    }
+    set majorRadius(value: number) {
+        this.toroidalSurface.setMajorRadius(value);
+    }
+    get minorRadius(): number {
+        return this.toroidalSurface.minorRadius();
+    }
+    set minorRadius(value: number) {
+        this.toroidalSurface.setMinorRadius(value);
+    }
+}
+
+export class OccSurfaceOfLinearExtrusion extends OccSweptSurface implements ISurfaceOfLinearExtrusion {
+    constructor(private surfaceOfLinearExtrusion: Geom_SurfaceOfLinearExtrusion) {
+        super(surfaceOfLinearExtrusion);
+    }
+    setDirection(direction: XYZ) {
+        gc((c) => {
+            this.surfaceOfLinearExtrusion.setDirection(c(OcctHelper.toDir(direction)));
+        });
+    }
+    setBasisCurve(curve: ICurve) {
+        if (!(curve instanceof OccCurve)) {
+            throw new Error("curve must be an OccCurve");
+        }
+        const handleCurve = new wasm.Handle_Geom_Curve(curve.curve);
+        this.surfaceOfLinearExtrusion.setBasisCurve(handleCurve);
+        handleCurve.delete();
+    }
+}
+
+export class OccSurfaceOfRevolution extends OccSweptSurface implements ISurfaceOfRevolution {
+    constructor(private surfaceOfRevolution: Geom_SurfaceOfRevolution) {
+        super(surfaceOfRevolution);
+    }
+    get location(): XYZ {
+        return gc((c) => {
+            return OcctHelper.toXYZ(c(this.surfaceOfRevolution.location()));
+        });
+    }
+    set location(value: XYZ) {
+        gc((c) => {
+            this.surfaceOfRevolution.setLocation(c(OcctHelper.toPnt(value)));
+        });
+    }
+    referencePlane(): Plane {
+        return gc((c) => {
+            return OcctHelper.fromAx23(c(this.surfaceOfRevolution.referencePlane()));
+        });
+    }
+    setDirection(direction: XYZ) {
+        gc((c) => {
+            this.surfaceOfRevolution.setDirection(c(OcctHelper.toDir(direction)));
+        });
+    }
+    setBasisCurve(curve: ICurve) {
+        if (!(curve instanceof OccCurve)) {
+            throw new Error("curve must be an OccCurve");
+        }
+        const handleCurve = new wasm.Handle_Geom_Curve(curve.curve);
+        this.surfaceOfRevolution.setBasisCurve(handleCurve);
+        handleCurve.delete();
+    }
+}

package/packages/chili-wasm/src/wasm.ts

@@ -0,0 +1,13 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import MainModuleFactory, { type MainModule } from "../lib/chili-wasm";
+
+declare global {
+    var wasm: MainModule;
+}
+
+export async function initWasm() {
+    global.wasm = await MainModuleFactory();
+    return global.wasm;
+}

package/packages/chili-web/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "chili-web",
+  "version": "0.6.1",
+  "description": "",
+  "main": "src/index.ts",
+  "devDependencies": {
+    "chili-builder": "*"
+  }
+}

package/packages/chili-web/src/index.ts

@@ -0,0 +1,33 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+import { AppBuilder } from "chili-builder";
+import { type IApplication, Logger } from "chili-core";
+import { Loading } from "./loading";
+
+const loading = new Loading();
+document.body.appendChild(loading);
+
+async function handleApplicaionBuilt(app: IApplication) {
+    document.body.removeChild(loading);
+
+    const params = new URLSearchParams(window.location.search);
+    const url = params.get("url") ?? params.get("model");
+    if (url) {
+        Logger.info(`load file from url: ${url}`);
+
+        await app.loadFileFromUrl(url);
+    }
+}
+
+// prettier-ignore
+new AppBuilder()
+    .useIndexedDB()
+    .useWasmOcc()
+    .useThree()
+    .useUI()
+    .build()
+    .then(handleApplicaionBuilt)
+    .catch((err) => {
+        Logger.error(err);
+    });

package/packages/chili-web/src/loading.ts

@@ -0,0 +1,67 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+export class Loading extends HTMLElement {
+    constructor() {
+        super();
+        this.initSpinner();
+        this.initLabel();
+        this.initAnimation();
+        this.style.cssText = `
+            position: fixed;
+            display: block;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            z-index: 9999;
+            background-color: rgba(0, 0, 0, 0.5);
+        `;
+    }
+
+    private initSpinner() {
+        const text = document.createElement("div");
+        text.style.cssText = `
+            position: absolute;
+            top: 40%;
+            left: 50%;
+            transform: translate(-50%, -50%);
+            width: 50px;
+            height: 50px;
+            border-radius: 50%;
+            border: 5px solid var(--foreground-color);
+            border-top-color: var(--background-color);
+            animation: spin 1s infinite linear;
+        `;
+        this.appendChild(text);
+    }
+
+    private initAnimation() {
+        const styleSheet = document.createElement("style");
+        styleSheet.innerHTML = `
+          @keyframes spin {
+            from { transform: rotate(0deg); }
+            to { transform: rotate(360deg); }
+          }
+        `;
+        document.head.appendChild(styleSheet);
+    }
+
+    private initLabel() {
+        const text = document.createElement("div");
+        text.innerText = "Loading...";
+        text.style.cssText = `
+        color: var(--foreground-color);
+        font-size: 16px;
+        position: relative;
+        top: calc(40% + 100px);
+        left: calc(50% + 25px);
+        transform: translate(-50%, -50%);
+        width: 50px;
+        height: 50px;
+        `;
+        this.appendChild(text);
+    }
+}
+
+customElements.define("chili-loading", Loading);

package/packages/global.d.ts

@@ -0,0 +1,31 @@
+// Part of the Chili3d Project, under the AGPL-3.0 License.
+// See LICENSE file in the project root for full license information.
+
+declare module "*.module.css" {
+    const classes: any;
+    export default classes;
+}
+
+declare module "*.wasm" {
+    const fun: string;
+    export default fun;
+}
+
+declare module "*.cur" {
+    const cur: string;
+    export default cur;
+}
+
+declare module "*.svg" {
+    const icon: string;
+    export default icon;
+}
+
+declare module "*.jpg" {
+    const path: string;
+    export default path;
+}
+
+declare var __APP_VERSION__: string;
+declare var __DOCUMENT_VERSION__: string;
+declare var __IS_PRODUCTION__: boolean;

package/public/favicon.svg

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
+<!-- Created with Vectornator (http://vectornator.io/) -->
+<svg height="100%" stroke-miterlimit="10" style="fill-rule:nonzero;clip-rule:evenodd;stroke-linecap:round;stroke-linejoin:round;" version="1.1" viewBox="31 31 450 450" width="100%" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<defs/>
+<g id="图层-1">
+<path d="M71.7162 480.951C245.442 476.178 386.182 360.591 424.806 237.032C433.072 210.6 428.265 188.187 407.178 174.42C397.044 167.804 393.006 171.672 385.839 175.233C380.422 177.925 373.922 182.241 379.097 187.137C382.615 190.465 380.668 194.9 379.363 197.573C375.125 206.224 355.105 205.326 334.648 195.56C314.192 185.793 301.05 170.855 305.297 162.204C308.269 156.139 318.139 154.402 332.173 157.868C339.807 159.753 341.653 156.992 343.845 153.691C347.933 147.536 345.196 145.675 341.891 144.204C333.356 140.404 321.576 138.261 309.985 137.735C145.144 133.229 267.528 285.847 51.8973 427.303C33.8726 436.816 7.71038 482.711 71.7162 480.951Z" fill="#f0322d" fill-rule="nonzero" opacity="1" stroke="none"/>
+<path d="M356.231 185.86C360.69 183.864 365.088 181.629 369.434 179.183C376.947 174.899 384.181 170.153 391.092 164.973C433.422 133.468 465.071 92.5206 477.548 73.7696C481.013 68.5621 482.62 57.4866 478.761 52.105C469.108 38.6429 449.136 31.9566 431.287 31.081C423.477 30.6979 415.771 31.6629 408.83 34.2076C405.923 35.2737 400.017 38.9675 398.218 50.6922C391.564 94.0823 368.434 127.479 353.408 149.769C349.45 155.652 345.898 160.541 342.996 164.35C341.599 166.185 338.313 170.011 335.256 172.935C332.41 175.658 332.712 180.687 336.496 183.727C341.343 187.62 351.538 187.958 356.231 185.86Z" fill="#6ec83c" fill-rule="nonzero" opacity="1" stroke="none"/>
+</g>
+</svg>