1

bourse_app/node_modules/fancy-canvas/canvas-element-bitmap-size.d.mts

@@ -0,0 +1,35 @@
+import Disposable from "./disposable.mjs";
+import { Size } from "./size.mjs";
+export declare type BitmapSizeChangedListener = (this: Binding, oldSize: Size, newSize: Size) => void;
+export declare type BitmapSizeTransformer = (bitmapSize: Size, canvasElementClientSize: Size) => {
+    width: number;
+    height: number;
+};
+export declare type SuggestedBitmapSizeChangedListener = (this: Binding, oldSize: Size | null, newSize: Size | null) => void;
+export interface Binding extends Disposable {
+    readonly canvasElement: HTMLCanvasElement;
+    /**
+     * Canvas element client size in CSS pixels
+     */
+    readonly canvasElementClientSize: Size;
+    resizeCanvasElement(clientSize: {
+        width: number;
+        height: number;
+    }): void;
+    readonly bitmapSize: Size;
+    subscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
+    unsubscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
+    readonly suggestedBitmapSize: Size | null;
+    subscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
+    unsubscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
+    applySuggestedBitmapSize(): void;
+}
+export interface DevicePixelContentBoxBindingTargetOptions {
+    allowResizeObserver?: boolean;
+}
+export declare type BindingTarget = {
+    type: 'device-pixel-content-box';
+    transform?: BitmapSizeTransformer;
+    options?: DevicePixelContentBoxBindingTargetOptions;
+};
+export declare function bindTo(canvasElement: HTMLCanvasElement, target: BindingTarget): Binding;

bourse_app/node_modules/fancy-canvas/canvas-element-bitmap-size.d.ts

@@ -0,0 +1,35 @@
+import Disposable from './disposable.js';
+import { Size } from './size.js';
+export declare type BitmapSizeChangedListener = (this: Binding, oldSize: Size, newSize: Size) => void;
+export declare type BitmapSizeTransformer = (bitmapSize: Size, canvasElementClientSize: Size) => {
+    width: number;
+    height: number;
+};
+export declare type SuggestedBitmapSizeChangedListener = (this: Binding, oldSize: Size | null, newSize: Size | null) => void;
+export interface Binding extends Disposable {
+    readonly canvasElement: HTMLCanvasElement;
+    /**
+     * Canvas element client size in CSS pixels
+     */
+    readonly canvasElementClientSize: Size;
+    resizeCanvasElement(clientSize: {
+        width: number;
+        height: number;
+    }): void;
+    readonly bitmapSize: Size;
+    subscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
+    unsubscribeBitmapSizeChanged(listener: BitmapSizeChangedListener): void;
+    readonly suggestedBitmapSize: Size | null;
+    subscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
+    unsubscribeSuggestedBitmapSizeChanged(listener: SuggestedBitmapSizeChangedListener): void;
+    applySuggestedBitmapSize(): void;
+}
+export interface DevicePixelContentBoxBindingTargetOptions {
+    allowResizeObserver?: boolean;
+}
+export declare type BindingTarget = {
+    type: 'device-pixel-content-box';
+    transform?: BitmapSizeTransformer;
+    options?: DevicePixelContentBoxBindingTargetOptions;
+};
+export declare function bindTo(canvasElement: HTMLCanvasElement, target: BindingTarget): Binding;

bourse_app/node_modules/fancy-canvas/canvas-element-bitmap-size.js

