@sketch-hq/sketch-web-renderer 14.12.2 → 14.13.1

package/out/web-renderer/WasmModule-b06ee9c9.js

@@ -0,0 +1,921 @@
+import 'react';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    if (typeof b !== "function" && b !== null)
+        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __awaiter(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());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+var WebRendererError = /** @class */ (function (_super) {
+    __extends(WebRendererError, _super);
+    function WebRendererError(code, message, cause) {
+        var _newTarget = this.constructor;
+        var _this = _super.call(this, "(".concat(code, ") ").concat(message)) || this;
+        _this.code = code;
+        _this.cause = cause;
+        _this.name = WebRendererError.name;
+        Object.setPrototypeOf(_this, _newTarget.prototype);
+        return _this;
+    }
+    return WebRendererError;
+}(Error));
+
+var WebRendererMode;
+(function (WebRendererMode) {
+    WebRendererMode["debug"] = "debug";
+    WebRendererMode["release"] = "release";
+})(WebRendererMode || (WebRendererMode = {}));
+
+var PrototypeResizeMode;
+(function (PrototypeResizeMode) {
+    PrototypeResizeMode["Fit"] = "Fit";
+    PrototypeResizeMode["FillWidth"] = "FillWidth";
+    PrototypeResizeMode["ActualSize"] = "ActualSize";
+})(PrototypeResizeMode || (PrototypeResizeMode = {}));
+
+/**
+ * Very simple event emitter that can be extended from any class
+ */
+var EventEmitter = /** @class */ (function () {
+    function EventEmitter() {
+        this.listeners = {};
+    }
+    EventEmitter.prototype.on = function (event, callback) {
+        var _a, _b;
+        this.listeners[event] = (_a = this.listeners[event]) !== null && _a !== void 0 ? _a : new Set();
+        (_b = this.listeners[event]) === null || _b === void 0 ? void 0 : _b.add(callback);
+    };
+    EventEmitter.prototype.off = function (event, callback) {
+        var _a;
+        (_a = this.listeners[event]) === null || _a === void 0 ? void 0 : _a.delete(callback);
+    };
+    /**
+     * Forward a specific event to the given target
+     */
+    EventEmitter.prototype.forwardEvent = function (target, event) {
+        var callback = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            target.emit.apply(target, __spreadArray([event], args, false));
+        };
+        this.on(event, callback);
+    };
+    EventEmitter.prototype.emit = function (event) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        var listeners = this.listeners[event];
+        if (listeners === null || listeners === void 0 ? void 0 : listeners.size) {
+            listeners.forEach(function (listener) {
+                // Invoke listeners on next tick. This helps avoid tricky situations
+                // where handlers potentially syncronously dispose the renderer or
+                // trigger other large internal state changes in the same call stack as
+                // emit(...) is invoked.
+                Promise.resolve().then(function () {
+                    listener.apply(void 0, args);
+                });
+            });
+        }
+    };
+    EventEmitter.prototype.detachAllListeners = function () {
+        this.listeners = {};
+    };
+    return EventEmitter;
+}());
+
+/**
+ * ListenersCollector
+ * It's a wrapper around addEventListener, which collects
+ * all the callbacks, and provides a way to remove all of them
+ */
+var ListenersCollector = /** @class */ (function () {
+    function ListenersCollector(disabled) {
+        if (disabled === void 0) { disabled = false; }
+        this.removeListenerCallbacks = [];
+        this.disabled = disabled;
+    }
+    ListenersCollector.prototype.add = function (scope, event, callback, options) {
+        var _this = this;
+        var safeguardedCallback = function () {
+            var args = [];
+            for (var _i = 0; _i < arguments.length; _i++) {
+                args[_i] = arguments[_i];
+            }
+            if (_this.disabled) {
+                return;
+            }
+            callback.apply(void 0, args);
+        };
+        scope.addEventListener(event, safeguardedCallback, options);
+        var remove = function () {
+            scope.removeEventListener(event, safeguardedCallback, options);
+        };
+        this.removeListenerCallbacks.push(remove);
+        // Returns the function to remove the event
+        return remove;
+    };
+    ListenersCollector.prototype.dispose = function () {
+        this.removeListenerCallbacks.forEach(function (remove) { return remove(); });
+    };
+    ListenersCollector.prototype.setDisabled = function (disabled) {
+        this.disabled = disabled;
+    };
+    return ListenersCollector;
+}());
+
+/**
+ * Initial dummy structure for feature flags
+ */
+var DefaultFeatureFlags = {
+    delayedDraw: true,
+    offscreenCanvas: false,
+    useDirtyRectsRendering: true,
+    safariWebGL2: false,
+    // When this is true, the canvas won't allow to pan/zoom outside the page boundaries
+    pageBoundariesLimit: false,
+    // When this is true, the canvas will send user events through the rendering scene.
+    // This is useful to check which layer was clicked/hovered, etc.
+    canvasLayersEvents: false,
+};
+
+// Taken from https://gist.github.com/Craga89/2829457
+var getiOSVersion = function (userAgent) {
+    return parseFloat(('' +
+        (/CPU.*OS ([0-9_]{1,5})|(CPU like).*AppleWebKit.*Mobile/i.exec(userAgent) || [0, ''])[1])
+        .replace('undefined', '3_2')
+        .replace('_', '.')
+        .replace('_', '')) || false;
+};
+var SAFARI_USER_AGENT_REGEX = /(iPhone|Macintosh|iPad)(.*)(Version)\/(0|[1-9]\d*)\.(0|[1-9]\d*)\.?(0|[1-9]\d*)?/;
+/**
+ * Parses a Safari user agent string into structured data. If the user agent string
+ * isn't for a Safari browser, null is returned.
+ *
+ * User Agent parsing is generally discouraged and can never be 100% reliable. So favour
+ * feature detection when possible, and do not use this method for critical functionality.
+ */
+var parseSafariUserAgent = function (userAgent) {
+    if (userAgent === void 0) { userAgent = window.navigator.userAgent; }
+    if (userAgent.includes('Chrome/') ||
+        userAgent.includes('Chromium/') ||
+        userAgent.includes('Opera/') ||
+        userAgent.includes('Firefox/'))
+        return null;
+    var match = userAgent.match(SAFARI_USER_AGENT_REGEX);
+    if (!match)
+        return null;
+    var hardware = match[1];
+    if (hardware !== 'Macintosh' && hardware !== 'iPad' && hardware !== 'iPhone')
+        return null;
+    return {
+        hardware: hardware,
+        version: {
+            major: parseInt(match[4]) || 0,
+            minor: parseInt(match[5]) || 0,
+            patch: parseInt(match[6]) || 0,
+        },
+    };
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function debounce(callback, delayMs) {
+    var timeoutId;
+    function debouncedCallback() {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        clearTimeout(timeoutId);
+        timeoutId = setTimeout(function () {
+            callback.apply(void 0, args);
+        }, delayMs);
+    }
+    /**
+     * Cancel the potentially scheduled execution.
+     * Call this function to clean things up properly.
+     */
+    debouncedCallback.cancel = function () {
+        if (timeoutId) {
+            clearTimeout(timeoutId);
+        }
+    };
+    return debouncedCallback;
+}
+/**
+ * Extract the correct mouse position
+ * @param e: The type can be MouseEvent or TouchEvent or GestureEvent, but we are using any because for some reason the pageX/Y is not included inside the TouchEvent type definition.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function extractPointer(e) {
+    var _a, _b, _c, _d, _e;
+    // If the touches array is empty, but the changedTouches is not, it means that all the fingers were lifted from the screen,
+    // and the changed touches contains the position of the last finger that was lifted.
+    // The changed touches might contain more fingers, in case multiple fingers were lifted at the same time,
+    // in that case we would need to find the mid point, but we don't really need to handle that, because no user interaction depends on that
+    var touch = (_b = (_a = e.touches) === null || _a === void 0 ? void 0 : _a[0]) !== null && _b !== void 0 ? _b : (_c = e.changedTouches) === null || _c === void 0 ? void 0 : _c[0];
+    return {
+        x: (_d = touch === null || touch === void 0 ? void 0 : touch.clientX) !== null && _d !== void 0 ? _d : e.clientX,
+        y: (_e = touch === null || touch === void 0 ? void 0 : touch.clientY) !== null && _e !== void 0 ? _e : e.clientY,
+    };
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}
+function getSupportedWebGLVersion(deviceInfo) {
+    // We are forcing WebGL 1 on AMD Radeon Pro 5xxx series
+    // On macs with this GPU, Chrome scrambles the vertices of the triangles sent to the gpu
+    // causing incorrect renderings. See https://bugs.chromium.org/p/chromium/issues/detail?id=1301748&q=webgl&can=2
+    // GH ticket: https://github.com/sketch-hq/Cloud/issues/17439
+    var amdRadeonRegex = /amd\sradeon\s(pro|rx)\s5\d\d\d/gi;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    var isChrome = Boolean(window.chrome);
+    if (isChrome && deviceInfo.gpu && amdRadeonRegex.test(deviceInfo.gpu)) {
+        return 1;
+    }
+    // Safari 15 has support for WebGL 2, but their implementation
+    // is still slow and filled with bugs, so we are forcing WebGL 1
+    // until we see that WebGL 2 starts working correctly on Safari
+    if (parseSafariUserAgent() && !DefaultFeatureFlags.safariWebGL2)
+        return 1;
+    if (typeof WebGL2RenderingContext !== 'undefined')
+        return 2;
+    return 1;
+}
+function convertEmbindVectorToArray(vector) {
+    if (!vector)
+        return [];
+    var result = [];
+    for (var i = 0; i < vector.size(); i++) {
+        result.push(vector.get(i));
+    }
+    return result;
+}
+/**
+ * Keep in mind that this check is not entirely accurate on Windows machines.
+ * On Safari for MacOS, it's fairly accurate. That's where we use it.
+ * @see: https://stackoverflow.com/questions/4817029/whats-the-best-way-to-detect-a-touch-screen-device-using-javascript
+ */
+function isTouchDevice() {
+    return ('ontouchstart' in window ||
+        navigator.maxTouchPoints > 0 ||
+        navigator.msMaxTouchPoints > 0);
+}
+/**
+ * Remove all the keys that have an undefined value.
+ * The function doesn't edit the given object directly, but it creates and returns a copy
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function removeUndefinedKeys(targetObject) {
+    var copiedObject = __assign({}, targetObject);
+    Object.keys(copiedObject).forEach(function (key) {
+        if (typeof copiedObject[key] !== 'undefined')
+            return;
+        delete copiedObject[key];
+    });
+    return copiedObject;
+}
+/**
+ * Prevent to bind both onClick and touchEnd events by only binding the required event based on the device.
+ * The function is designed to be used with React.
+ *
+ * How to use:
+ *
+ * <div {...touchableClick(myCallback) />
+ */
+function touchableClick(callback) {
+    return isTouchDevice() ? { onTouchEnd: callback } : { onClick: callback };
+}
+var safePtrAccess = function (embindPtr) {
+    /**
+     * We are preventing JS to throw an error when accessing
+     * the internal methods of a pointer when it is deleted.
+     *
+     * Given "$$.count.value" are internal properties of emscripten
+     * we re-type prFile as any
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if ((embindPtr === null || embindPtr === void 0 ? void 0 : embindPtr.$$.count.value) === 0) {
+        return null;
+    }
+    return embindPtr;
+};
+
+var GestureManager = /** @class */ (function (_super) {
+    __extends(GestureManager, _super);
+    function GestureManager(target, invertedWheelZoom, disabled) {
+        if (invertedWheelZoom === void 0) { invertedWheelZoom = false; }
+        if (disabled === void 0) { disabled = false; }
+        var _this = _super.call(this) || this;
+        _this.state = {
+            // The distance between the 2 fingers used to pinch to zoom
+            pinchToZoomLastDistance: 0,
+            lastGestureScale: 1,
+            isCtrlPressed: false,
+        };
+        _this.handleGestureStart = function (e) {
+            e.preventDefault();
+            _this.state.lastGestureScale = e.scale;
+        };
+        _this.handleGestureChange = function (e) {
+            e.preventDefault();
+            var delta = e.scale / _this.state.lastGestureScale;
+            _this.state.lastGestureScale = e.scale;
+            var center = _this.getCorrectPointerPosition(e);
+            _this.emitZoomEvent(delta, center);
+        };
+        _this.handleGestureEnd = function (e) {
+            e.preventDefault();
+        };
+        /**
+         * Update the mouse position and emit the mousemove event
+         */
+        _this.updateMousePosition = function (e) {
+            _this.emit('pointermove', {
+                type: 'mouse',
+                position: _this.getCorrectPointerPosition(e),
+                button: e.button,
+                touchesCount: 0,
+            });
+        };
+        _this.updateGlobalMousePosition = function (e) {
+            _this.emit('globalpointermove', {
+                type: 'mouse',
+                position: _this.getCorrectPointerPosition(e),
+                button: e.button,
+                touchesCount: 0,
+            });
+        };
+        _this.handleTouchStart = function (e) {
+            e.preventDefault();
+            _this.handleTouchPinchToZoomStart(e);
+            _this.emit('pointerdown', {
+                type: 'touch',
+                position: _this.getCorrectPointerPosition(e),
+                button: 0,
+                touchesCount: e.touches.length,
+            });
+        };
+        _this.handleMouseDown = function (e) {
+            // Preventing dragging while keeping the CTRL key pressed.
+            // When holding the CTRL key the user is expected to zoom, so it might cause conflicts with the pan.
+            // But also, on macOS left-clicking while holding the CTRL key opens the context menu,
+            // and when the context menu is open, no mouseup event is triggered after releasing the left click.
+            // We would also need to track the context menu event and treat it as a mouseup, bringing more complexity,
+            // for our own sanity, let's just prevent dragging when this key is pressed
+            if (e.ctrlKey)
+                return;
+            e.preventDefault();
+            _this.emit('pointerdown', {
+                type: 'mouse',
+                position: _this.getCorrectPointerPosition(e),
+                button: e.button,
+                touchesCount: 0,
+            });
+        };
+        _this.handleTouchMove = function (e) {
+            _this.handleTouchPinchToZoomChange(e);
+            _this.emit('pointermove', {
+                type: 'touch',
+                position: _this.getCorrectPointerPosition(e),
+                button: 0,
+                touchesCount: e.touches.length,
+            });
+        };
+        _this.handleMouseMove = function (e) {
+            _this.updateMousePosition(e);
+        };
+        _this.handleGlobalTouchMove = function (e) {
+            _this.emit('globalpointermove', {
+                type: 'touch',
+                position: _this.getCorrectPointerPosition(e),
+                button: 0,
+                touchesCount: e.touches.length,
+            });
+        };
+        _this.handleGlobalMouseMove = function (e) {
+            _this.updateGlobalMousePosition(e);
+        };
+        _this.handleTouchPinchToZoomStart = function (e) {
+            var _a;
+            if (!e.touches || ((_a = e.touches) === null || _a === void 0 ? void 0 : _a.length) < 2)
+                return;
+            _this.state.pinchToZoomLastDistance = _this.calculateDistanceBetweenTouches(e.touches[0], e.touches[1]);
+        };
+        /**
+         * Handle the pinch to zoom scale calculation on touch devices, using the distance
+         * between the first 2 fingers on screen and the middle point between them as zoom center
+         */
+        _this.handleTouchPinchToZoomChange = function (e) {
+            var _a;
+            if (!e.touches || ((_a = e.touches) === null || _a === void 0 ? void 0 : _a.length) < 2)
+                return;
+            var distance = _this.calculateDistanceBetweenTouches(e.touches[0], e.touches[1]);
+            var middlePoint = _this.getCorrectPointerPosition(e);
+            var distanceDelta = distance - _this.state.pinchToZoomLastDistance;
+            var normalisedDelta = 1 + distanceDelta * 0.004;
+            _this.state.pinchToZoomLastDistance = distance;
+            // The pinch to zoom is triggered by the touchstart/touchmove/touched events, and the start/end events are emitted by the touchstart/end.
+            _this.emitZoomEvent(normalisedDelta, middlePoint);
+        };
+        _this.handleTouchEnd = function (e) {
+            var position = _this.getCorrectPointerPosition(e);
+            _this.emit('pointerup', {
+                position: position,
+                type: 'touch',
+                button: 0,
+                touchesCount: e.touches.length,
+            });
+        };
+        _this.handleMouseUp = function (e) {
+            _this.emit('pointerup', {
+                type: 'mouse',
+                position: _this.getCorrectPointerPosition(e),
+                button: e.button,
+                touchesCount: 0,
+            });
+        };
+        _this.debouncedUpdateMousePosition = debounce(_this.updateMousePosition, 40);
+        _this.debouncedUpdateGlobalMousePosition = debounce(_this.updateGlobalMousePosition, 40);
+        _this.handleMouseWheel = function (e) {
+            // Preventing the mousewheel by default when in the canvas,
+            // so we don't get unwanted scrolls, bounces, etc
+            e.preventDefault();
+            // crtlKey is true when the user is using pinch to zoom
+            // not very intuitive, but that's how chrome and firefox work.
+            // BUT, the keydown event for the ctrlKey won't be triggered when
+            // pinching to zoom, so we can track the key pressed and understand
+            // if the user is really pressing the key or pinching to zoom
+            var isPinchToZoom = e.ctrlKey && !_this.state.isCtrlPressed;
+            var isZooming = e.metaKey || isPinchToZoom || _this.state.isCtrlPressed;
+            // The mouse wheel event can be triggered only by a mouse like device,
+            // so we update only the mouse position, we ignore the touch.
+            // The emitted event is debounced, so we don't keep emitting mouse events at a high rate while scrolling.
+            // But also, it's common UX in apps/browsers that while the user scrolls, events are not triggered
+            _this.debouncedUpdateMousePosition(e);
+            _this.debouncedUpdateGlobalMousePosition(e);
+            if (isZooming) {
+                // When the user is pinching to zoom, the deltaY is inverted
+                var invert = isPinchToZoom || _this.invertedWheelZoom ? -1 : 1;
+                var center = _this.getCorrectPointerPosition(e);
+                var zoomDelta = 1 + e.deltaY * 0.005 * invert;
+                _this.emitZoomEvent(zoomDelta, center);
+            }
+            else {
+                _this.emit('wheel', 
+                /* delta */ {
+                    x: -e.deltaX,
+                    y: -e.deltaY,
+                }, 
+                /* pointerInfo */ {
+                    type: 'mouse',
+                    position: _this.getCorrectPointerPosition(e),
+                    button: e.button,
+                    touchesCount: 0,
+                });
+            }
+        };
+        _this.target = target;
+        _this.invertedWheelZoom = invertedWheelZoom;
+        _this.targetBounds = target.getBoundingClientRect();
+        _this.listenersCollector = new ListenersCollector(disabled);
+        _this.addListeners();
+        _this.targetResizeObserver = new ResizeObserver(_this.updateTargetBounds.bind(_this));
+        _this.targetResizeObserver.observe(_this.target);
+        return _this;
+    }
+    GestureManager.prototype.updateTargetBounds = function () {
+        this.targetBounds = this.target.getBoundingClientRect();
+    };
+    GestureManager.prototype.addListeners = function () {
+        this.addTouchEventListeners();
+        this.addMouseEventListeners();
+        this.addKeyboardEventListeners();
+        this.addSafariGesturesEventListeners();
+    };
+    GestureManager.prototype.addKeyboardEventListeners = function () {
+        var _this = this;
+        this.listenersCollector.add(document, 'keydown', function (e) {
+            // Tracking the CTRL key, so we can understand when it's really pressed or not.
+            // Chrome and firefox sets the Event.ctrlKey boolean to true when pinching to zoom, even if that's not true.
+            if (e.key === 'Control')
+                _this.state.isCtrlPressed = true;
+        });
+        this.listenersCollector.add(document, 'keyup', function (e) {
+            if (e.key === 'Control')
+                _this.state.isCtrlPressed = false;
+        });
+        this.listenersCollector.add(document, 'contextmenu', function (e) {
+            // On macOS, if the context menu was opened by using: CTRL + left click, the keyup event wouldn't be triggered
+            if (e.ctrlKey) {
+                _this.state.isCtrlPressed = false;
+            }
+        });
+    };
+    GestureManager.prototype.addMouseEventListeners = function () {
+        this.listenersCollector.add(this.target, 'mousedown', this.handleMouseDown);
+        this.listenersCollector.add(this.target, 'mousemove', this.handleMouseMove);
+        this.listenersCollector.add(document, 'mousemove', this.handleGlobalMouseMove);
+        // Attaching the mouseup listener to the document itself, so we never miss a mouseup event to invalidate a dragging session
+        this.listenersCollector.add(document, 'mouseup', this.handleMouseUp);
+        this.listenersCollector.add(this.target, 'wheel', this.handleMouseWheel);
+    };
+    GestureManager.prototype.addTouchEventListeners = function () {
+        this.listenersCollector.add(this.target, 'touchstart', this.handleTouchStart);
+        this.listenersCollector.add(document, 'touchmove', this.handleGlobalTouchMove, {
+            passive: true,
+            capture: true,
+        });
+        this.listenersCollector.add(this.target, 'touchmove', this.handleTouchMove, { passive: true, capture: true });
+        // Attaching to the document to never miss a touchcancel or touchend event
+        this.listenersCollector.add(document, 'touchcancel', this.handleTouchEnd);
+        this.listenersCollector.add(document, 'touchend', this.handleTouchEnd);
+    };
+    GestureManager.prototype.addSafariGesturesEventListeners = function () {
+        // Add the gesture listeners only for Safari Desktop
+        // These listeners are used for the pinch to zoom gesture
+        // and on touch devices, we use the touch events instead
+        if (isTouchDevice())
+            return;
+        this.listenersCollector.add(this.target, 'gesturestart', this.handleGestureStart, { capture: true });
+        this.listenersCollector.add(this.target, 'gesturechange', this.handleGestureChange, { capture: true });
+        this.listenersCollector.add(this.target, 'gestureend', this.handleGestureEnd, { capture: true });
+    };
+    GestureManager.prototype.clampPointerToTargetBounds = function (pointer) {
+        return {
+            x: pointer.x - this.targetBounds.x,
+            y: pointer.y - this.targetBounds.y,
+        };
+    };
+    /**
+     * Extract the pointer position from the event
+     * and makes sure that the pointer position is correct even if the target has margins
+     */
+    GestureManager.prototype.getCorrectPointerPosition = function (e) {
+        var _a;
+        var pointer = { x: 0, y: 0 };
+        // If there are multiple touches on the screen, we use the middle
+        // point between the first two touches as the pointer position,
+        // so panning while pinching to zoom works correctly, by using the point between the 2 fingers
+        if (((_a = e.touches) === null || _a === void 0 ? void 0 : _a.length) > 1) {
+            var touchEv = e;
+            var firstTouch = touchEv.touches[0];
+            var secTouch = touchEv.touches[1];
+            // Finding the middle point
+            pointer = {
+                x: (firstTouch.clientX + secTouch.clientX) / 2,
+                y: (firstTouch.clientY + secTouch.clientY) / 2,
+            };
+        }
+        else {
+            pointer = extractPointer(e);
+        }
+        return this.clampPointerToTargetBounds(pointer);
+    };
+    GestureManager.prototype.calculateDistanceBetweenTouches = function (firstTouch, secTouch) {
+        return Math.hypot(firstTouch.clientX - secTouch.clientX, firstTouch.clientY - secTouch.clientY);
+    };
+    GestureManager.prototype.emitZoomEvent = function (zoomDelta, zoomCenter) {
+        this.emit('pinchToZoom', zoomDelta, zoomCenter);
+    };
+    GestureManager.prototype.dispose = function () {
+        this.listenersCollector.dispose();
+        this.targetResizeObserver.disconnect();
+    };
+    GestureManager.prototype.setDisable = function (disable) {
+        this.listenersCollector.setDisabled(disable);
+    };
+    GestureManager.prototype.setInvertedWheelZoom = function (inverted) {
+        this.invertedWheelZoom = inverted;
+    };
+    return GestureManager;
+}(EventEmitter));
+
+/**
+ * A class to manage all kinds of keyboard events
+ * The class exposes a .dispose function that can be invoked when all the listeners should be detached
+ */
+var KeyboardManager = /** @class */ (function (_super) {
+    __extends(KeyboardManager, _super);
+    function KeyboardManager(target) {
+        var _this = _super.call(this) || this;
+        _this.listenersCollector = new ListenersCollector();
+        _this.handleKeyUp = function (e) {
+            _this.emit('keyUp', e.code);
+        };
+        _this.target = target;
+        _this.addListeners();
+        return _this;
+    }
+    KeyboardManager.prototype.addListeners = function () {
+        this.listenersCollector.add(this.target, 'keyup', this.handleKeyUp);
+    };
+    KeyboardManager.prototype.dispose = function () {
+        this.listenersCollector.dispose();
+    };
+    return KeyboardManager;
+}(EventEmitter));
+
+var Performance = /** @class */ (function () {
+    function Performance(label) {
+        this.label = label;
+        this.startTime = performance.now();
+        this.startTimestamp = Date.now();
+    }
+    Performance.prototype.measure = function () {
+        var duration = performance.now() - this.startTime;
+        return {
+            duration: duration,
+            end: Date.now(),
+            start: this.startTimestamp,
+            id: this.label,
+        };
+    };
+    Performance.prototype.printMeasurement = function () {
+        var duration = this.measure().duration;
+        if (duration < 1000) {
+            var formatted = duration.toFixed(2);
+            return "[Performance] ".concat(this.label, " -> ").concat(formatted, " ms");
+        }
+        else {
+            var seconds = (duration / 1000).toFixed(2);
+            return "[Performance] ".concat(this.label, " -> ").concat(seconds, " s");
+        }
+    };
+    return Performance;
+}());
+
+var Logger = /** @class */ (function (_super) {
+    __extends(Logger, _super);
+    function Logger() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Logger.prototype.logDebug = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.emit.apply(this, __spreadArray(['log', 'debug'], args, false));
+    };
+    Logger.prototype.logWarning = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.emit.apply(this, __spreadArray(['log', 'warn'], args, false));
+    };
+    Logger.prototype.logError = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        this.emit.apply(this, __spreadArray(['log', 'error'], args, false));
+    };
+    return Logger;
+}(EventEmitter));
+var logger = new Logger();
+
+/**
+ * This class responsibility is to initialise the WASM module created by emscripten,
+ * and provide utility functions to access the objects exposed through Embind, which are attached to the main wasm module
+ */
+var WasmModule = /** @class */ (function () {
+    function WasmModule(settings) {
+        this.settings = settings;
+    }
+    WasmModule.prototype.isReleaseMode = function () {
+        return this.settings.mode === WebRendererMode.release;
+    };
+    WasmModule.prototype.init = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var emscriptenJsModule, factory, _a, error_1;
+            var _b;
+            var _this = this;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this.importModule()];
+                    case 1:
+                        emscriptenJsModule = _c.sent();
+                        factory = emscriptenJsModule.default;
+                        _c.label = 2;
+                    case 2:
+                        _c.trys.push([2, 4, , 5]);
+                        _a = this;
+                        return [4 /*yield*/, factory({
+                                FeatureFlags: this.settings.featureFlags,
+                                currentWebGLVersion: this.settings.webglVersion,
+                                bridge: this.settings.jsBridge,
+                                locateFile: function (file) {
+                                    return _this.settings.locateFile.replace('{file}', file);
+                                },
+                            })];
+                    case 3:
+                        _a.instance = _c.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        error_1 = _c.sent();
+                        throw new WebRendererError('WASM_ERROR', 'An error occurred while trying to create the wasm module.', error_1);
+                    case 5:
+                        // Updating the pointer info map. We use it to convert Js pointer types to WASM
+                        this.pointerTypeToWASMMap = {
+                            unset: this.instance.PRUserPointerTypeEnum.Unset,
+                            mouse: this.instance.PRUserPointerTypeEnum.Mouse,
+                            touch: this.instance.PRUserPointerTypeEnum.Touch,
+                        };
+                        // Mapping the PRCursorType to the TS Enum
+                        this.prCursorTypeToCSSCursorMap = (_b = {},
+                            _b[this.instance.PRCursorTypeEnum.Auto.value] = "auto" /* CSSCursor.Auto */,
+                            _b[this.instance.PRCursorTypeEnum.Default.value] = "default" /* CSSCursor.Default */,
+                            _b[this.instance.PRCursorTypeEnum.Pointer.value] = "pointer" /* CSSCursor.Pointer */,
+                            _b[this.instance.PRCursorTypeEnum.Grab.value] = "grab" /* CSSCursor.Grab */,
+                            _b[this.instance.PRCursorTypeEnum.Grabbing.value] = "grabbing" /* CSSCursor.Grabbing */,
+                            _b);
+                        this.prototypeResizeModeToWASMMap = {
+                            Fit: this.instance.PrototypeResizeModeWasmEnum.Fit,
+                            FillWidth: this.instance.PrototypeResizeModeWasmEnum.FillWidth,
+                            ActualSize: this.instance.PrototypeResizeModeWasmEnum.ActualSize,
+                        };
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    WasmModule.prototype.makeWebGLContext = function (canvas, webGLContextAttributes) {
+        var _a;
+        if (webGLContextAttributes === void 0) { webGLContextAttributes = {}; }
+        var ctxSettings = __assign({ antialias: false, alpha: false, stencil: false, depth: false, powerPreference: 'high-performance', preserveDrawingBuffer: false, desynchronized: true }, webGLContextAttributes);
+        var ctxHandle = this.instance.GL.createContext(canvas, ctxSettings);
+        if (!ctxHandle) {
+            throw new WebRendererError('WEBGL_ERROR', 'Unable to create WebGL context. WebGL might be unsupported, disabled, or this device is not able to run WebGL correctly.');
+        }
+        var gl = (_a = this.instance.GL.getContext(ctxHandle)) === null || _a === void 0 ? void 0 : _a.GLctx;
+        if (gl) {
+            // Enabling the WEBGL_debug_renderer_info extension if available
+            // so that we can retrieve debug info about the GPU
+            // We do that using the detect-gpu npm package
+            gl.getExtension('WEBGL_debug_renderer_info');
+        }
+        return ctxHandle;
+    };
+    WasmModule.prototype.createWebGLTextureFromImage = function (image, webGLCtxHandle) {
+        var GL = this.instance.GL;
+        var ctxHandle = GL.getContext(webGLCtxHandle);
+        if (!ctxHandle) {
+            throw new Error('Unable to retrieve emscripten WebGL context from handle');
+        }
+        var ctx = ctxHandle.GLctx;
+        if (!ctx) {
+            throw new Error('WebGL context is null');
+        }
+        // First, create a WebGL texture
+        var texture = ctx.createTexture();
+        ctx.bindTexture(ctx.TEXTURE_2D, texture);
+        ctx.pixelStorei(ctx.UNPACK_PREMULTIPLY_ALPHA_WEBGL, true);
+        // Now we generate a texture id using emscripten
+        var textureHandle = GL.getNewId(GL.textures);
+        // Adding the texture into the correct slot
+        GL.textures[textureHandle] = texture;
+        // And finally, we upload the image to the texture
+        ctx.texImage2D(ctx.TEXTURE_2D, 0, ctx.RGBA, ctx.RGBA, ctx.UNSIGNED_BYTE, image);
+        // Unbinding the current texture, so that we don't accidentally modify it
+        ctx.bindTexture(ctx.TEXTURE_2D, null);
+        return textureHandle;
+    };
+    /**
+     * Forcefully releasing the WebGL context
+     */
+    WasmModule.prototype.destroyWebGLContext = function (webGLCtxHandle) {
+        var _a;
+        logger.logDebug('Destroying WebGL context');
+        var ctx = (_a = this.instance) === null || _a === void 0 ? void 0 : _a.GL.getContext(webGLCtxHandle);
+        if (!ctx) {
+            logger.logError('WebGL context not found while trying to destroy it');
+            return;
+        }
+        this.instance.GL.deleteContext(webGLCtxHandle);
+        var loseContextExt = ctx.GLctx.getExtension('WEBGL_lose_context');
+        if (!loseContextExt) {
+            logger.logError('WEBGL_lose_context not available. Not possible to destroy WebGL context manually.');
+            return;
+        }
+        loseContextExt.loseContext();
+        logger.logDebug('WebGL destroyed');
+        return true;
+    };
+    /**
+     * Imports the emscripten generated JavaScript using a dynamic import. By using
+     * a dynamic import the user only has to download the JS needed for their use
+     * case (debug or release), and not both. How the dynamic import is handled
+     * during the build is the responsibility of our bundler Rollup - the result is
+     * a bundle employing code splitting and dynamic chunk loading. As such there
+     * are implications for downstream build tools too, for example Webpack in
+     * cloud-frontend.
+     */
+    WasmModule.prototype.importModule = function () {
+        return this.isReleaseMode()
+            ? import('./web-renderer-release-988811bf.js')
+            : import('./web-renderer-debug-ceaf0a83.js');
+    };
+    WasmModule.prototype.mapToCSSCursor = function (prCursorType) {
+        return this.prCursorTypeToCSSCursorMap[prCursorType.value];
+    };
+    WasmModule.prototype.mapToPRPointerType = function (pointerType) {
+        var _a;
+        return ((_a = this.pointerTypeToWASMMap[pointerType]) !== null && _a !== void 0 ? _a : this.instance.PRUserPointerTypeEnum.Unset);
+    };
+    WasmModule.prototype.mapPointerInfo = function (pointerInfo) {
+        return __assign(__assign({}, pointerInfo), { type: this.mapToPRPointerType(pointerInfo.type) });
+    };
+    WasmModule.prototype.mapResizeMode = function (resizeMode) {
+        return this.prototypeResizeModeToWASMMap[resizeMode];
+    };
+    return WasmModule;
+}());
+
+export { DefaultFeatureFlags as D, EventEmitter as E, GestureManager as G, KeyboardManager as K, ListenersCollector as L, Performance as P, WebRendererMode as W, __extends as _, __awaiter as a, __generator as b, clamp as c, debounce as d, convertEmbindVectorToArray as e, WebRendererError as f, getSupportedWebGLVersion as g, __assign as h, WasmModule as i, __spreadArray as j, PrototypeResizeMode as k, logger as l, extractPointer as m, isTouchDevice as n, getiOSVersion as o, parseSafariUserAgent as p, removeUndefinedKeys as r, safePtrAccess as s, touchableClick as t };