@gg-web-engine/core 0.0.1

package/dist/base/math/numbers.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lerpNumber = exports.averageAngle = void 0;
+const averageAngle = (angleA, angleB, factor = 0.5) => {
+    while (Math.abs(angleA - angleB) > Math.PI) {
+        angleB += Math.PI * (angleA > angleB ? 2 : -2);
+    }
+    return angleA * (1 - factor) + angleB * factor;
+};
+exports.averageAngle = averageAngle;
+const lerpNumber = (a, b, t) => {
+    return a + t * (b - a);
+};
+exports.lerpNumber = lerpNumber;

package/dist/base/math/point2.d.ts

@@ -0,0 +1,15 @@
+import { Point2 } from '../models/points';
+export declare class Pnt2 {
+    /** clone point */
+    static clone(p: Point2): Point2;
+    /** add point b to point a */
+    static add(a: Point2, b: Point2): Point2;
+    /** subtract point b from point a */
+    static sub(a: Point2, b: Point2): Point2;
+    /** normalize */
+    static norm(p: Point2): Point2;
+    /** scalar multiplication */
+    static scalarMult(p: Point2, m: number): Point2;
+    /** linear interpolation */
+    static lerp(a: Point2, b: Point2, t: number): Point2;
+}

package/dist/base/math/point2.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pnt2 = void 0;
+class Pnt2 {
+    /** clone point */
+    static clone(p) {
+        return Object.assign({}, p);
+    }
+    /** add point b to point a */
+    static add(a, b) {
+        return { x: a.x + b.x, y: a.y + b.y };
+    }
+    /** subtract point b from point a */
+    static sub(a, b) {
+        return { x: a.x - b.x, y: a.y - b.y };
+    }
+    /** normalize */
+    static norm(p) {
+        const length = Math.sqrt(p.x ** 2 + p.y ** 2);
+        return {
+            x: p.x / length,
+            y: p.y / length,
+        };
+    }
+    /** scalar multiplication */
+    static scalarMult(p, m) {
+        return {
+            x: p.x * m,
+            y: p.y * m,
+        };
+    }
+    /** linear interpolation */
+    static lerp(a, b, t) {
+        return {
+            x: a.x + t * (b.x - a.x),
+            y: a.y + t * (b.y - a.y),
+        };
+    }
+}
+exports.Pnt2 = Pnt2;

package/dist/base/math/point3.d.ts

@@ -0,0 +1,25 @@
+import { Point3, Point4 } from '../models/points';
+export declare class Pnt3 {
+    /** clone point */
+    static clone(p: Point3): Point3;
+    /** add point b to point a */
+    static add(a: Point3, b: Point3): Point3;
+    /** subtract point b from point a */
+    static sub(a: Point3, b: Point3): Point3;
+    /** calculate vector length (squared) */
+    static lenSq(v: Point3): number;
+    /** calculate vector length */
+    static len(v: Point3): number;
+    /** cross vectors */
+    static cross(a: Point3, b: Point3): Point3;
+    /** normalize */
+    static norm(p: Point3): Point3;
+    /** scalar multiplication */
+    static scalarMult(p: Point3, m: number): Point3;
+    /** linear interpolation */
+    static lerp(a: Point3, b: Point3, t: number): Point3;
+    /** rotate point a with quaternion q */
+    static rot(p: Point3, q: Point4): Point3;
+    /** rotate point around axis a (normalized vector) */
+    static rotAround(p: Point3, axis: Point3, angle: number): Point3;
+}

