@jbrowse/core 3.7.0 → 4.0.1

package/util/io/RemoteFileWithRangeCache.js

@@ -1,76 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteFileWithRangeCache = void 0;
-exports.clearCache = clearCache;
-const http_range_fetcher_1 = require("@gmod/http-range-fetcher");
-const generic_filehandle2_1 = require("generic-filehandle2");
-const fetchers = {};
-function binaryRangeFetch(url, start, end, options = {}) {
-    const fetcher = fetchers[url];
-    if (!fetcher) {
-        throw new Error(`fetch not registered for ${url}`);
-    }
-    return fetcher(url, start, end, options);
-}
-const globalRangeCache = new http_range_fetcher_1.HttpRangeFetcher({
-    fetch: binaryRangeFetch,
-    size: 500 * 1024 ** 2,
-    chunkSize: 128 * 1024,
-    maxFetchSize: 100 * 1024 ** 2,
-    minimumTTL: 24 * 60 * 60 * 1000,
-});
-function clearCache() {
-    globalRangeCache.reset();
-}
-class RemoteFileWithRangeCache extends generic_filehandle2_1.RemoteFile {
-    async fetch(url, init) {
-        const str = String(url);
-        if (!fetchers[str]) {
-            fetchers[str] = this.fetchBinaryRange.bind(this);
-        }
-        const range = new Headers(init === null || init === void 0 ? void 0 : init.headers).get('range');
-        if (range) {
-            const rangeParse = /bytes=(\d+)-(\d+)/.exec(range);
-            if (rangeParse) {
-                const [, start, end] = rangeParse;
-                const s = Number.parseInt(start, 10);
-                const e = Number.parseInt(end, 10);
-                const len = e - s;
-                const { buffer, headers } = (await globalRangeCache.getRange(`${url}`, s, len + 1));
-                return new Response(buffer, {
-                    status: 206,
-                    headers,
-                });
-            }
-        }
-        return super.fetch(url, init);
-    }
-    async fetchBinaryRange(url, start, end, options = {}) {
-        const requestDate = new Date();
-        const res = await super.fetch(url, {
-            ...options,
-            headers: {
-                ...options.headers,
-                range: `bytes=${start}-${end}`,
-            },
-        });
-        const responseDate = new Date();
-        if (!res.ok) {
-            const errorMessage = `HTTP ${res.status} fetching ${url} bytes ${start}-${end}`;
-            const hint = ' (should be 206 for range requests)';
-            throw new Error(`${errorMessage}${res.status === 200 ? hint : ''}`);
-        }
-        const headers = {};
-        for (const [k, v] of res.headers.entries()) {
-            headers[k] = v;
-        }
-        const arrayBuffer = await res.arrayBuffer();
-        return {
-            headers,
-            requestDate,
-            responseDate,
-            buffer: new Uint8Array(arrayBuffer),
-        };
-    }
-}
-exports.RemoteFileWithRangeCache = RemoteFileWithRangeCache;

package/util/io/index.d.ts

@@ -1,7 +0,0 @@
-import type PluginManager from '../../PluginManager';
-import type { FileLocation, UriLocation } from '../types';
-import type { Fetcher, GenericFilehandle } from 'generic-filehandle2';
-export declare function resolveUriLocation(location: UriLocation): UriLocation;
-export declare function openLocation(location: FileLocation, pluginManager?: PluginManager): GenericFilehandle;
-export declare function getFetcher(location: FileLocation, pluginManager?: PluginManager): Fetcher;
-export { RemoteFileWithRangeCache } from './RemoteFileWithRangeCache';

package/util/io/index.js