@@ -0,0 +1,240 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bindTo = void 0;
+var size_js_1 = require("./size.js");
+var device_pixel_ratio_js_1 = require("./device-pixel-ratio.js");
+var DevicePixelContentBoxBinding = /** @class */ (function () {
+    function DevicePixelContentBoxBinding(canvasElement, transformBitmapSize, options) {
+        var _a;
+        this._canvasElement = null;
+        this._bitmapSizeChangedListeners = [];
+        this._suggestedBitmapSize = null;
+        this._suggestedBitmapSizeChangedListeners = [];
+        // devicePixelRatio approach
+        this._devicePixelRatioObservable = null;
+        // ResizeObserver approach
+        this._canvasElementResizeObserver = null;
+        this._canvasElement = canvasElement;
+        this._canvasElementClientSize = (0, size_js_1.size)({
+            width: this._canvasElement.clientWidth,
+            height: this._canvasElement.clientHeight,
+        });
+        this._transformBitmapSize = transformBitmapSize !== null && transformBitmapSize !== void 0 ? transformBitmapSize : (function (size) { return size; });
+        this._allowResizeObserver = (_a = options === null || options === void 0 ? void 0 : options.allowResizeObserver) !== null && _a !== void 0 ? _a : true;
+        this._chooseAndInitObserver();
+        // we MAY leave the constuctor without any bitmap size observation mechanics initialized
+    }
+    DevicePixelContentBoxBinding.prototype.dispose = function () {
+        var _a, _b;
+        if (this._canvasElement === null) {
+            throw new Error('Object is disposed');
+        }
+        (_a = this._canvasElementResizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this._canvasElementResizeObserver = null;
+        (_b = this._devicePixelRatioObservable) === null || _b === void 0 ? void 0 : _b.dispose();
+        this._devicePixelRatioObservable = null;
+        this._suggestedBitmapSizeChangedListeners.length = 0;
+        this._bitmapSizeChangedListeners.length = 0;
+        this._canvasElement = null;
+    };
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElement", {
+        get: function () {
+            if (this._canvasElement === null) {
+                throw new Error('Object is disposed');
+            }
+            return this._canvasElement;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElementClientSize", {
+        get: function () {
+            return this._canvasElementClientSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "bitmapSize", {
+        get: function () {
+            return (0, size_js_1.size)({
+                width: this.canvasElement.width,
+                height: this.canvasElement.height,
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Use this function to change canvas element client size until binding is disposed
+     * @param clientSize New client size for bound HTMLCanvasElement
+     */
+    DevicePixelContentBoxBinding.prototype.resizeCanvasElement = function (clientSize) {
+        this._canvasElementClientSize = (0, size_js_1.size)(clientSize);
+        this.canvasElement.style.width = "".concat(this._canvasElementClientSize.width, "px");
+        this.canvasElement.style.height = "".concat(this._canvasElementClientSize.height, "px");
+        this._invalidateBitmapSize();
+    };
+    DevicePixelContentBoxBinding.prototype.subscribeBitmapSizeChanged = function (listener) {
+        this._bitmapSizeChangedListeners.push(listener);
+    };
+    DevicePixelContentBoxBinding.prototype.unsubscribeBitmapSizeChanged = function (listener) {
+        this._bitmapSizeChangedListeners = this._bitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
+    };
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "suggestedBitmapSize", {
+        get: function () {
+            return this._suggestedBitmapSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DevicePixelContentBoxBinding.prototype.subscribeSuggestedBitmapSizeChanged = function (listener) {
+        this._suggestedBitmapSizeChangedListeners.push(listener);
+    };
+    DevicePixelContentBoxBinding.prototype.unsubscribeSuggestedBitmapSizeChanged = function (listener) {
+        this._suggestedBitmapSizeChangedListeners = this._suggestedBitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
+    };
+    DevicePixelContentBoxBinding.prototype.applySuggestedBitmapSize = function () {
+        if (this._suggestedBitmapSize === null) {
+            // nothing to apply
+            return;
+        }
+        var oldSuggestedSize = this._suggestedBitmapSize;
+        this._suggestedBitmapSize = null;
+        this._resizeBitmap(oldSuggestedSize);
+        this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, this._suggestedBitmapSize);
+    };
+    DevicePixelContentBoxBinding.prototype._resizeBitmap = function (newSize) {
+        var oldSize = this.bitmapSize;
+        if ((0, size_js_1.equalSizes)(oldSize, newSize)) {
+            return;
+        }
+        this.canvasElement.width = newSize.width;
+        this.canvasElement.height = newSize.height;
+        this._emitBitmapSizeChanged(oldSize, newSize);
+    };
+    DevicePixelContentBoxBinding.prototype._emitBitmapSizeChanged = function (oldSize, newSize) {
+        var _this = this;
+        this._bitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
+    };
+    DevicePixelContentBoxBinding.prototype._suggestNewBitmapSize = function (newSize) {
+        var oldSuggestedSize = this._suggestedBitmapSize;
+        var finalNewSize = (0, size_js_1.size)(this._transformBitmapSize(newSize, this._canvasElementClientSize));
+        var newSuggestedSize = (0, size_js_1.equalSizes)(this.bitmapSize, finalNewSize) ? null : finalNewSize;
+        if (oldSuggestedSize === null && newSuggestedSize === null) {
+            return;
+        }
+        if (oldSuggestedSize !== null && newSuggestedSize !== null
+            && (0, size_js_1.equalSizes)(oldSuggestedSize, newSuggestedSize)) {
+            return;
+        }
+        this._suggestedBitmapSize = newSuggestedSize;
+        this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, newSuggestedSize);
+    };
+    DevicePixelContentBoxBinding.prototype._emitSuggestedBitmapSizeChanged = function (oldSize, newSize) {
+        var _this = this;
+        this._suggestedBitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
+    };
+    DevicePixelContentBoxBinding.prototype._chooseAndInitObserver = function () {
+        var _this = this;
+        if (!this._allowResizeObserver) {
+            this._initDevicePixelRatioObservable();
+            return;
+        }
+        isDevicePixelContentBoxSupported()
+            .then(function (isSupported) {
+            return isSupported ?
+                _this._initResizeObserver() :
+                _this._initDevicePixelRatioObservable();
+        });
+    };
+    // devicePixelRatio approach
+    DevicePixelContentBoxBinding.prototype._initDevicePixelRatioObservable = function () {
+        var _this = this;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        var win = canvasElementWindow(this._canvasElement);
+        if (win === null) {
+            throw new Error('No window is associated with the canvas');
+        }
+        this._devicePixelRatioObservable = (0, device_pixel_ratio_js_1.createObservable)(win);
+        this._devicePixelRatioObservable.subscribe(function () { return _this._invalidateBitmapSize(); });
+        this._invalidateBitmapSize();
+    };
+    DevicePixelContentBoxBinding.prototype._invalidateBitmapSize = function () {
+        var _a, _b;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        var win = canvasElementWindow(this._canvasElement);
+        if (win === null) {
+            return;
+        }
+        var ratio = (_b = (_a = this._devicePixelRatioObservable) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : win.devicePixelRatio;
+        var canvasRects = this._canvasElement.getClientRects();
+        var newSize = 
+        // eslint-disable-next-line no-negated-condition
+        canvasRects[0] !== undefined ?
+            predictedBitmapSize(canvasRects[0], ratio) :
+            (0, size_js_1.size)({
+                width: this._canvasElementClientSize.width * ratio,
+                height: this._canvasElementClientSize.height * ratio,
+            });
+        this._suggestNewBitmapSize(newSize);
+    };
+    // ResizeObserver approach
+    DevicePixelContentBoxBinding.prototype._initResizeObserver = function () {
+        var _this = this;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        this._canvasElementResizeObserver = new ResizeObserver(function (entries) {
+            var entry = entries.find(function (entry) { return entry.target === _this._canvasElement; });
+            if (!entry || !entry.devicePixelContentBoxSize || !entry.devicePixelContentBoxSize[0]) {
+                return;
+            }
+            var entrySize = entry.devicePixelContentBoxSize[0];
+            var newSize = (0, size_js_1.size)({
+                width: entrySize.inlineSize,
+                height: entrySize.blockSize,
+            });
+            _this._suggestNewBitmapSize(newSize);
+        });
+        this._canvasElementResizeObserver.observe(this._canvasElement, { box: 'device-pixel-content-box' });
+    };
+    return DevicePixelContentBoxBinding;
+}());
+function bindTo(canvasElement, target) {
+    if (target.type === 'device-pixel-content-box') {
+        return new DevicePixelContentBoxBinding(canvasElement, target.transform, target.options);
+    }
+    throw new Error('Unsupported binding target');
+}
+exports.bindTo = bindTo;
+function canvasElementWindow(canvasElement) {
+    // According to DOM Level 2 Core specification, ownerDocument should never be null for HTMLCanvasElement
+    // see https://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#node-ownerDoc
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return canvasElement.ownerDocument.defaultView;
+}
+function isDevicePixelContentBoxSupported() {
+    return new Promise(function (resolve) {
+        var ro = new ResizeObserver(function (entries) {
+            resolve(entries.every(function (entry) { return 'devicePixelContentBoxSize' in entry; }));
+            ro.disconnect();
+        });
+        ro.observe(document.body, { box: 'device-pixel-content-box' });
+    })
+        .catch(function () { return false; });
+}
+function predictedBitmapSize(canvasRect, ratio) {
+    return (0, size_js_1.size)({
+        width: Math.round(canvasRect.left * ratio + canvasRect.width * ratio) -
+            Math.round(canvasRect.left * ratio),
+        height: Math.round(canvasRect.top * ratio + canvasRect.height * ratio) -
+            Math.round(canvasRect.top * ratio),
+    });
+}

bourse_app/node_modules/fancy-canvas/canvas-element-bitmap-size.mjs

@@ -0,0 +1,236 @@
+import { equalSizes, size } from "./size.mjs";
+import { createObservable as createDevicePixelRatioObservable } from "./device-pixel-ratio.mjs";
+var DevicePixelContentBoxBinding = /** @class */ (function () {
+    function DevicePixelContentBoxBinding(canvasElement, transformBitmapSize, options) {
+        var _a;
+        this._canvasElement = null;
+        this._bitmapSizeChangedListeners = [];
+        this._suggestedBitmapSize = null;
+        this._suggestedBitmapSizeChangedListeners = [];
+        // devicePixelRatio approach
+        this._devicePixelRatioObservable = null;
+        // ResizeObserver approach
+        this._canvasElementResizeObserver = null;
+        this._canvasElement = canvasElement;
+        this._canvasElementClientSize = size({
+            width: this._canvasElement.clientWidth,
+            height: this._canvasElement.clientHeight,
+        });
+        this._transformBitmapSize = transformBitmapSize !== null && transformBitmapSize !== void 0 ? transformBitmapSize : (function (size) { return size; });
+        this._allowResizeObserver = (_a = options === null || options === void 0 ? void 0 : options.allowResizeObserver) !== null && _a !== void 0 ? _a : true;
+        this._chooseAndInitObserver();
+        // we MAY leave the constuctor without any bitmap size observation mechanics initialized
+    }
+    DevicePixelContentBoxBinding.prototype.dispose = function () {
+        var _a, _b;
+        if (this._canvasElement === null) {
+            throw new Error('Object is disposed');
+        }
+        (_a = this._canvasElementResizeObserver) === null || _a === void 0 ? void 0 : _a.disconnect();
+        this._canvasElementResizeObserver = null;
+        (_b = this._devicePixelRatioObservable) === null || _b === void 0 ? void 0 : _b.dispose();
+        this._devicePixelRatioObservable = null;
+        this._suggestedBitmapSizeChangedListeners.length = 0;
+        this._bitmapSizeChangedListeners.length = 0;
+        this._canvasElement = null;
+    };
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElement", {
+        get: function () {
+            if (this._canvasElement === null) {
+                throw new Error('Object is disposed');
+            }
+            return this._canvasElement;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "canvasElementClientSize", {
+        get: function () {
+            return this._canvasElementClientSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "bitmapSize", {
+        get: function () {
+            return size({
+                width: this.canvasElement.width,
+                height: this.canvasElement.height,
+            });
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Use this function to change canvas element client size until binding is disposed
+     * @param clientSize New client size for bound HTMLCanvasElement
+     */
+    DevicePixelContentBoxBinding.prototype.resizeCanvasElement = function (clientSize) {
+        this._canvasElementClientSize = size(clientSize);
+        this.canvasElement.style.width = "".concat(this._canvasElementClientSize.width, "px");
+        this.canvasElement.style.height = "".concat(this._canvasElementClientSize.height, "px");
+        this._invalidateBitmapSize();
+    };
+    DevicePixelContentBoxBinding.prototype.subscribeBitmapSizeChanged = function (listener) {
+        this._bitmapSizeChangedListeners.push(listener);
+    };
+    DevicePixelContentBoxBinding.prototype.unsubscribeBitmapSizeChanged = function (listener) {
+        this._bitmapSizeChangedListeners = this._bitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
+    };
+    Object.defineProperty(DevicePixelContentBoxBinding.prototype, "suggestedBitmapSize", {
+        get: function () {
+            return this._suggestedBitmapSize;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    DevicePixelContentBoxBinding.prototype.subscribeSuggestedBitmapSizeChanged = function (listener) {
+        this._suggestedBitmapSizeChangedListeners.push(listener);
+    };
+    DevicePixelContentBoxBinding.prototype.unsubscribeSuggestedBitmapSizeChanged = function (listener) {
+        this._suggestedBitmapSizeChangedListeners = this._suggestedBitmapSizeChangedListeners.filter(function (l) { return l !== listener; });
+    };
+    DevicePixelContentBoxBinding.prototype.applySuggestedBitmapSize = function () {
+        if (this._suggestedBitmapSize === null) {
+            // nothing to apply
+            return;
+        }
+        var oldSuggestedSize = this._suggestedBitmapSize;
+        this._suggestedBitmapSize = null;
+        this._resizeBitmap(oldSuggestedSize);
+        this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, this._suggestedBitmapSize);
+    };
+    DevicePixelContentBoxBinding.prototype._resizeBitmap = function (newSize) {
+        var oldSize = this.bitmapSize;
+        if (equalSizes(oldSize, newSize)) {
+            return;
+        }
+        this.canvasElement.width = newSize.width;
+        this.canvasElement.height = newSize.height;
+        this._emitBitmapSizeChanged(oldSize, newSize);
+    };
+    DevicePixelContentBoxBinding.prototype._emitBitmapSizeChanged = function (oldSize, newSize) {
+        var _this = this;
+        this._bitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
+    };
+    DevicePixelContentBoxBinding.prototype._suggestNewBitmapSize = function (newSize) {
+        var oldSuggestedSize = this._suggestedBitmapSize;
+        var finalNewSize = size(this._transformBitmapSize(newSize, this._canvasElementClientSize));
+        var newSuggestedSize = equalSizes(this.bitmapSize, finalNewSize) ? null : finalNewSize;
+        if (oldSuggestedSize === null && newSuggestedSize === null) {
+            return;
+        }
+        if (oldSuggestedSize !== null && newSuggestedSize !== null
+            && equalSizes(oldSuggestedSize, newSuggestedSize)) {
+            return;
+        }
+        this._suggestedBitmapSize = newSuggestedSize;
+        this._emitSuggestedBitmapSizeChanged(oldSuggestedSize, newSuggestedSize);
+    };
+    DevicePixelContentBoxBinding.prototype._emitSuggestedBitmapSizeChanged = function (oldSize, newSize) {
+        var _this = this;
+        this._suggestedBitmapSizeChangedListeners.forEach(function (listener) { return listener.call(_this, oldSize, newSize); });
+    };
+    DevicePixelContentBoxBinding.prototype._chooseAndInitObserver = function () {
+        var _this = this;
+        if (!this._allowResizeObserver) {
+            this._initDevicePixelRatioObservable();
+            return;
+        }
+        isDevicePixelContentBoxSupported()
+            .then(function (isSupported) {
+            return isSupported ?
+                _this._initResizeObserver() :
+                _this._initDevicePixelRatioObservable();
+        });
+    };
+    // devicePixelRatio approach
+    DevicePixelContentBoxBinding.prototype._initDevicePixelRatioObservable = function () {
+        var _this = this;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        var win = canvasElementWindow(this._canvasElement);
+        if (win === null) {
+            throw new Error('No window is associated with the canvas');
+        }
+        this._devicePixelRatioObservable = createDevicePixelRatioObservable(win);
+        this._devicePixelRatioObservable.subscribe(function () { return _this._invalidateBitmapSize(); });
+        this._invalidateBitmapSize();
+    };
+    DevicePixelContentBoxBinding.prototype._invalidateBitmapSize = function () {
+        var _a, _b;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        var win = canvasElementWindow(this._canvasElement);
+        if (win === null) {
+            return;
+        }
+        var ratio = (_b = (_a = this._devicePixelRatioObservable) === null || _a === void 0 ? void 0 : _a.value) !== null && _b !== void 0 ? _b : win.devicePixelRatio;
+        var canvasRects = this._canvasElement.getClientRects();
+        var newSize = 
+        // eslint-disable-next-line no-negated-condition
+        canvasRects[0] !== undefined ?
+            predictedBitmapSize(canvasRects[0], ratio) :
+            size({
+                width: this._canvasElementClientSize.width * ratio,
+                height: this._canvasElementClientSize.height * ratio,
+            });
+        this._suggestNewBitmapSize(newSize);
+    };
+    // ResizeObserver approach
+    DevicePixelContentBoxBinding.prototype._initResizeObserver = function () {
+        var _this = this;
+        if (this._canvasElement === null) {
+            // it looks like we are already dead
+            return;
+        }
+        this._canvasElementResizeObserver = new ResizeObserver(function (entries) {
+            var entry = entries.find(function (entry) { return entry.target === _this._canvasElement; });
+            if (!entry || !entry.devicePixelContentBoxSize || !entry.devicePixelContentBoxSize[0]) {
+                return;
+            }
+            var entrySize = entry.devicePixelContentBoxSize[0];
+            var newSize = size({
+                width: entrySize.inlineSize,
+                height: entrySize.blockSize,
+            });
+            _this._suggestNewBitmapSize(newSize);
+        });
+        this._canvasElementResizeObserver.observe(this._canvasElement, { box: 'device-pixel-content-box' });
+    };
+    return DevicePixelContentBoxBinding;
+}());
+export function bindTo(canvasElement, target) {
+    if (target.type === 'device-pixel-content-box') {
+        return new DevicePixelContentBoxBinding(canvasElement, target.transform, target.options);
+    }
+    throw new Error('Unsupported binding target');
+}
+function canvasElementWindow(canvasElement) {
+    // According to DOM Level 2 Core specification, ownerDocument should never be null for HTMLCanvasElement
+    // see https://www.w3.org/TR/2000/REC-DOM-Level-2-Core-20001113/core.html#node-ownerDoc
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return canvasElement.ownerDocument.defaultView;
+}
+function isDevicePixelContentBoxSupported() {
+    return new Promise(function (resolve) {
+        var ro = new ResizeObserver(function (entries) {
+            resolve(entries.every(function (entry) { return 'devicePixelContentBoxSize' in entry; }));
+            ro.disconnect();
+        });
+        ro.observe(document.body, { box: 'device-pixel-content-box' });
+    })
+        .catch(function () { return false; });
+}
+function predictedBitmapSize(canvasRect, ratio) {
+    return size({
+        width: Math.round(canvasRect.left * ratio + canvasRect.width * ratio) -
+            Math.round(canvasRect.left * ratio),
+        height: Math.round(canvasRect.top * ratio + canvasRect.height * ratio) -
+            Math.round(canvasRect.top * ratio),
+    });
+}

bourse_app/node_modules/fancy-canvas/canvas-rendering-target.d.mts

@@ -0,0 +1,40 @@
+import { Size } from "./size.mjs";
+import { Binding as CanvasElementBitmapSizeBinding } from "./canvas-element-bitmap-size.mjs";
+/**
+ * @experimental
+ */
+export interface MediaCoordinatesRenderingScope {
+    readonly context: CanvasRenderingContext2D;
+    readonly mediaSize: Size;
+}
+/**
+ * @experimental
+ */
+export interface BitmapCoordinatesRenderingScope {
+    readonly context: CanvasRenderingContext2D;
+    readonly mediaSize: Size;
+    readonly bitmapSize: Size;
+    readonly horizontalPixelRatio: number;
+    readonly verticalPixelRatio: number;
+}
+/**
+ * @experimental
+ */
+export declare class CanvasRenderingTarget2D {
+    private readonly _context;
+    private readonly _mediaSize;
+    private readonly _bitmapSize;
+    constructor(context: CanvasRenderingContext2D, mediaSize: Size, bitmapSize: Size);
+    useMediaCoordinateSpace<T>(f: (scope: MediaCoordinatesRenderingScope) => T): T;
+    useBitmapCoordinateSpace<T>(f: (scope: BitmapCoordinatesRenderingScope) => T): T;
+    private get _horizontalPixelRatio();
+    private get _verticalPixelRatio();
+}
+/**
+ * @experimental
+ */
+export declare function createCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D;
+/**
+ * @experimental
+ */
+export declare function tryCreateCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D | null;

bourse_app/node_modules/fancy-canvas/canvas-rendering-target.d.ts

@@ -0,0 +1,40 @@
+import { Size } from './size.js';
+import { Binding as CanvasElementBitmapSizeBinding } from './canvas-element-bitmap-size.js';
+/**
+ * @experimental
+ */
+export interface MediaCoordinatesRenderingScope {
+    readonly context: CanvasRenderingContext2D;
+    readonly mediaSize: Size;
+}
+/**
+ * @experimental
+ */
+export interface BitmapCoordinatesRenderingScope {
+    readonly context: CanvasRenderingContext2D;
+    readonly mediaSize: Size;
+    readonly bitmapSize: Size;
+    readonly horizontalPixelRatio: number;
+    readonly verticalPixelRatio: number;
+}
+/**
+ * @experimental
+ */
+export declare class CanvasRenderingTarget2D {
+    private readonly _context;
+    private readonly _mediaSize;
+    private readonly _bitmapSize;
+    constructor(context: CanvasRenderingContext2D, mediaSize: Size, bitmapSize: Size);
+    useMediaCoordinateSpace<T>(f: (scope: MediaCoordinatesRenderingScope) => T): T;
+    useBitmapCoordinateSpace<T>(f: (scope: BitmapCoordinatesRenderingScope) => T): T;
+    private get _horizontalPixelRatio();
+    private get _verticalPixelRatio();
+}
+/**
+ * @experimental
+ */
+export declare function createCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D;
+/**
+ * @experimental
+ */
+export declare function tryCreateCanvasRenderingTarget2D(binding: CanvasElementBitmapSizeBinding, contextOptions?: CanvasRenderingContext2DSettings): CanvasRenderingTarget2D | null;

bourse_app/node_modules/fancy-canvas/canvas-rendering-target.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCreateCanvasRenderingTarget2D = exports.createCanvasRenderingTarget2D = exports.CanvasRenderingTarget2D = void 0;
+/**
+ * @experimental
+ */
+var CanvasRenderingTarget2D = /** @class */ (function () {
+    function CanvasRenderingTarget2D(context, mediaSize, bitmapSize) {
+        if (mediaSize.width === 0 || mediaSize.height === 0) {
+            throw new TypeError('Rendering target could only be created on a media with positive width and height');
+        }
+        this._mediaSize = mediaSize;
+        // !Number.isInteger(bitmapSize.width) || !Number.isInteger(bitmapSize.height)
+        if (bitmapSize.width === 0 || bitmapSize.height === 0) {
+            throw new TypeError('Rendering target could only be created using a bitmap with positive integer width and height');
+        }
+        this._bitmapSize = bitmapSize;
+        this._context = context;
+    }
+    CanvasRenderingTarget2D.prototype.useMediaCoordinateSpace = function (f) {
+        try {
+            this._context.save();
+            // do not use resetTransform to support old versions of Edge
+            this._context.setTransform(1, 0, 0, 1, 0, 0);
+            this._context.scale(this._horizontalPixelRatio, this._verticalPixelRatio);
+            return f({
+                context: this._context,
+                mediaSize: this._mediaSize,
+            });
+        }
+        finally {
+            this._context.restore();
+        }
+    };
+    CanvasRenderingTarget2D.prototype.useBitmapCoordinateSpace = function (f) {
+        try {
+            this._context.save();
+            // do not use resetTransform to support old versions of Edge
+            this._context.setTransform(1, 0, 0, 1, 0, 0);
+            return f({
+                context: this._context,
+                mediaSize: this._mediaSize,
+                bitmapSize: this._bitmapSize,
+                horizontalPixelRatio: this._horizontalPixelRatio,
+                verticalPixelRatio: this._verticalPixelRatio,
+            });
+        }
+        finally {
+            this._context.restore();
+        }
+    };
+    Object.defineProperty(CanvasRenderingTarget2D.prototype, "_horizontalPixelRatio", {
+        get: function () {
+            return this._bitmapSize.width / this._mediaSize.width;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CanvasRenderingTarget2D.prototype, "_verticalPixelRatio", {
+        get: function () {
+            return this._bitmapSize.height / this._mediaSize.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CanvasRenderingTarget2D;
+}());
+exports.CanvasRenderingTarget2D = CanvasRenderingTarget2D;
+/**
+ * @experimental
+ */
+function createCanvasRenderingTarget2D(binding, contextOptions) {
+    var mediaSize = binding.canvasElementClientSize;
+    var bitmapSize = binding.bitmapSize;
+    var context = binding.canvasElement.getContext('2d', contextOptions);
+    if (context === null) {
+        throw new Error('Could not get 2d drawing context from bound canvas element. Has the canvas already been set to a different context mode?');
+    }
+    return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
+}
+exports.createCanvasRenderingTarget2D = createCanvasRenderingTarget2D;
+/**
+ * @experimental
+ */
+function tryCreateCanvasRenderingTarget2D(binding, contextOptions) {
+    var mediaSize = binding.canvasElementClientSize;
+    if (mediaSize.width === 0 || mediaSize.height === 0) {
+        return null;
+    }
+    var bitmapSize = binding.bitmapSize;
+    if (bitmapSize.width === 0 || bitmapSize.height === 0) {
+        return null;
+    }
+    var context = binding.canvasElement.getContext('2d', contextOptions);
+    if (context === null) {
+        return null;
+    }
+    return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
+}
+exports.tryCreateCanvasRenderingTarget2D = tryCreateCanvasRenderingTarget2D;

bourse_app/node_modules/fancy-canvas/canvas-rendering-target.mjs

@@ -0,0 +1,95 @@
+/**
+ * @experimental
+ */
+var CanvasRenderingTarget2D = /** @class */ (function () {
+    function CanvasRenderingTarget2D(context, mediaSize, bitmapSize) {
+        if (mediaSize.width === 0 || mediaSize.height === 0) {
+            throw new TypeError('Rendering target could only be created on a media with positive width and height');
+        }
+        this._mediaSize = mediaSize;
+        // !Number.isInteger(bitmapSize.width) || !Number.isInteger(bitmapSize.height)
+        if (bitmapSize.width === 0 || bitmapSize.height === 0) {
+            throw new TypeError('Rendering target could only be created using a bitmap with positive integer width and height');
+        }
+        this._bitmapSize = bitmapSize;
+        this._context = context;
+    }
+    CanvasRenderingTarget2D.prototype.useMediaCoordinateSpace = function (f) {
+        try {
+            this._context.save();
+            // do not use resetTransform to support old versions of Edge
+            this._context.setTransform(1, 0, 0, 1, 0, 0);
+            this._context.scale(this._horizontalPixelRatio, this._verticalPixelRatio);
+            return f({
+                context: this._context,
+                mediaSize: this._mediaSize,
+            });
+        }
+        finally {
+            this._context.restore();
+        }
+    };
+    CanvasRenderingTarget2D.prototype.useBitmapCoordinateSpace = function (f) {
+        try {
+            this._context.save();
+            // do not use resetTransform to support old versions of Edge
+            this._context.setTransform(1, 0, 0, 1, 0, 0);
+            return f({
+                context: this._context,
+                mediaSize: this._mediaSize,
+                bitmapSize: this._bitmapSize,
+                horizontalPixelRatio: this._horizontalPixelRatio,
+                verticalPixelRatio: this._verticalPixelRatio,
+            });
+        }
+        finally {
+            this._context.restore();
+        }
+    };
+    Object.defineProperty(CanvasRenderingTarget2D.prototype, "_horizontalPixelRatio", {
+        get: function () {
+            return this._bitmapSize.width / this._mediaSize.width;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(CanvasRenderingTarget2D.prototype, "_verticalPixelRatio", {
+        get: function () {
+            return this._bitmapSize.height / this._mediaSize.height;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return CanvasRenderingTarget2D;
+}());
+export { CanvasRenderingTarget2D };
+/**
+ * @experimental
+ */
+export function createCanvasRenderingTarget2D(binding, contextOptions) {
+    var mediaSize = binding.canvasElementClientSize;
+    var bitmapSize = binding.bitmapSize;
+    var context = binding.canvasElement.getContext('2d', contextOptions);
+    if (context === null) {
+        throw new Error('Could not get 2d drawing context from bound canvas element. Has the canvas already been set to a different context mode?');
+    }
+    return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
+}
+/**
+ * @experimental
+ */
+export function tryCreateCanvasRenderingTarget2D(binding, contextOptions) {
+    var mediaSize = binding.canvasElementClientSize;
+    if (mediaSize.width === 0 || mediaSize.height === 0) {
+        return null;
+    }
+    var bitmapSize = binding.bitmapSize;
+    if (bitmapSize.width === 0 || bitmapSize.height === 0) {
+        return null;
+    }
+    var context = binding.canvasElement.getContext('2d', contextOptions);
+    if (context === null) {
+        return null;
+    }
+    return new CanvasRenderingTarget2D(context, mediaSize, bitmapSize);
+}

bourse_app/node_modules/fancy-canvas/device-pixel-ratio.d.mts

@@ -0,0 +1,3 @@
+import Disposable from "./disposable.mjs";
+import { BehaviorSubject } from "./rx.mjs";
+export declare function createObservable(win: Window): BehaviorSubject<number> & Disposable;

bourse_app/node_modules/fancy-canvas/device-pixel-ratio.d.ts

@@ -0,0 +1,3 @@
+import Disposable from './disposable.js';
+import { BehaviorSubject } from './rx.js';
+export declare function createObservable(win: Window): BehaviorSubject<number> & Disposable;

bourse_app/node_modules/fancy-canvas/device-pixel-ratio.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createObservable = void 0;
+var Observable = /** @class */ (function () {
+    function Observable(win) {
+        var _this = this;
+        this._resolutionListener = function () { return _this._onResolutionChanged(); };
+        this._resolutionMediaQueryList = null;
+        this._observers = [];
+        this._window = win;
+        this._installResolutionListener();
+    }
+    Observable.prototype.dispose = function () {
+        this._uninstallResolutionListener();
+        this._window = null;
+    };
+    Object.defineProperty(Observable.prototype, "value", {
+        get: function () {
+            return this._window.devicePixelRatio;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Observable.prototype.subscribe = function (next) {
+        var _this = this;
+        var observer = { next: next };
+        this._observers.push(observer);
+        return {
+            unsubscribe: function () {
+                _this._observers = _this._observers.filter(function (o) { return o !== observer; });
+            },
+        };
+    };
+    Observable.prototype._installResolutionListener = function () {
+        if (this._resolutionMediaQueryList !== null) {
+            throw new Error('Resolution listener is already installed');
+        }
+        var dppx = this._window.devicePixelRatio;
+        this._resolutionMediaQueryList = this._window.matchMedia("all and (resolution: ".concat(dppx, "dppx)"));
+        // IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
+        this._resolutionMediaQueryList.addListener(this._resolutionListener);
+    };
+    Observable.prototype._uninstallResolutionListener = function () {
+        if (this._resolutionMediaQueryList !== null) {
+            // IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
+            this._resolutionMediaQueryList.removeListener(this._resolutionListener);
+            this._resolutionMediaQueryList = null;
+        }
+    };
+    Observable.prototype._reinstallResolutionListener = function () {
+        this._uninstallResolutionListener();
+        this._installResolutionListener();
+    };
+    Observable.prototype._onResolutionChanged = function () {
+        var _this = this;
+        this._observers.forEach(function (observer) { return observer.next(_this._window.devicePixelRatio); });
+        this._reinstallResolutionListener();
+    };
+    return Observable;
+}());
+function createObservable(win) {
+    return new Observable(win);
+}
+exports.createObservable = createObservable;

bourse_app/node_modules/fancy-canvas/device-pixel-ratio.mjs

@@ -0,0 +1,60 @@
+var Observable = /** @class */ (function () {
+    function Observable(win) {
+        var _this = this;
+        this._resolutionListener = function () { return _this._onResolutionChanged(); };
+        this._resolutionMediaQueryList = null;
+        this._observers = [];
+        this._window = win;
+        this._installResolutionListener();
+    }
+    Observable.prototype.dispose = function () {
+        this._uninstallResolutionListener();
+        this._window = null;
+    };
+    Object.defineProperty(Observable.prototype, "value", {
+        get: function () {
+            return this._window.devicePixelRatio;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Observable.prototype.subscribe = function (next) {
+        var _this = this;
+        var observer = { next: next };
+        this._observers.push(observer);
+        return {
+            unsubscribe: function () {
+                _this._observers = _this._observers.filter(function (o) { return o !== observer; });
+            },
+        };
+    };
+    Observable.prototype._installResolutionListener = function () {
+        if (this._resolutionMediaQueryList !== null) {
+            throw new Error('Resolution listener is already installed');
+        }
+        var dppx = this._window.devicePixelRatio;
+        this._resolutionMediaQueryList = this._window.matchMedia("all and (resolution: ".concat(dppx, "dppx)"));
+        // IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
+        this._resolutionMediaQueryList.addListener(this._resolutionListener);
+    };
+    Observable.prototype._uninstallResolutionListener = function () {
+        if (this._resolutionMediaQueryList !== null) {
+            // IE and some versions of Edge do not support addEventListener/removeEventListener, and we are going to use the deprecated addListener/removeListener
+            this._resolutionMediaQueryList.removeListener(this._resolutionListener);
+            this._resolutionMediaQueryList = null;
+        }
+    };
+    Observable.prototype._reinstallResolutionListener = function () {
+        this._uninstallResolutionListener();
+        this._installResolutionListener();
+    };
+    Observable.prototype._onResolutionChanged = function () {
+        var _this = this;
+        this._observers.forEach(function (observer) { return observer.next(_this._window.devicePixelRatio); });
+        this._reinstallResolutionListener();
+    };
+    return Observable;
+}());
+export function createObservable(win) {
+    return new Observable(win);
+}

bourse_app/node_modules/fancy-canvas/disposable.d.mts

@@ -0,0 +1,3 @@
+export default interface Disposable {
+    dispose(): void;
+}

bourse_app/node_modules/fancy-canvas/disposable.d.ts

@@ -0,0 +1,3 @@
+export default interface Disposable {
+    dispose(): void;
+}

bourse_app/node_modules/fancy-canvas/disposable.js

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

bourse_app/node_modules/fancy-canvas/disposable.mjs

@@ -0,0 +1 @@
+export {};

bourse_app/node_modules/fancy-canvas/index.d.mts

@@ -0,0 +1,4 @@
+export { default as Disposable } from "./disposable.mjs";
+export { Size, size, equalSizes } from "./size.mjs";
+export { Binding as CanvasElementBitmapSizeBinding, BindingTarget as CanvasElementBitmapSizeBindingTarget, BitmapSizeChangedListener, bindTo as bindCanvasElementBitmapSizeTo, } from "./canvas-element-bitmap-size.mjs";
+export { CanvasRenderingTarget2D, MediaCoordinatesRenderingScope, BitmapCoordinatesRenderingScope, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from "./canvas-rendering-target.mjs";

bourse_app/node_modules/fancy-canvas/index.d.ts

@@ -0,0 +1,4 @@
+export { default as Disposable } from './disposable.js';
+export { Size, size, equalSizes } from './size.js';
+export { Binding as CanvasElementBitmapSizeBinding, BindingTarget as CanvasElementBitmapSizeBindingTarget, BitmapSizeChangedListener, bindTo as bindCanvasElementBitmapSizeTo, } from './canvas-element-bitmap-size.js';
+export { CanvasRenderingTarget2D, MediaCoordinatesRenderingScope, BitmapCoordinatesRenderingScope, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from './canvas-rendering-target.js';

bourse_app/node_modules/fancy-canvas/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryCreateCanvasRenderingTarget2D = exports.createCanvasRenderingTarget2D = exports.CanvasRenderingTarget2D = exports.bindCanvasElementBitmapSizeTo = exports.equalSizes = exports.size = void 0;
+var size_js_1 = require("./size.js");
+Object.defineProperty(exports, "size", { enumerable: true, get: function () { return size_js_1.size; } });
+Object.defineProperty(exports, "equalSizes", { enumerable: true, get: function () { return size_js_1.equalSizes; } });
+var canvas_element_bitmap_size_js_1 = require("./canvas-element-bitmap-size.js");
+Object.defineProperty(exports, "bindCanvasElementBitmapSizeTo", { enumerable: true, get: function () { return canvas_element_bitmap_size_js_1.bindTo; } });
+var canvas_rendering_target_js_1 = require("./canvas-rendering-target.js");
+Object.defineProperty(exports, "CanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.CanvasRenderingTarget2D; } });
+Object.defineProperty(exports, "createCanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.createCanvasRenderingTarget2D; } });
+Object.defineProperty(exports, "tryCreateCanvasRenderingTarget2D", { enumerable: true, get: function () { return canvas_rendering_target_js_1.tryCreateCanvasRenderingTarget2D; } });

bourse_app/node_modules/fancy-canvas/index.mjs

@@ -0,0 +1,3 @@
+export { size, equalSizes } from "./size.mjs";
+export { bindTo as bindCanvasElementBitmapSizeTo, } from "./canvas-element-bitmap-size.mjs";
+export { CanvasRenderingTarget2D, createCanvasRenderingTarget2D, tryCreateCanvasRenderingTarget2D, } from "./canvas-rendering-target.mjs";

bourse_app/node_modules/fancy-canvas/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "fancy-canvas",
+  "version": "2.1.0",
+  "author": "smakarov@tradingview.com",
+  "description": "Functionality on top of HTML canvas element, including support for HiDPI and pixel-perfect rendering",
+  "keywords": [
+    "html",
+    "canvas",
+    "graphics",
+    "hidpi",
+    "pixel-perfect"
+  ],
+  "license": "MIT",
+  "exports": {
+    "import": "./index.mjs",
+    "require": "./index.js"
+  },
+  "module": "./index.mjs",
+  "type": "commonjs",
+  "files": [
+    "**/*.mjs",
+    "**/*.d.mts",
+    "**/*.js",
+    "**/*.d.ts"
+  ]
+}

bourse_app/node_modules/fancy-canvas/rx.d.mts

@@ -0,0 +1,12 @@
+export interface NextObserver<T> {
+    next: (value: T) => void;
+}
+export interface Unsubscribable {
+    unsubscribe(): void;
+}
+export interface Subscribable<T> {
+    subscribe(next: (value: T) => void): Unsubscribable;
+}
+export interface BehaviorSubject<T> extends Subscribable<T> {
+    readonly value: T;
+}

bourse_app/node_modules/fancy-canvas/rx.d.ts

@@ -0,0 +1,12 @@
+export interface NextObserver<T> {
+    next: (value: T) => void;
+}
+export interface Unsubscribable {
+    unsubscribe(): void;
+}
+export interface Subscribable<T> {
+    subscribe(next: (value: T) => void): Unsubscribable;
+}
+export interface BehaviorSubject<T> extends Subscribable<T> {
+    readonly value: T;
+}

bourse_app/node_modules/fancy-canvas/rx.js

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

bourse_app/node_modules/fancy-canvas/rx.mjs

@@ -0,0 +1 @@
+export {};

bourse_app/node_modules/fancy-canvas/size.d.mts

@@ -0,0 +1,17 @@
+export declare type Size = Readonly<{
+    width: number;
+    height: number;
+}> & {
+    __brand: 'Size';
+};
+export declare function size({ width, height }: {
+    width: number;
+    height: number;
+}): Size;
+export declare function equalSizes(first: {
+    width: number;
+    height: number;
+}, second: {
+    width: number;
+    height: number;
+}): boolean;

bourse_app/node_modules/fancy-canvas/size.d.ts

@@ -0,0 +1,17 @@
+export declare type Size = Readonly<{
+    width: number;
+    height: number;
+}> & {
+    __brand: 'Size';
+};
+export declare function size({ width, height }: {
+    width: number;
+    height: number;
+}): Size;
+export declare function equalSizes(first: {
+    width: number;
+    height: number;
+}, second: {
+    width: number;
+    height: number;
+}): boolean;

bourse_app/node_modules/fancy-canvas/size.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalSizes = exports.size = void 0;
+function size(_a) {
+    var width = _a.width, height = _a.height;
+    if (width < 0) {
+        throw new Error('Negative width is not allowed for Size');
+    }
+    if (height < 0) {
+        throw new Error('Negative height is not allowed for Size');
+    }
+    return {
+        width: width,
+        height: height,
+    };
+}
+exports.size = size;
+function equalSizes(first, second) {
+    return (first.width === second.width) &&
+        (first.height === second.height);
+}
+exports.equalSizes = equalSizes;

bourse_app/node_modules/fancy-canvas/size.mjs

@@ -0,0 +1,17 @@
+export function size(_a) {
+    var width = _a.width, height = _a.height;
+    if (width < 0) {
+        throw new Error('Negative width is not allowed for Size');
+    }
+    if (height < 0) {
+        throw new Error('Negative height is not allowed for Size');
+    }
+    return {
+        width: width,
+        height: height,
+    };
+}
+export function equalSizes(first, second) {
+    return (first.width === second.width) &&
+        (first.height === second.height);
+}