@genome-spy/core 0.36.0 → 0.37.0

package/dist/src/data/sources/dataUtils.js

@@ -0,0 +1,83 @@
+import { isInlineData } from "./inlineSource";
+
+/**
+ * Validates data source params, infers format if not specified explicitly,
+ * returns a complete DataSource params object.
+ *
+ * @param {import("../../spec/data").DataSource} params
+ *      DataSource parameters
+ */
+export function getFormat(params) {
+    if (!isInlineData(params) && !isUrlData(params)) {
+        return;
+    }
+    const format = { ...params.format };
+
+    format.type ??= isUrlData(params) && extractTypeFromUrl(params.url);
+    // @ts-ignore TODO: Fix typing
+    format.parse ??= "auto";
+
+    if (!format.type) {
+        throw new Error(
+            "Format for the data source was not defined and it could not be inferred: " +
+                JSON.stringify(params)
+        );
+    }
+
+    return format;
+}
+
+/**
+ * @param {string | string[]} url
+ */
+export function extractTypeFromUrl(url) {
+    if (Array.isArray(url)) {
+        url = url[0];
+    }
+
+    if (url) {
+        return url.match(/\.(csv|tsv|json)/)?.[1];
+    }
+}
+
+export const makeWrapper = (/** @type {any} */ d) =>
+    typeof d != "object" ? scalarWrapper : nopWrapper;
+
+const scalarWrapper = (
+    /** @type {import("@genome-spy/core/spec/channel").Scalar} */ x
+) => ({ data: x });
+
+const nopWrapper = (/** @type {import("../flowNode").Datum} */ x) => x;
+
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").CsvDataFormat}
+ */
+export function isCsvDataFormat(dataFormat) {
+    return dataFormat.type == "csv" || dataFormat.type == "tsv";
+}
+
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").DsvDataFormat}
+ */
+export function isDsvDataFormat(dataFormat) {
+    return dataFormat.type == "dsv";
+}
+
+/**
+ * @param {import("../../spec/data").DataFormat} dataFormat
+ * @return {dataFormat is import("../../spec/data").JsonDataFormat}
+ */
+export function isJsonDataFormat(dataFormat) {
+    return dataFormat.type == "json";
+}
+
+/**
+ *
+ * @param {import("../../spec/data").DataSource} dataSource
+ * @return {dataSource is import("../../spec/data").UrlData}
+ */
+export function isUrlData(dataSource) {
+    return "url" in dataSource;
+}

package/dist/src/data/sources/dynamic/README.md

@@ -0,0 +1,3 @@
+# Dynamic data sources
+
+... that listen to changes in scale domains and propagates data dynamically.