@@ -1,103 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RemoteFileWithRangeCache = void 0;
-exports.resolveUriLocation = resolveUriLocation;
-exports.openLocation = openLocation;
-exports.getFetcher = getFetcher;
-const detect_node_1 = __importDefault(require("detect-node"));
-const generic_filehandle2_1 = require("generic-filehandle2");
-const RemoteFileWithRangeCache_1 = require("./RemoteFileWithRangeCache");
-const __1 = require("../");
-const tracks_1 = require("../tracks");
-const types_1 = require("../types");
-function isLocalPathLocation(location) {
-    return 'localPath' in location;
-}
-function isBlobLocation(location) {
-    return 'blobId' in location;
-}
-function resolveUriLocation(location) {
-    return location.baseUri
-        ? { ...location, uri: new URL(location.uri, location.baseUri).href }
-        : location;
-}
-function openLocation(location, pluginManager) {
-    if (isLocalPathLocation(location)) {
-        if (!location.localPath) {
-            throw new Error('No local path provided');
-        }
-        if (detect_node_1.default || __1.isElectron) {
-            return new generic_filehandle2_1.LocalFile(location.localPath);
-        }
-        else {
-            throw new Error("can't use local files in the browser");
-        }
-    }
-    if (isBlobLocation(location)) {
-        const blob = (0, tracks_1.getBlob)(location.blobId);
-        if (!blob) {
-            throw new Error(`file ("${location.name}") was opened locally from a previous session. To restore it, go to track settings and reopen the file`);
-        }
-        return new generic_filehandle2_1.BlobFile(blob);
-    }
-    if ((0, types_1.isUriLocation)(location)) {
-        if (!location.uri) {
-            throw new Error('No URI provided');
-        }
-        const absoluteLocation = resolveUriLocation(location);
-        if (pluginManager) {
-            const internetAccount = getInternetAccount(location, pluginManager);
-            if (internetAccount) {
-                return internetAccount.openLocation(absoluteLocation);
-            }
-        }
-        return new RemoteFileWithRangeCache_1.RemoteFileWithRangeCache(absoluteLocation.uri, {
-            fetch: checkAuthNeededFetch,
-        });
-    }
-    throw new Error('invalid fileLocation');
-}
-function getFetcher(location, pluginManager) {
-    if (!(0, types_1.isUriLocation)(location)) {
-        throw new Error(`Not a valid UriLocation: ${JSON.stringify(location)}`);
-    }
-    if (pluginManager) {
-        const internetAccount = getInternetAccount(location, pluginManager);
-        if (internetAccount) {
-            return internetAccount.getFetcher(location);
-        }
-    }
-    return checkAuthNeededFetch;
-}
-function getInternetAccount(location, pluginManager) {
-    const { rootModel } = pluginManager;
-    if (rootModel && (0, types_1.isRootModelWithInternetAccounts)(rootModel)) {
-        return rootModel.findAppropriateInternetAccount(location);
-    }
-    if (location.internetAccountPreAuthorization) {
-        if (!location.internetAccountPreAuthorization.authInfo.token) {
-            throw new Error('Failed to obtain token from internet account. Try reloading the page');
-        }
-        return pluginManager
-            .getInternetAccountType(location.internetAccountPreAuthorization.internetAccountType)
-            .stateModel.create({
-            type: location.internetAccountPreAuthorization.internetAccountType,
-            configuration: location.internetAccountPreAuthorization.authInfo.configuration,
-        });
-    }
-    return undefined;
-}
-async function checkAuthNeededFetch(url, opts) {
-    var _a;
-    const response = await fetch(url, opts);
-    if (response.status === 401 &&
-        ((_a = response.headers.get('WWW-Authenticate')) === null || _a === void 0 ? void 0 : _a.includes('Basic'))) {
-        throw new types_1.AuthNeededError('Accessing HTTPBasic resource without authentication', url.toString());
-    }
-    return response;
-}
-var RemoteFileWithRangeCache_2 = require("./RemoteFileWithRangeCache");
-Object.defineProperty(exports, "RemoteFileWithRangeCache", { enumerable: true, get: function () { return RemoteFileWithRangeCache_2.RemoteFileWithRangeCache; } });

package/util/jexl.d.ts

@@ -1,4 +0,0 @@
-import jexl from 'jexl';
-type JexlNonBuildable = Omit<typeof jexl, 'Jexl'>;
-export default function JexlF(): JexlNonBuildable;
-export {};

package/util/jexl.js