package/dist/base/math/point3.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Pnt3 = void 0;
+const quaternion_1 = require("./quaternion");
+class Pnt3 {
+    /** clone point */
+    static clone(p) {
+        return Object.assign({}, p);
+    }
+    /** add point b to point a */
+    static add(a, b) {
+        return { x: a.x + b.x, y: a.y + b.y, z: a.z + b.z };
+    }
+    /** subtract point b from point a */
+    static sub(a, b) {
+        return { x: a.x - b.x, y: a.y - b.y, z: a.z - b.z };
+    }
+    /** calculate vector length (squared) */
+    static lenSq(v) {
+        return v.x * v.x + v.y * v.y + v.z * v.z;
+    }
+    /** calculate vector length */
+    static len(v) {
+        return Math.sqrt(v.x * v.x + v.y * v.y + v.z * v.z);
+    }
+    /** cross vectors */
+    static cross(a, b) {
+        const ax = a.x, ay = a.y, az = a.z;
+        const bx = b.x, by = b.y, bz = b.z;
+        return {
+            x: ay * bz - az * by,
+            y: az * bx - ax * bz,
+            z: ax * by - ay * bx,
+        };
+    }
+    /** normalize */
+    static norm(p) {
+        const length = Math.sqrt(p.x ** 2 + p.y ** 2 + p.z ** 2);
+        if (length === 0) {
+            return p;
+        }
+        return {
+            x: p.x / length,
+            y: p.y / length,
+            z: p.z / length,
+        };
+    }
+    /** scalar multiplication */
+    static scalarMult(p, m) {
+        return {
+            x: p.x * m,
+            y: p.y * m,
+            z: p.z * m,
+        };
+    }
+    /** linear interpolation */
+    static lerp(a, b, t) {
+        return {
+            x: a.x + t * (b.x - a.x),
+            y: a.y + t * (b.y - a.y),
+            z: a.z + t * (b.z - a.z),
+        };
+    }
+    /** rotate point a with quaternion q */
+    static rot(p, q) {
+        // faster version of:
+        // let qvec: Point4 = {x: v.x, y: v.y, z: v.z, w: 0};
+        // let qinv: Point4 = {x: -q.x, y: -q.y, z: -q.z, w: q.w};
+        // let res = Qtrn.mult(q, Qtrn.mult(qvec, qinv));
+        // return {x: res.x, y: res.y, z: res.z};
+        const { x, y, z } = p;
+        return {
+            x: q.w * q.w * x +
+                2 * q.y * q.w * z -
+                2 * q.z * q.w * y +
+                q.x * q.x * x +
+                2 * q.y * q.x * y +
+                2 * q.z * q.x * z -
+                q.y * q.y * x -
+                q.z * q.z * x,
+            y: 2 * q.x * q.y * x +
+                q.y * q.y * y +
+                2 * q.z * q.y * z +
+                2 * q.w * q.z * x -
+                q.z * q.z * y +
+                q.w * q.w * y -
+                2 * q.x * q.w * z -
+                q.x * q.x * y,
+            z: 2 * q.x * q.z * x +
+                2 * q.y * q.z * y +
+                q.z * q.z * z -
+                2 * q.w * q.y * x -
+                q.y * q.y * z +
+                2 * q.w * q.x * y -
+                q.x * q.x * z +
+                q.w * q.w * z,
+        };
+    }
+    /** rotate point around axis a (normalized vector) */
+    static rotAround(p, axis, angle) {
+        return this.rot(p, quaternion_1.Qtrn.fromAngle(axis, angle));
+    }
+}
+exports.Pnt3 = Pnt3;

package/dist/base/math/quaternion.d.ts

@@ -0,0 +1,28 @@
+import { Point3, Point4 } from '../models/points';
+export declare class Qtrn {
+    /** clone quaternion */
+    static clone(q: Point4): Point4;
+    /** add quaternion b to quaternion a */
+    static add(a: Point4, b: Point4): Point4;
+    static mult(a: Point4, b: Point4): Point4;
+    static combineRotations(...quaternions: Point4[]): Point4;
+    /** linear interpolation */
+    static lerp(a: Point4, b: Point4, t: number): Point4;
+    /** spherical interpolation */
+    static slerp(a: Point4, b: Point4, t: number): Point4;
+    /** creates quaternion from simple angle around axis. Assumes that axis vector is normalized */
+    static fromAngle(axis: Point3, angle: number): {
+        w: number;
+        x: number;
+        y: number;
+        z: number;
+    };
+    /** creates quaternion from 4-dimension rotation matrix */
+    static fromMatrix4(m: number[]): Point4;
+    /** creates a quaternion from euler */
+    static fromEuler(e: Point3): Point4;
+    /** converts a quaternion to euler */
+    static toEuler(q: Point4): Point3;
+    /** creates a rotation for object, so it will look at some point in space */
+    static lookAt(eye: Point3, target: Point3, up: Point3): Point4;
+}