package/dist/src/data/sources/dynamic/axisGenomeSource.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Propagates the genome (chromosome) data associated with the channel.
+ * Can be used to generate a genome axis or fancy background grid.
+ */
+export default class AxisGenomeSource extends SingleAxisLazySource {
+    /**
+     * @param {import("../../../spec/data").AxisGenomeData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").AxisGenomeData, view: import("../../../view/view").default);
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+//# sourceMappingURL=axisGenomeSource.d.ts.map

package/dist/src/data/sources/dynamic/axisGenomeSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisGenomeSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/axisGenomeSource.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,cAAc,QAC3C,OAAO,oBAAoB,EAAE,OAAO,EAI9C;CAKJ;iCAlBgC,wBAAwB"}

package/dist/src/data/sources/dynamic/axisGenomeSource.js

@@ -0,0 +1,19 @@
+import SingleAxisLazySource from "./singleAxisLazySource";
+
+/**
+ * Propagates the genome (chromosome) data associated with the channel.
+ * Can be used to generate a genome axis or fancy background grid.
+ */
+export default class AxisGenomeSource extends SingleAxisLazySource {
+    /**
+     * @param {import("../../../spec/data").AxisGenomeData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        super(view, params.channel);
+    }
+
+    async load() {
+        this.publishData(this.genome.chromosomes);
+    }
+}

package/dist/src/data/sources/dynamic/axisTickSource.d.ts

@@ -0,0 +1,18 @@
+/**
+ *
+ */
+export default class AxisTickSource extends SingleAxisLazySource {
+    /**
+     * @param {import("../../../spec/data").AxisTicksData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").AxisTicksData, view: import("../../../view/view").default);
+    /**
+     * @type {import("../../../spec/channel").Scalar[]}
+     */
+    ticks: import("../../../spec/channel").Scalar[];
+    params: import("../../../spec/data").AxisTicksData;
+    onDomainChanged(): Promise<void>;
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+//# sourceMappingURL=axisTickSource.d.ts.map

package/dist/src/data/sources/dynamic/axisTickSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"axisTickSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/axisTickSource.js"],"names":[],"mappings":"AAYA;;GAEG;AACH;IAMI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,aAAa,QAC1C,OAAO,oBAAoB,EAAE,OAAO,EAY9C;IAnBD;;OAEG;IACH,OAFU,OAAO,uBAAuB,EAAE,MAAM,EAAE,CAEvC;IAeP,mDAAoB;IAGxB,iCAkCC;CACJ;iCA9DgC,wBAAwB"}

package/dist/src/data/sources/dynamic/axisTickSource.js

@@ -0,0 +1,73 @@
+import { isNumber } from "vega-util";
+
+import { shallowArrayEquals } from "../../../utils/arrayUtils";
+import smoothstep from "../../../utils/smoothstep";
+import {
+    validTicks,
+    tickValues,
+    tickFormat,
+    tickCount,
+} from "../../../scale/ticks";
+import SingleAxisLazySource from "./singleAxisLazySource";
+
+/**
+ *
+ */
+export default class AxisTickSource extends SingleAxisLazySource {
+    /**
+     * @type {import("../../../spec/channel").Scalar[]}
+     */
+    ticks = [];
+
+    /**
+     * @param {import("../../../spec/data").AxisTicksData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").AxisTicksData} params */
+        const paramsWithDefaults = {
+            axis: {},
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = params;
+    }
+
+    async onDomainChanged() {
+        // Note, although this function is async, it is not awaited. Data are updated
+        // synchronously to ensure that the new ticks are available before the next frame is drawn.
+
+        const scale = this.scaleResolution.getScale();
+        const axisParams = this.params.axis;
+        const axisLength = this.getAxisLength();
+
+        /**
+         * Make ticks more dense in small plots.
+         * TODO: Make configurable
+         *
+         * @param {number} length
+         */
+        const tickSpacing = (length) => 25 + 60 * smoothstep(100, 700, length);
+
+        const requestedCount = isNumber(axisParams.tickCount)
+            ? axisParams.tickCount
+            : Math.round(axisLength / tickSpacing(axisLength));
+
+        const count = tickCount(scale, requestedCount, axisParams.tickMinStep);
+
+        const ticks = axisParams.values
+            ? validTicks(scale, axisParams.values, count)
+            : tickValues(scale, count);
+
+        if (!shallowArrayEquals(ticks, this.ticks)) {
+            this.ticks = ticks;
+
+            const format = tickFormat(scale, requestedCount, axisParams.format);
+            this.publishData(
+                ticks.map((tick) => ({ value: tick, label: format(tick) }))
+            );
+        }
+    }
+}

package/dist/src/data/sources/dynamic/bamSource.d.ts

@@ -0,0 +1,46 @@
+declare const BamSource_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        lastQuantizedInterval: number[];
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & typeof SingleAxisLazySource;
+export default class BamSource extends BamSource_base {
+    /**
+     * @param {import("../../../spec/data").BamData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").BamData, view: import("../../../view/view").default);
+    /** Keep track of the order of the requests */
+    lastRequestId: number;
+    /**
+     * Some BAM files lack the "chr" prefix on their reference names. For example:
+     * http://genome.ucsc.edu/goldenPath/help/examples/bamExample.bam
+     *
+     * N.B. @SN AN records in SAM header may have alternative names for chromosomes.
+     * TODO: Explore their usage
+     *
+     * @type {(chr: string) => string}
+     */
+    chrPrefixFixer: (chr: string) => string;
+    params: import("../../../spec/data").BamData;
+    bam: BamFile;
+    headerPromise: Promise<{
+        tag: string;
+        data: {
+            tag: string;
+            value: string;
+        }[];
+    }[]>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+import { BamFile } from "@gmod/bam";
+export {};
+//# sourceMappingURL=bamSource.d.ts.map

package/dist/src/data/sources/dynamic/bamSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bamSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/bamSource.js"],"names":[],"mappings":";;;;;;;;AAOA;IAeI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,OAAO,QACpC,OAAO,oBAAoB,EAAE,OAAO,EAuC9C;IAvDD,8CAA8C;IAC9C,sBAAkB;IAElB;;;;;;;;OAQG;IACH,sBAFgB,MAAM,KAAK,MAAM,CAEH;IAgB1B,6CAAgC;IAShC,aAKE;IAEF;;;;;;SAAyC;IAa7C;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBA6ClB;CACJ;iCA/GgC,wBAAwB;wBAFjC,WAAW"}

package/dist/src/data/sources/dynamic/bamSource.js

@@ -0,0 +1,115 @@
+import { RemoteFile } from "generic-filehandle";
+import { BamFile } from "@gmod/bam";
+
+import SingleAxisLazySource from "./singleAxisLazySource";
+import windowedMixin from "./windowedMixin";
+import addBaseUrl from "@genome-spy/core/utils/addBaseUrl";
+
+export default class BamSource extends windowedMixin(SingleAxisLazySource) {
+    /** Keep track of the order of the requests */
+    lastRequestId = 0;
+
+    /**
+     * Some BAM files lack the "chr" prefix on their reference names. For example:
+     * http://genome.ucsc.edu/goldenPath/help/examples/bamExample.bam
+     *
+     * N.B. @SN AN records in SAM header may have alternative names for chromosomes.
+     * TODO: Explore their usage
+     *
+     * @type {(chr: string) => string}
+     */
+    chrPrefixFixer = (chr) => chr;
+
+    /**
+     * @param {import("../../../spec/data").BamData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").BamData} */
+        const paramsWithDefaults = {
+            channel: "x",
+            windowSize: 20000,
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = paramsWithDefaults;
+
+        if (!this.params.url) {
+            throw new Error("No URL provided for BamSource");
+        }
+
+        const withBase = (/** @type {string} */ uri) =>
+            new RemoteFile(addBaseUrl(uri, this.view.getBaseUrl()));
+
+        this.bam = new BamFile({
+            bamFilehandle: withBase(this.params.url),
+            baiFilehandle: withBase(
+                this.params.indexUrl ?? this.params.url + ".bai"
+            ),
+        });
+
+        this.headerPromise = this.bam.getHeader();
+        this.headerPromise.then((_header) => {
+            const g = this.genome.hasChrPrefix();
+            // @ts-expect-error protected property
+            const b = this.bam.indexToChr?.[0]?.refName.startsWith("chr");
+            if (g && !b) {
+                this.chrPrefixFixer = (chr) => chr.replace("chr", "");
+            } else if (!g && b) {
+                this.chrPrefixFixer = (chr) => "chr" + chr;
+            }
+        });
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    async onDomainChanged(domain) {
+        const windowSize = this.params.windowSize;
+
+        if (domain[1] - domain[0] > windowSize) {
+            return;
+        }
+
+        await this.headerPromise;
+
+        const quantizedInterval = this.quantizeInterval(domain, windowSize);
+
+        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
+            const discreteChromosomeIntervals =
+                this.genome.continuousToDiscreteChromosomeIntervals(
+                    quantizedInterval
+                );
+
+            // TODO: Error handling
+            const sequencesWithChrom = await Promise.all(
+                discreteChromosomeIntervals.map((d) =>
+                    this.bam
+                        .getRecordsForRange(
+                            this.chrPrefixFixer(d.chrom),
+                            d.startPos,
+                            d.endPos
+                        )
+                        .then((records) =>
+                            records.map((record) => ({
+                                chrom: d.chrom,
+                                start: record.get("start"),
+                                end: record.get("end"),
+                                name: record.get("name"),
+                                MD: record.get("MD"),
+                                cigar: record.get("cigar"),
+                                mapq: record.get("mq"),
+                                strand: record.get("strand") === 1 ? "+" : "-",
+                            }))
+                        )
+                )
+            );
+
+            this.publishData(sequencesWithChrom.flat());
+        }
+    }
+}

package/dist/src/data/sources/dynamic/bigBedSource.d.ts

@@ -0,0 +1,51 @@
+declare const BigBedSource_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        lastQuantizedInterval: number[];
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & typeof SingleAxisLazySource;
+export default class BigBedSource extends BigBedSource_base {
+    /**
+     * @param {import("../../../spec/data").BigBedData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").BigBedData, view: import("../../../view/view").default);
+    /** Keep track of the order of the requests */
+    lastRequestId: number;
+    /** @type {BED} */
+    parser: BED;
+    params: import("../../../spec/data").BigBedData;
+    bbi: BigBed;
+    doDebouncedRequest: (...args: any[]) => Promise<any>;
+    headerPromise: Promise<import("@gmod/bbi").Header>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     */
+    doRequest(interval: number[]): Promise<void>;
+    /**
+     *
+     * @param {number[]} interval
+     */
+    getFeatures(interval: number[]): Promise<{
+        requestId: number;
+        abort: () => void;
+        features: {
+            [key: string]: any;
+        }[];
+    }>;
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+import BED from "@gmod/bed";
+import { BigBed } from "@gmod/bbi";
+export {};
+//# sourceMappingURL=bigBedSource.d.ts.map

package/dist/src/data/sources/dynamic/bigBedSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigBedSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/bigBedSource.js"],"names":[],"mappings":";;;;;;;;AASA;IAOI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,UAAU,QACvC,OAAO,oBAAoB,EAAE,OAAO,EAmC9C;IA3CD,8CAA8C;IAC9C,sBAAkB;IAElB,kBAAkB;IAClB,QADW,GAAG,CACP;IAgBH,gDAAgC;IAMhC,YAIE;IAEF,qDAIC;IAED,mDAAyC;IAO7C;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAclB;IAED;;;;OAIG;IACH,oBAFW,MAAM,EAAE,iBAWlB;IAED;;;OAGG;IACH,sBAFW,MAAM,EAAE;;;;;;OAkClB;CACJ;iCA3HgC,wBAAwB;gBAFzC,WAAW;uBAFJ,WAAW"}

package/dist/src/data/sources/dynamic/bigBedSource.js

@@ -0,0 +1,128 @@
+import { BigBed } from "@gmod/bbi";
+import { RemoteFile } from "generic-filehandle";
+import BED from "@gmod/bed";
+
+import SingleAxisLazySource from "./singleAxisLazySource";
+import windowedMixin from "./windowedMixin";
+import { debounce } from "../../../utils/debounce";
+import addBaseUrl from "@genome-spy/core/utils/addBaseUrl";
+
+export default class BigBedSource extends windowedMixin(SingleAxisLazySource) {
+    /** Keep track of the order of the requests */
+    lastRequestId = 0;
+
+    /** @type {BED} */
+    parser;
+
+    /**
+     * @param {import("../../../spec/data").BigBedData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params, view) {
+        /** @type {import("../../../spec/data").BigBedData} */
+        const paramsWithDefaults = {
+            channel: "x",
+            windowSize: 1000000,
+            ...params,
+        };
+
+        super(view, paramsWithDefaults.channel);
+
+        this.params = paramsWithDefaults;
+
+        if (!this.params.url) {
+            throw new Error("No URL provided for BigBedSource");
+        }
+
+        this.bbi = new BigBed({
+            filehandle: new RemoteFile(
+                addBaseUrl(this.params.url, this.view.getBaseUrl())
+            ),
+        });
+
+        this.doDebouncedRequest = debounce(
+            this.doRequest.bind(this),
+            200,
+            false
+        );
+
+        this.headerPromise = this.bbi.getHeader();
+
+        this.headerPromise.then((header) => {
+            this.parser = new BED({ autoSql: header.autoSql });
+        });
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    async onDomainChanged(domain) {
+        const windowSize = this.params.windowSize;
+
+        if (domain[1] - domain[0] > windowSize) {
+            return;
+        }
+
+        const quantizedInterval = this.quantizeInterval(domain, windowSize);
+
+        if (this.checkAndUpdateLastInterval(quantizedInterval)) {
+            this.doDebouncedRequest(quantizedInterval);
+        }
+    }
+
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     */
+    async doRequest(interval) {
+        const featureResponse = await this.getFeatures(interval);
+
+        // Discard late responses
+        if (featureResponse.requestId < this.lastRequestId) {
+            return;
+        }
+
+        this.publishData(featureResponse.features);
+    }
+
+    /**
+     *
+     * @param {number[]} interval
+     */
+    async getFeatures(interval) {
+        let requestId = ++this.lastRequestId;
+
+        // TODO: Abort previous requests
+        const abortController = new AbortController();
+
+        const discreteChromosomeIntervals =
+            this.genome.continuousToDiscreteChromosomeIntervals(interval);
+
+        // TODO: Error handling
+        const featuresWithChrom = await Promise.all(
+            discreteChromosomeIntervals.map((d) =>
+                this.bbi
+                    .getFeatures(d.chrom, d.startPos, d.endPos, {
+                        signal: abortController.signal,
+                    })
+                    .then((features) =>
+                        features.map((f) =>
+                            this.parser.parseLine(
+                                `${d.chrom}\t${f.start}\t${f.end}\t${f.rest}`,
+                                { uniqueId: f.uniqueId }
+                            )
+                        )
+                    )
+            )
+        );
+
+        return {
+            requestId,
+            abort: () => abortController.abort(),
+            features: featuresWithChrom.flat(), // TODO: Use batches, not flat
+        };
+    }
+}

package/dist/src/data/sources/dynamic/bigWigSource.d.ts

@@ -0,0 +1,58 @@
+declare const BigWigSource_base: {
+    new (...args: any[]): {
+        [x: string]: any;
+        lastQuantizedInterval: number[];
+        quantizeInterval(interval: number[], windowSize: number): number[];
+        checkAndUpdateLastInterval(interval: number[]): boolean;
+    };
+} & typeof SingleAxisLazySource;
+/**
+ *
+ */
+export default class BigWigSource extends BigWigSource_base {
+    /**
+     * @param {import("../../../spec/data").BigWigData} params
+     * @param {import("../../../view/view").default} view
+     */
+    constructor(params: import("../../../spec/data").BigWigData, view: import("../../../view/view").default);
+    /** @type {number[]} */
+    reductionLevels: number[];
+    /** Keep track of the order of the requests */
+    lastRequestId: number;
+    params: import("../../../spec/data").BigWigData;
+    bbi: BigWig;
+    doDebouncedRequest: (...args: any[]) => Promise<any>;
+    headerPromise: Promise<import("@gmod/bbi").Header>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} domain Linearized domain
+     */
+    onDomainChanged(domain: number[]): Promise<void>;
+    /**
+     * Listen to the domain change event and update data when the covered windows change.
+     *
+     * @param {number[]} interval linearized domain
+     * @param {number} reductionLevel
+     */
+    doRequest(interval: number[], reductionLevel: number): Promise<void>;
+    /**
+     *
+     * @param {number[]} interval
+     * @param {number} scale
+     */
+    getFeatures(interval: number[], scale: number): Promise<{
+        requestId: number;
+        abort: () => void;
+        features: {
+            chrom: string;
+            start: number;
+            end: number;
+            score: number;
+        }[];
+    }>;
+}
+import SingleAxisLazySource from "./singleAxisLazySource";
+import { BigWig } from "@gmod/bbi";
+export {};
+//# sourceMappingURL=bigWigSource.d.ts.map

package/dist/src/data/sources/dynamic/bigWigSource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigWigSource.d.ts","sourceRoot":"","sources":["../../../../../src/data/sources/dynamic/bigWigSource.js"],"names":[],"mappings":";;;;;;;;AAQA;;GAEG;AACH;IAOI;;;OAGG;IACH,oBAHW,OAAO,oBAAoB,EAAE,UAAU,QACvC,OAAO,oBAAoB,EAAE,OAAO,EA2C9C;IAnDD,uBAAuB;IACvB,iBADW,MAAM,EAAE,CACE;IAErB,8CAA8C;IAC9C,sBAAkB;IAgBd,gDAAgC;IAMhC,YAIE;IAEF,qDAIC;IAED,mDAAyC;IAe7C;;;;OAIG;IACH,wBAFW,MAAM,EAAE,iBAwBlB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,EAAE,kBACR,MAAM,iBAchB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,SACR,MAAM;;;;;;;;;OAmChB;CACJ;iCArJgC,wBAAwB;uBAJlC,WAAW"}