@@ -1,55 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = JexlF;
-const jexl_1 = __importDefault(require("jexl"));
-function JexlF() {
-    const j = new jexl_1.default.Jexl();
-    j.addFunction('get', (feature, data) => feature.get(data));
-    j.addFunction('parent', (feature) => feature.parent());
-    j.addFunction('id', (feature) => feature.id());
-    j.addFunction('cast', (arg) => arg);
-    j.addFunction('log', (thing) => {
-        console.log(thing);
-        return thing;
-    });
-    j.addFunction('max', Math.max);
-    j.addFunction('min', Math.min);
-    j.addFunction('sqrt', Math.sqrt);
-    j.addFunction('ceil', Math.ceil);
-    j.addFunction('floor', Math.floor);
-    j.addFunction('round', Math.round);
-    j.addFunction('abs', Math.abs);
-    j.addFunction('log10', Math.log10);
-    j.addFunction('parseInt', Number.parseInt);
-    j.addFunction('parseFloat', Number.parseFloat);
-    j.addFunction('split', (s, char) => s.split(char));
-    j.addFunction('join', (k, ...args) => [...args].filter(f => !!f).join(k));
-    j.addFunction('charAt', (s, index) => s.charAt(index));
-    j.addFunction('charCodeAt', (s, index) => s.charCodeAt(index));
-    j.addFunction('codePointAt', (s, pos) => s.codePointAt(pos));
-    j.addFunction('startsWith', (s, search, len) => s.startsWith(search, len));
-    j.addFunction('endsWith', (s, search, len) => s.endsWith(search, len));
-    j.addFunction('padEnd', (s, len, pad) => s.padEnd(len, pad));
-    j.addFunction('padStart', (s, len, fill) => s.padStart(len, fill));
-    j.addFunction('repeat', (s, count) => s.repeat(count));
-    j.addFunction('replace', (s, match, sub) => s.replace(match, sub));
-    j.addFunction('replaceAll', (s, match, sub) => s.replaceAll(match, sub));
-    j.addFunction('slice', (s, start, end) => s.slice(start, end));
-    j.addFunction('startsWith', (s, search, pos) => s.startsWith(search, pos));
-    j.addFunction('substring', (s, start, end) => s.substring(start, end));
-    j.addFunction('toLowerCase', (s) => s.toLowerCase());
-    j.addFunction('toUpperCase', (s) => s.toUpperCase());
-    j.addFunction('jsonParse', (s) => JSON.parse(s));
-    j.addFunction('trim', (s) => s.trim());
-    j.addFunction('trimEnd', (s) => s.trimEnd());
-    j.addFunction('trimStart', (s) => s.trimStart());
-    j.addFunction('getTag', (feature, s) => {
-        const tags = feature.get('tags');
-        return tags ? tags[s] : feature.get(s);
-    });
-    j.addBinaryOp('&', 15, (a, b) => a & b);
-    return j;
-}

package/util/jexlStrings.js

@@ -1,23 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringToJexlExpression = stringToJexlExpression;
-const jexl_1 = __importDefault(require("./jexl"));
-const compilationCache = {};
-function stringToJexlExpression(str, jexl) {
-    const cacheKey = `nosig|${str}`;
-    if (!compilationCache[cacheKey]) {
-        const match = str.startsWith('jexl:');
-        if (!match) {
-            throw new Error('string does not appear to be in jexl format');
-        }
-        const code = str.split('jexl:')[1];
-        const compiled = jexl
-            ? jexl.compile(code)
-            : (0, jexl_1.default)().compile(code);
-        compilationCache[cacheKey] = compiled;
-    }
-    return compilationCache[cacheKey];
-}

package/util/layouts/BaseLayout.d.ts

@@ -1,30 +0,0 @@
-export type RectTuple = [number, number, number, number];
-export interface SerializedLayout {
-    rectangles: Record<string, RectTuple>;
-    totalHeight: number;
-    containsNoTransferables?: true;
-    maxHeightReached: boolean;
-}
-export interface Rectangle<T> {
-    id: string;
-    l: number;
-    r: number;
-    top: number | null;
-    h: number;
-    originalHeight: number;
-    data?: T;
-}
-export interface BaseLayout<T> {
-    addRect(id: string, left: number, right: number, height: number, data?: unknown): number | null;
-    collides(rect: Rectangle<T>, top: number): boolean;
-    addRectToBitmap(rect: Rectangle<T>, data: unknown): void;
-    getRectangles(): Map<string, RectTuple>;
-    discardRange(left: number, right: number): void;
-    serializeRegion(region: {
-        start: number;
-        end: number;
-    }): SerializedLayout;
-    getTotalHeight(): number;
-    maxHeightReached: boolean;
-    toJSON(): SerializedLayout;
-}

package/util/layouts/BaseLayout.js

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

package/util/layouts/GranularRectLayout.d.ts