package/dist/base/math/quaternion.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Qtrn = void 0;
+const point3_1 = require("./point3");
+const matrix4_1 = require("./matrix4");
+class Qtrn {
+    /** clone quaternion */
+    static clone(q) {
+        return Object.assign({}, q);
+    }
+    /** add quaternion b to quaternion a */
+    static add(a, b) {
+        const w = a.w + b.w;
+        const x = a.x + b.x;
+        const y = a.y + b.y;
+        const z = a.z + b.z;
+        const magnitude = Math.sqrt(w * w + x * x + y * y + z * z);
+        return { w: w / magnitude, x: x / magnitude, y: y / magnitude, z: z / magnitude };
+    }
+    static mult(a, b) {
+        return {
+            w: a.w * b.w - a.x * b.x - a.y * b.y - a.z * b.z,
+            x: a.w * b.x + a.x * b.w + a.y * b.z - a.z * b.y,
+            y: a.w * b.y - a.x * b.z + a.y * b.w + a.z * b.x,
+            z: a.w * b.z + a.x * b.y - a.y * b.x + a.z * b.w,
+        };
+    }
+    static combineRotations(...quaternions) {
+        let result = { w: 1, x: 0, y: 0, z: 0 };
+        for (const quat of quaternions) {
+            result = this.mult(result, quat);
+        }
+        return result;
+    }
+    /** linear interpolation */
+    static lerp(a, b, t) {
+        return {
+            x: a.x + t * (b.x - a.x),
+            y: a.y + t * (b.y - a.y),
+            z: a.z + t * (b.z - a.z),
+            w: a.w + t * (b.w - a.w),
+        };
+    }
+    /** spherical interpolation */
+    static slerp(a, b, t) {
+        let dot = a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w;
+        let theta = Math.acos(dot);
+        let sinTheta = Math.sin(theta);
+        let x = (a.x * Math.sin((1 - t) * theta)) / sinTheta + (b.x * Math.sin(t * theta)) / sinTheta;
+        let y = (a.y * Math.sin((1 - t) * theta)) / sinTheta + (b.y * Math.sin(t * theta)) / sinTheta;
+        let z = (a.z * Math.sin((1 - t) * theta)) / sinTheta + (b.z * Math.sin(t * theta)) / sinTheta;
+        let w = (a.w * Math.sin((1 - t) * theta)) / sinTheta + (b.w * Math.sin(t * theta)) / sinTheta;
+        if (isNaN(x) || isNaN(y) || isNaN(z) || isNaN(w)) {
+            // happens when they are equal
+            return Qtrn.clone(a);
+        }
+        return { x, y, z, w };
+    }
+    /** creates quaternion from simple angle around axis. Assumes that axis vector is normalized */
+    static fromAngle(axis, angle) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/angleToQuaternion/index.htm
+        const halfAngle = angle / 2, s = Math.sin(halfAngle);
+        return Object.assign(Object.assign({}, point3_1.Pnt3.scalarMult(axis, s)), { w: Math.cos(halfAngle) });
+    }
+    /** creates quaternion from 4-dimension rotation matrix */
+    static fromMatrix4(m) {
+        // http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm
+        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+        const m11 = m[0], m12 = m[4], m13 = m[8], m21 = m[1], m22 = m[5], m23 = m[9], m31 = m[2], m32 = m[6], m33 = m[10], trace = m11 + m22 + m33;
+        if (trace > 0) {
+            const s = 0.5 / Math.sqrt(trace + 1.0);
+            return {
+                x: (m32 - m23) * s,
+                y: (m13 - m31) * s,
+                z: (m21 - m12) * s,
+                w: 0.25 / s,
+            };
+        }
+        else if (m11 > m22 && m11 > m33) {
+            const s = 2.0 * Math.sqrt(1.0 + m11 - m22 - m33);
+            return {
+                x: 0.25 * s,
+                y: (m12 + m21) / s,
+                z: (m13 + m31) / s,
+                w: (m32 - m23) / s,
+            };
+        }
+        else if (m22 > m33) {
+            const s = 2.0 * Math.sqrt(1.0 + m22 - m11 - m33);
+            return {
+                x: (m12 + m21) / s,
+                y: 0.25 * s,
+                z: (m23 + m32) / s,
+                w: (m13 - m31) / s,
+            };
+        }
+        else {
+            const s = 2.0 * Math.sqrt(1.0 + m33 - m11 - m22);
+            return {
+                x: (m13 + m31) / s,
+                y: (m23 + m32) / s,
+                z: 0.25 * s,
+                w: (m21 - m12) / s,
+            };
+        }
+    }
+    /** creates a quaternion from euler */
+    static fromEuler(e) {
+        const roll = e.x;
+        const pitch = e.y;
+        const yaw = e.z;
+        const cy = Math.cos(yaw * 0.5);
+        const sy = Math.sin(yaw * 0.5);
+        const cp = Math.cos(pitch * 0.5);
+        const sp = Math.sin(pitch * 0.5);
+        const cr = Math.cos(roll * 0.5);
+        const sr = Math.sin(roll * 0.5);
+        const qw = cr * cp * cy + sr * sp * sy;
+        const qx = sr * cp * cy - cr * sp * sy;
+        const qy = cr * sp * cy + sr * cp * sy;
+        const qz = cr * cp * sy - sr * sp * cy;
+        return { w: qw, x: qx, y: qy, z: qz };
+    }
+    /** converts a quaternion to euler */
+    static toEuler(q) {
+        const qw = q.w;
+        const qx = q.x;
+        const qy = q.y;
+        const qz = q.z;
+        const sinr_cosp = 2 * (qw * qx + qy * qz);
+        const cosr_cosp = 1 - 2 * (qx * qx + qy * qy);
+        const roll = Math.atan2(sinr_cosp, cosr_cosp);
+        const sinp = 2 * (qw * qy - qz * qx);
+        const pitch = Math.abs(sinp) >= 1 ? (Math.sign(sinp) * Math.PI) / 2 : Math.asin(sinp);
+        const siny_cosp = 2 * (qw * qz + qx * qy);
+        const cosy_cosp = 1 - 2 * (qy * qy + qz * qz);
+        const yaw = Math.atan2(siny_cosp, cosy_cosp);
+        return { x: roll, y: pitch, z: yaw };
+    }
+    /** creates a rotation for object, so it will look at some point in space */
+    static lookAt(eye, target, up) {
+        return this.fromMatrix4(matrix4_1.Mtrx4.lookAt(eye, target, up));
+    }
+}
+exports.Qtrn = Qtrn;