@@ -1,37 +0,0 @@
-import type { BaseLayout, RectTuple, Rectangle, SerializedLayout } from './BaseLayout';
-export default class GranularRectLayout<T> implements BaseLayout<T> {
-    private pitchX;
-    private pitchY;
-    private hardRowLimit;
-    private bitmap;
-    private rectangles;
-    maxHeightReached: boolean;
-    private maxHeight;
-    private displayMode;
-    private pTotalHeight;
-    constructor({ pitchX, pitchY, maxHeight, hardRowLimit, displayMode, }?: {
-        pitchX?: number;
-        pitchY?: number;
-        maxHeight?: number;
-        displayMode?: string;
-        hardRowLimit?: number;
-    });
-    addRect(id: string, left: number, right: number, height: number, data?: T): number | null;
-    collides(rect: Rectangle<T>, top: number): boolean;
-    private autovivifyRow;
-    addRectToBitmap(rect: Rectangle<T>): void;
-    discardRange(left: number, right: number): void;
-    hasSeen(id: string): boolean;
-    getByCoord(x: number, y: number): string | Record<string, T> | undefined;
-    getByID(id: string): RectTuple | undefined;
-    getDataByID(id: string): T | undefined;
-    cleanup(): void;
-    getTotalHeight(): number;
-    get totalHeight(): number;
-    getRectangles(): Map<string, RectTuple>;
-    serializeRegion(region: {
-        start: number;
-        end: number;
-    }): SerializedLayout;
-    toJSON(): SerializedLayout;
-}

package/util/layouts/GranularRectLayout.js