package/dist/base/models/axis-directions.d.ts

@@ -0,0 +1,3 @@
+export declare type AxisDirection2 = 'x' | 'y' | '-x' | '-y';
+export declare type AxisDirection3 = AxisDirection2 | 'z' | '-z';
+export declare type AxisDirection4 = AxisDirection3 | 'w' | '-w';

package/dist/base/models/axis-directions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/models/body-options.d.ts

@@ -0,0 +1,6 @@
+export interface BodyOptions {
+    dynamic: boolean;
+    mass: number;
+    restitution: number;
+    friction: number;
+}

package/dist/base/models/body-options.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/models/geometry-nodes.d.ts

@@ -0,0 +1,7 @@
+import { Point2, Point3 } from './points';
+export declare type GgBox<T> = {
+    min: T;
+    max: T;
+};
+export declare type GgBox2d = GgBox<Point2>;
+export declare type GgBox3d = GgBox<Point3>;

package/dist/base/models/geometry-nodes.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/models/points.d.ts

@@ -0,0 +1,15 @@
+export declare type Point2 = {
+    x: number;
+    y: number;
+};
+export declare type Point3 = {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare type Point4 = {
+    x: number;
+    y: number;
+    z: number;
+    w: number;
+};

package/dist/base/models/points.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/base/ui/gg-console.ui.d.ts

@@ -0,0 +1,21 @@
+export declare class GgConsoleUI {
+    private static _instance;
+    static get instance(): GgConsoleUI;
+    private constructor();
+    private output;
+    private commandHistory;
+    private currentCommandIndex;
+    elements: {
+        main: HTMLDivElement;
+        input: HTMLInputElement;
+        output: HTMLTextAreaElement;
+    } | null;
+    get isUIShown(): boolean;
+    createUI(): void;
+    destroyUI(): void;
+    onUsePreviousCommand(): void;
+    onUseNextCommand(): void;
+    onInput(): Promise<void>;
+    private stdout;
+    setupDragging(): void;
+}

package/dist/base/ui/gg-console.ui.js

@@ -0,0 +1,162 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GgConsoleUI = void 0;
+const gg_static_1 = require("../gg-static");
+class GgConsoleUI {
+    constructor() {
+        this.output = `
+                  ▄████   ▄████     █     █░▓█████  ▄▄▄▄   
+                 ██▒ ▀█▒ ██▒ ▀█▒   ▓█░ █ ░█░▓█   ▀ ▓█████▄ 
+                ▒██░▄▄▄░▒██░▄▄▄░   ▒█░ █ ░█ ▒███   ▒██▒ ▄██
+                ░▓█  ██▓░▓█  ██▓   ░█░ █ ░█ ▒▓█  ▄ ▒██░█▀  
+                ░▒▓███▀▒░▒▓███▀▒   ░░██▒██▓ ░▒████▒░▓█  ▀█▓
+                 ░▒   ▒  ░▒   ▒    ░ ▓░▒ ▒  ░░ ▒░ ░░▒▓███▀▒
+                  ░   ░   ░   ░      ▒ ░ ░   ░ ░  ░▒░▒   ░ 
+                ░ ░   ░ ░ ░   ░      ░   ░     ░    ░    ░ 
+                      ░       ░        ░       ░  ░ ░      
+                                                         ░ 
+             >>> https://github.com/AndyGura/gg-web-engine <<<
+Welcome to GG web engine UI console. 
+Enter command in input below.
+
+List of available commands: commandslist 
+`;
+        this.commandHistory = [];
+        this.currentCommandIndex = 0; // for repeating command using up/down arrow keys
+        this.elements = null;
+    }
+    static get instance() {
+        if (!this._instance) {
+            this._instance = new GgConsoleUI();
+        }
+        return this._instance;
+    }
+    get isUIShown() {
+        return !!this.elements;
+    }
+    createUI() {
+        if (this.elements) {
+            return;
+        }
+        const main = document.createElement('div');
+        main.innerHTML = `
+  <div id="gg-console-header" style="padding: 10px; cursor: move; z-index: 10; background-color: #054a81; border: 1px solid white; font-size: large;">GG web engine UI console</div>
+  <textarea id="gg-console-output" disabled style="resize: none; flex-grow: 1; background: #555555; border: 1px solid white; color: white; font-family: monospace;" ></textarea>
+  <input id="gg-console-input" style="background: #555555; border: 1px solid white; color: white; font-family: monospace;"/>`;
+        main.style.position = 'absolute';
+        main.style.zIndex = '1000';
+        main.style.backgroundColor = '#222222';
+        main.style.border = '1px solid white';
+        main.style.width = '640px';
+        main.style.height = '480px';
+        main.style.display = 'flex';
+        main.style.flexDirection = 'column';
+        main.style.alignItems = 'stretch';
+        main.style.padding = '3px';
+        main.style.rowGap = '3px';
+        main.style.fontFamily = 'monospace';
+        main.style.color = 'white';
+        document.body.append(main);
+        this.elements = {
+            main,
+            input: document.getElementById('gg-console-input'),
+            output: document.getElementById('gg-console-output'),
+        };
+        this.elements.input.onkeydown = event => {
+            if ((event === null || event === void 0 ? void 0 : event.keyCode) === 13) {
+                event.preventDefault();
+                this.onInput().then();
+            }
+            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 38) {
+                event.preventDefault();
+                this.onUsePreviousCommand();
+            }
+            else if ((event === null || event === void 0 ? void 0 : event.keyCode) === 40) {
+                event.preventDefault();
+                this.onUseNextCommand();
+            }
+        };
+        this.stdout();
+        this.setupDragging();
+        setTimeout(() => this.elements.input.focus(), 20);
+    }
+    destroyUI() {
+        if (!this.elements) {
+            return;
+        }
+        document.body.removeChild(this.elements.main);
+        this.elements = null;
+    }
+    onUsePreviousCommand() {
+        if (this.commandHistory.length === 0) {
+            return;
+        }
+        this.currentCommandIndex--;
+        if (this.currentCommandIndex < 0) {
+            this.currentCommandIndex += this.commandHistory.length;
+        }
+        this.elements.input.value = this.commandHistory[this.currentCommandIndex % this.commandHistory.length];
+    }
+    onUseNextCommand() {
+        if (this.commandHistory.length === 0) {
+            return;
+        }
+        this.currentCommandIndex++;
+        this.elements.input.value = this.commandHistory[this.currentCommandIndex % this.commandHistory.length];
+    }
+    onInput() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = this.elements.input.value;
+            this.elements.input.value = '';
+            this.stdout('\n> ' + command);
+            this.stdout('\n' + (yield gg_static_1.GgStatic.instance.console(command)));
+            this.commandHistory.push(command);
+            this.currentCommandIndex = this.commandHistory.length;
+        });
+    }
+    stdout(s = '') {
+        this.output += s;
+        this.elements.output.value = this.output;
+        this.elements.output.scrollTop = this.elements.output.scrollHeight;
+    }
+    setupDragging() {
+        let x = 0, y = 0;
+        const dragMouseDown = (e) => {
+            e = e || window.event;
+            e.preventDefault();
+            // get the mouse cursor position at startup:
+            x = e.clientX;
+            y = e.clientY;
+            document.onmouseup = closeDragElement;
+            // call a function whenever the cursor moves:
+            document.onmousemove = elementDrag;
+        };
+        const elementDrag = (e) => {
+            e.preventDefault();
+            // calculate the new cursor position:
+            const curX = x - e.clientX;
+            const curY = y - e.clientY;
+            x = e.clientX;
+            y = e.clientY;
+            // set the element's new position:
+            this.elements.main.style.left = this.elements.main.offsetLeft - curX + 'px';
+            this.elements.main.style.top = this.elements.main.offsetTop - curY + 'px';
+        };
+        const closeDragElement = () => {
+            // stop moving when mouse button is released:
+            document.onmouseup = null;
+            document.onmousemove = null;
+        };
+        document.getElementById('gg-console-header').onmousedown = dragMouseDown;
+    }
+}
+exports.GgConsoleUI = GgConsoleUI;

package/dist/base/ui/gg-debugger.ui.d.ts

@@ -0,0 +1,10 @@
+export declare class GgDebuggerUI {
+    private static _instance;
+    static get instance(): GgDebuggerUI;
+    private ui;
+    private removed$;
+    private constructor();
+    get isUIShown(): boolean;
+    createUI(): void;
+    destroyUI(): void;
+}