@@ -1,343 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const minSizeToBotherWith = 10000;
-const maxFeaturePitchWidth = 20000;
-function segmentsIntersect(x1, x2, y1, y2) {
-    return x2 >= y1 && y2 >= x1;
-}
-class LayoutRow {
-    constructor() {
-        this.padding = 1;
-        this.widthLimit = 1000000;
-    }
-    setAllFilled(data) {
-        this.allFilled = data;
-    }
-    getItemAt(x) {
-        var _a;
-        if (this.allFilled) {
-            return this.allFilled;
-        }
-        if (((_a = this.rowState) === null || _a === void 0 ? void 0 : _a.min) === undefined ||
-            x < this.rowState.min ||
-            x >= this.rowState.max) {
-            return undefined;
-        }
-        return this.rowState.bits[x - this.rowState.offset];
-    }
-    isRangeClear(left, right) {
-        if (this.allFilled) {
-            return false;
-        }
-        if (this.rowState === undefined ||
-            right <= this.rowState.min ||
-            left >= this.rowState.max) {
-            return true;
-        }
-        const { min, max, offset, bits } = this.rowState;
-        const maxX = Math.min(max, right) - offset;
-        let flag = true;
-        for (let x = Math.max(min, left) - offset; x < maxX && flag; x++) {
-            flag = bits[x] === undefined;
-        }
-        return flag;
-    }
-    initialize(left, right) {
-        const rectWidth = right - left;
-        return {
-            offset: left - rectWidth,
-            min: left,
-            max: right,
-            bits: Array.from({ length: 3 * rectWidth }),
-        };
-    }
-    addRect(rect, data) {
-        const left = rect.l;
-        const right = rect.r + this.padding;
-        if (!this.rowState) {
-            this.rowState = this.initialize(left, right);
-        }
-        let oLeft = left - this.rowState.offset;
-        let oRight = right - this.rowState.offset;
-        const currLength = this.rowState.bits.length;
-        if (oRight >= this.rowState.bits.length) {
-            const additionalLength = oRight + 1;
-            if (this.rowState.bits.length + additionalLength > this.widthLimit) {
-                console.warn('Layout width limit exceeded, discarding old layout. Please be more careful about discarding unused blocks.');
-                this.rowState = this.initialize(left, right);
-            }
-            else if (additionalLength > 0) {
-                this.rowState.bits = [
-                    ...this.rowState.bits,
-                    ...Array.from({ length: additionalLength }),
-                ];
-            }
-        }
-        if (left < this.rowState.offset) {
-            const additionalLength = Math.min(currLength - oLeft, this.rowState.offset);
-            if (this.rowState.bits.length + additionalLength > this.widthLimit) {
-                console.warn('Layout width limit exceeded, discarding old layout. Please be more careful about discarding unused blocks.');
-                this.rowState = this.initialize(left, right);
-            }
-            else {
-                this.rowState.bits = [
-                    ...Array.from({ length: additionalLength }),
-                    ...this.rowState.bits,
-                ];
-                this.rowState.offset -= additionalLength;
-            }
-        }
-        oRight = right - this.rowState.offset;
-        oLeft = left - this.rowState.offset;
-        const w = oRight - oLeft;
-        if (w > maxFeaturePitchWidth) {
-            console.warn(`Layout X pitch set too low, feature spans ${w} bits in a single row.`, rect, data);
-        }
-        for (let x = oLeft; x < oRight; x += 1) {
-            this.rowState.bits[x] = data;
-        }
-        if (left < this.rowState.min) {
-            this.rowState.min = left;
-        }
-        if (right > this.rowState.max) {
-            this.rowState.max = right;
-        }
-    }
-    discardRange(left, right) {
-        if (this.allFilled) {
-            return;
-        }
-        if (!this.rowState) {
-            return;
-        }
-        if (right <= this.rowState.min || left >= this.rowState.max) {
-            return;
-        }
-        if (left <= this.rowState.min && right >= this.rowState.max) {
-            this.rowState = undefined;
-            return;
-        }
-        if (right > this.rowState.min && left <= this.rowState.min) {
-            this.rowState.min = right;
-        }
-        if (left < this.rowState.max && right >= this.rowState.max) {
-            this.rowState.max = left;
-        }
-        if (this.rowState.offset < this.rowState.min - minSizeToBotherWith &&
-            this.rowState.bits.length >
-                this.rowState.max + minSizeToBotherWith - this.rowState.offset) {
-            const leftTrimAmount = this.rowState.min - this.rowState.offset;
-            const rightTrimAmount = this.rowState.bits.length -
-                1 -
-                (this.rowState.max - this.rowState.offset);
-            this.rowState.bits = this.rowState.bits.slice(leftTrimAmount, this.rowState.bits.length - rightTrimAmount);
-            this.rowState.offset += leftTrimAmount;
-        }
-        else if (this.rowState.offset < this.rowState.min - minSizeToBotherWith) {
-            const desiredOffset = this.rowState.min - Math.floor(minSizeToBotherWith / 2);
-            const trimAmount = desiredOffset - this.rowState.offset;
-            this.rowState.bits.splice(0, trimAmount);
-            this.rowState.offset += trimAmount;
-        }
-        else if (this.rowState.bits.length >
-            this.rowState.max - this.rowState.offset + minSizeToBotherWith) {
-            const desiredLength = this.rowState.max -
-                this.rowState.offset +
-                1 +
-                Math.floor(minSizeToBotherWith / 2);
-            this.rowState.bits.length = desiredLength;
-        }
-        const oLeft = Math.max(this.rowState.min, left) - this.rowState.offset;
-        const oRight = Math.min(right, this.rowState.max) - this.rowState.offset;
-        for (let x = oLeft; x >= 0 && x < oRight; x += 1) {
-            this.rowState.bits[x] = undefined;
-        }
-    }
-}
-class GranularRectLayout {
-    constructor({ pitchX = 10, pitchY = 10, maxHeight = 10000, hardRowLimit = 10000, displayMode = 'normal', } = {}) {
-        this.pitchX = pitchX;
-        this.pitchY = pitchY;
-        this.hardRowLimit = hardRowLimit;
-        this.maxHeightReached = false;
-        this.displayMode = displayMode;
-        if (this.displayMode === 'compact') {
-            this.pitchY = Math.round(this.pitchY / 4) || 1;
-            this.pitchX = Math.round(this.pitchX / 4) || 1;
-        }
-        this.bitmap = [];
-        this.rectangles = new Map();
-        this.maxHeight = Math.ceil(maxHeight / this.pitchY);
-        this.pTotalHeight = 0;
-    }
-    addRect(id, left, right, height, data) {
-        const storedRec = this.rectangles.get(id);
-        if (storedRec) {
-            if (storedRec.top === null) {
-                return null;
-            }
-            this.addRectToBitmap(storedRec);
-            return storedRec.top * this.pitchY;
-        }
-        const pLeft = Math.floor(left / this.pitchX);
-        const pRight = Math.floor(right / this.pitchX);
-        const pHeight = Math.ceil(height / this.pitchY);
-        const rectangle = {
-            id,
-            l: pLeft,
-            r: pRight,
-            top: null,
-            h: pHeight,
-            originalHeight: height,
-            data,
-        };
-        const maxTop = this.maxHeight - pHeight;
-        let top = 0;
-        if (this.displayMode !== 'collapse') {
-            for (; top <= maxTop; top += 1) {
-                if (!this.collides(rectangle, top)) {
-                    break;
-                }
-            }
-            if (top > maxTop) {
-                rectangle.top = null;
-                this.rectangles.set(id, rectangle);
-                this.maxHeightReached = true;
-                return null;
-            }
-        }
-        rectangle.top = top;
-        this.addRectToBitmap(rectangle);
-        this.rectangles.set(id, rectangle);
-        this.pTotalHeight = Math.max(this.pTotalHeight || 0, top + pHeight);
-        return top * this.pitchY;
-    }
-    collides(rect, top) {
-        const { bitmap } = this;
-        const maxY = top + rect.h;
-        for (let y = top; y < maxY; y += 1) {
-            const row = bitmap[y];
-            if (row !== undefined && !row.isRangeClear(rect.l, rect.r)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    autovivifyRow(bitmap, y) {
-        let row = bitmap[y];
-        if (!row) {
-            if (y > this.hardRowLimit) {
-                throw new Error(`layout hard limit (${this.hardRowLimit * this.pitchY}px) exceeded, aborting layout`);
-            }
-            row = new LayoutRow();
-            bitmap[y] = row;
-        }
-        return row;
-    }
-    addRectToBitmap(rect) {
-        if (rect.top === null) {
-            return;
-        }
-        const data = rect.id;
-        const yEnd = rect.top + rect.h;
-        if (rect.r - rect.l > maxFeaturePitchWidth) {
-            for (let y = rect.top; y < yEnd; y += 1) {
-                this.autovivifyRow(this.bitmap, y).setAllFilled(data);
-            }
-        }
-        else {
-            for (let y = rect.top; y < yEnd; y += 1) {
-                this.autovivifyRow(this.bitmap, y).addRect(rect, data);
-            }
-        }
-    }
-    discardRange(left, right) {
-        const pLeft = Math.floor(left / this.pitchX);
-        const pRight = Math.floor(right / this.pitchX);
-        const { bitmap } = this;
-        for (const row of bitmap) {
-            row.discardRange(pLeft, pRight);
-        }
-    }
-    hasSeen(id) {
-        return this.rectangles.has(id);
-    }
-    getByCoord(x, y) {
-        const pY = Math.floor(y / this.pitchY);
-        const row = this.bitmap[pY];
-        if (!row) {
-            return undefined;
-        }
-        const pX = Math.floor(x / this.pitchX);
-        return row.getItemAt(pX);
-    }
-    getByID(id) {
-        const r = this.rectangles.get(id);
-        if (r) {
-            const t = r.top * this.pitchY;
-            return [
-                r.l * this.pitchX,
-                t,
-                r.r * this.pitchX,
-                t + r.originalHeight,
-            ];
-        }
-        return undefined;
-    }
-    getDataByID(id) {
-        var _a;
-        return (_a = this.rectangles.get(id)) === null || _a === void 0 ? void 0 : _a.data;
-    }
-    cleanup() { }
-    getTotalHeight() {
-        return this.pTotalHeight * this.pitchY;
-    }
-    get totalHeight() {
-        return this.getTotalHeight();
-    }
-    getRectangles() {
-        return new Map([...this.rectangles.entries()].map(([id, rect]) => {
-            const { l, r, originalHeight, top } = rect;
-            const t = (top || 0) * this.pitchY;
-            const b = t + originalHeight;
-            return [id, [l * this.pitchX, t, r * this.pitchX, b]];
-        }));
-    }
-    serializeRegion(region) {
-        const regionRectangles = {};
-        let maxHeightReached = false;
-        for (const [id, rect] of this.rectangles.entries()) {
-            const { l, r, originalHeight, top } = rect;
-            if (rect.top === null) {
-                maxHeightReached = true;
-            }
-            else {
-                const t = (top || 0) * this.pitchY;
-                const b = t + originalHeight;
-                const y1 = l * this.pitchX;
-                const y2 = r * this.pitchX;
-                const x1 = region.start;
-                const x2 = region.end;
-                if (segmentsIntersect(x1, x2, y1 - this.pitchX, y2 + this.pitchX)) {
-                    regionRectangles[id] = [y1, t, y2, b];
-                }
-            }
-        }
-        return {
-            rectangles: regionRectangles,
-            containsNoTransferables: true,
-            totalHeight: this.getTotalHeight(),
-            maxHeightReached,
-        };
-    }
-    toJSON() {
-        const rectangles = Object.fromEntries(this.getRectangles());
-        return {
-            rectangles,
-            containsNoTransferables: true,
-            totalHeight: this.getTotalHeight(),
-            maxHeightReached: this.maxHeightReached,
-        };
-    }
-}
-exports.default = GranularRectLayout;