@gmod/bbi 1.0.30 → 1.0.31

package/esm/blockView.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockView = void 0;
+const binary_parser_1 = require("@gmod/binary-parser");
+const abortable_promise_cache_1 = __importDefault(require("abortable-promise-cache"));
+const zlib_1 = __importDefault(require("zlib"));
+const quick_lru_1 = __importDefault(require("quick-lru"));
+const range_1 = __importDefault(require("./range"));
+const util_1 = require("./util");
+const BIG_WIG_TYPE_GRAPH = 1;
+const BIG_WIG_TYPE_VSTEP = 2;
+const BIG_WIG_TYPE_FSTEP = 3;
+function getParsers(isBigEndian) {
+    const le = isBigEndian ? 'big' : 'little';
+    const summaryParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint32('chromId')
+        .uint32('start')
+        .uint32('end')
+        .uint32('validCnt')
+        .float('minScore')
+        .float('maxScore')
+        .float('sumData')
+        .float('sumSqData');
+    const leafParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint8('isLeaf')
+        .skip(1)
+        .uint16('cnt')
+        .choice({
+        tag: 'isLeaf',
+        choices: {
+            1: new binary_parser_1.Parser().array('blocksToFetch', {
+                length: 'cnt',
+                type: new binary_parser_1.Parser()
+                    .uint32('startChrom')
+                    .uint32('startBase')
+                    .uint32('endChrom')
+                    .uint32('endBase')
+                    .uint64('blockOffset')
+                    .uint64('blockSize'),
+            }),
+            0: new binary_parser_1.Parser().array('recurOffsets', {
+                length: 'cnt',
+                type: new binary_parser_1.Parser()
+                    .uint32('startChrom')
+                    .uint32('startBase')
+                    .uint32('endChrom')
+                    .uint32('endBase')
+                    .uint64('blockOffset'),
+            }),
+        },
+    });
+    const bigBedParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .uint32('chromId')
+        .int32('start')
+        .int32('end')
+        .string('rest', {
+        zeroTerminated: true,
+    });
+    const bigWigParser = new binary_parser_1.Parser()
+        .endianess(le)
+        .skip(4)
+        .int32('blockStart')
+        .skip(4)
+        .uint32('itemStep')
+        .uint32('itemSpan')
+        .uint8('blockType')
+        .skip(1)
+        .uint16('itemCount')
+        .choice({
+        tag: 'blockType',
+        choices: {
+            [BIG_WIG_TYPE_FSTEP]: new binary_parser_1.Parser().array('items', {
+                length: 'itemCount',
+                type: new binary_parser_1.Parser().float('score'),
+            }),
+            [BIG_WIG_TYPE_VSTEP]: new binary_parser_1.Parser().array('items', {
+                length: 'itemCount',
+                type: new binary_parser_1.Parser().int32('start').float('score'),
+            }),
+            [BIG_WIG_TYPE_GRAPH]: new binary_parser_1.Parser().array('items', {
+                length: 'itemCount',
+                type: new binary_parser_1.Parser().int32('start').int32('end').float('score'),
+            }),
+        },
+    });
+    return {
+        bigWigParser,
+        bigBedParser,
+        summaryParser,
+        leafParser,
+    };
+}
+/**
+ * View into a subset of the data in a BigWig file.
+ *
+ * Adapted by Robert Buels and Colin Diesh from bigwig.js in the Dalliance Genome
+ * Explorer by Thomas Down.
+ * @constructs
+ */
+class BlockView {
+    constructor(bbi, refsByName, cirTreeOffset, cirTreeLength, isBigEndian, isCompressed, blockType) {
+        this.featureCache = new abortable_promise_cache_1.default({
+            cache: new quick_lru_1.default({ maxSize: 1000 }),
+            fill: async (requestData, signal) => {
+                const { length, offset } = requestData;
+                const { buffer } = await this.bbi.read(Buffer.alloc(length), 0, length, offset, { signal });
+                return buffer;
+            },
+        });
+        if (!(cirTreeOffset >= 0)) {
+            throw new Error('invalid cirTreeOffset!');
+        }
+        if (!(cirTreeLength > 0)) {
+            throw new Error('invalid cirTreeLength!');
+        }
+        this.cirTreeOffset = cirTreeOffset;
+        this.cirTreeLength = cirTreeLength;
+        this.isCompressed = isCompressed;
+        this.refsByName = refsByName;
+        this.isBigEndian = isBigEndian;
+        this.bbi = bbi;
+        this.blockType = blockType;
+        Object.assign(this, getParsers(isBigEndian));
+    }
+    async readWigData(chrName, start, end, observer, opts) {
+        try {
+            const { refsByName, bbi, cirTreeOffset, isBigEndian } = this;
+            const { signal } = opts;
+            const chrId = refsByName[chrName];
+            if (chrId === undefined) {
+                observer.complete();
+            }
+            const request = { chrId, start, end };
+            if (!this.cirTreePromise) {
+                this.cirTreePromise = bbi.read(Buffer.alloc(48), 0, 48, cirTreeOffset, {
+                    signal,
+                });
+            }
+            const { buffer } = await this.cirTreePromise;
+            const cirBlockSize = isBigEndian
+                ? buffer.readUInt32BE(4)
+                : buffer.readUInt32LE(4);
+            let blocksToFetch = [];
+            let outstanding = 0;
+            //eslint-disable-next-line prefer-const
+            let cirFobRecur2;
+            const filterFeats = (b) => (b.startChrom < chrId ||
+                (b.startChrom === chrId && b.startBase <= end)) &&
+                (b.endChrom > chrId || (b.endChrom === chrId && b.endBase >= start));
+            const cirFobStartFetch = async (off, fr, level) => {
+                try {
+                    const length = fr.max() - fr.min();
+                    const offset = fr.min();
+                    const resultBuffer = await this.featureCache.get(`${length}_${offset}`, { length, offset }, signal);
+                    for (let i = 0; i < off.length; i += 1) {
+                        if (fr.contains(off[i])) {
+                            cirFobRecur2(resultBuffer, off[i] - offset, level, observer, opts);
+                            outstanding -= 1;
+                            if (outstanding === 0) {
+                                this.readFeatures(observer, blocksToFetch, { ...opts, request });
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    observer.error(e);
+                }
+            };
+            const cirFobRecur = (offset, level) => {
+                try {
+                    outstanding += offset.length;
+                    const maxCirBlockSpan = 4 + cirBlockSize * 32; // Upper bound on size, based on a completely full leaf node.
+                    let spans = new range_1.default(offset[0], offset[0] + maxCirBlockSpan);
+                    for (let i = 1; i < offset.length; i += 1) {
+                        const blockSpan = new range_1.default(offset[i], offset[i] + maxCirBlockSpan);
+                        spans = spans.union(blockSpan);
+                    }
+                    spans
+                        .getRanges()
+                        .map((fr) => cirFobStartFetch(offset, fr, level));
+                }
+                catch (e) {
+                    observer.error(e);
+                }
+            };
+            cirFobRecur2 = (cirBlockData, offset, level) => {
+                try {
+                    const data = cirBlockData.slice(offset);
+                    const p = this.leafParser.parse(data).result;
+                    if (p.blocksToFetch) {
+                        blocksToFetch = blocksToFetch.concat(p.blocksToFetch.filter(filterFeats).map((l) => ({
+                            offset: l.blockOffset,
+                            length: l.blockSize,
+                        })));
+                    }
+                    if (p.recurOffsets) {
+                        const recurOffsets = p.recurOffsets
+                            .filter(filterFeats)
+                            .map((l) => l.blockOffset);
+                        if (recurOffsets.length > 0) {
+                            cirFobRecur(recurOffsets, level + 1);
+                        }
+                    }
+                }
+                catch (e) {
+                    observer.error(e);
+                }
+            };
+            return cirFobRecur([cirTreeOffset + 48], 1);
+        }
+        catch (e) {
+            observer.error(e);
+        }
+    }
+    parseSummaryBlock(data, startOffset, request) {
+        const features = [];
+        let currOffset = startOffset;
+        while (currOffset < data.byteLength) {
+            const res = this.summaryParser.parse(data.slice(currOffset));
+            features.push(res.result);
+            currOffset += res.offset;
+        }
+        let items = features;
+        if (request) {
+            items = items.filter((elt) => elt.chromId === request.chrId);
+        }
+        items = items.map((elt) => ({
+            start: elt.start,
+            end: elt.end,
+            maxScore: elt.maxScore,
+            minScore: elt.minScore,
+            score: elt.sumData / (elt.validCnt || 1),
+            summary: true,
+        }));
+        return request
+            ? items.filter(f => BlockView.coordFilter(f, request))
+            : items;
+    }
+    parseBigBedBlock(data, startOffset, offset, request) {
+        const items = [];
+        let currOffset = startOffset;
+        while (currOffset < data.byteLength) {
+            const res = this.bigBedParser.parse(data.slice(currOffset));
+            res.result.uniqueId = `bb-${offset + currOffset}`;
+            items.push(res.result);
+            currOffset += res.offset;
+        }
+        return request
+            ? items.filter((f) => BlockView.coordFilter(f, request))
+            : items;
+    }
+    parseBigWigBlock(bytes, startOffset, request) {
+        const data = bytes.slice(startOffset);
+        const results = this.bigWigParser.parse(data).result;
+        const { items, itemSpan, itemStep, blockStart, blockType } = results;
+        if (blockType === BIG_WIG_TYPE_FSTEP) {
+            for (let i = 0; i < items.length; i++) {
+                items[i].start = blockStart + i * itemStep;
+                items[i].end = blockStart + i * itemStep + itemSpan;
+            }
+        }
+        else if (blockType === BIG_WIG_TYPE_VSTEP) {
+            for (let i = 0; i < items.length; i++) {
+                items[i].end = items[i].start + itemSpan;
+            }
+        }
+        return request
+            ? items.filter((f) => BlockView.coordFilter(f, request))
+            : items;
+    }
+    static coordFilter(f, range) {
+        return f.start < range.end && f.end >= range.start;
+    }
+    async readFeatures(observer, blocks, opts = {}) {
+        try {
+            const { blockType, isCompressed } = this;
+            const { signal, request } = opts;
+            const blockGroupsToFetch = (0, util_1.groupBlocks)(blocks);
+            (0, util_1.checkAbortSignal)(signal);
+            await Promise.all(blockGroupsToFetch.map(async (blockGroup) => {
+                (0, util_1.checkAbortSignal)(signal);
+                const { length, offset } = blockGroup;
+                const data = await this.featureCache.get(`${length}_${offset}`, blockGroup, signal);
+                blockGroup.blocks.forEach((block) => {
+                    (0, util_1.checkAbortSignal)(signal);
+                    let blockOffset = block.offset - blockGroup.offset;
+                    let resultData = data;
+                    if (isCompressed) {
+                        resultData = zlib_1.default.inflateSync(data.slice(blockOffset));
+                        blockOffset = 0;
+                    }
+                    (0, util_1.checkAbortSignal)(signal);
+                    switch (blockType) {
+                        case 'summary':
+                            observer.next(this.parseSummaryBlock(resultData, blockOffset, request));
+                            break;
+                        case 'bigwig':
+                            observer.next(this.parseBigWigBlock(resultData, blockOffset, request));
+                            break;
+                        case 'bigbed':
+                            observer.next(this.parseBigBedBlock(resultData, blockOffset, 
+                            // eslint-disable-next-line no-bitwise
+                            block.offset * (1 << 8), request));
+                            break;
+                        default:
+                            console.warn(`Don't know what to do with ${blockType}`);
+                    }
+                });
+            }));
+            observer.complete();
+        }
+        catch (e) {
+            observer.error(e);
+        }
+    }
+}
+exports.BlockView = BlockView;

package/esm/index.d.ts

@@ -0,0 +1,3 @@
+export { BigWig } from './bigwig';
+export { BigBed } from './bigbed';
+export { Feature, Header, RequestOptions } from './bbi';

package/esm/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigBed = exports.BigWig = void 0;
+var bigwig_1 = require("./bigwig");
+Object.defineProperty(exports, "BigWig", { enumerable: true, get: function () { return bigwig_1.BigWig; } });
+var bigbed_1 = require("./bigbed");
+Object.defineProperty(exports, "BigBed", { enumerable: true, get: function () { return bigbed_1.BigBed; } });

package/esm/range.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Adapted from a combination of Range and _Compound in the
+ * Dalliance Genome Explorer, (c) Thomas Down 2006-2010.
+ */
+export default class Range {
+    ranges: any;
+    constructor(arg1: any, arg2?: any);
+    min(): number;
+    max(): number;
+    contains(pos: number): boolean;
+    isContiguous(): boolean;
+    getRanges(): Range[];
+    toString(): string;
+    union(s1: Range): Range;
+    intersection(arg: Range): Range;
+    coverage(): number;
+    rangeOrder(tmpa: Range, tmpb: Range): number;
+}

package/esm/range.js

@@ -0,0 +1,126 @@
+"use strict";
+/* eslint prefer-rest-params:0, no-nested-ternary:0 */
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Adapted from a combination of Range and _Compound in the
+ * Dalliance Genome Explorer, (c) Thomas Down 2006-2010.
+ */
+class Range {
+    constructor(arg1, arg2) {
+        this.ranges =
+            arguments.length === 2
+                ? [{ min: arg1, max: arg2 }]
+                : 0 in arg1
+                    ? Object.assign({}, arg1)
+                    : [arg1];
+    }
+    min() {
+        return this.ranges[0].min;
+    }
+    max() {
+        return this.ranges[this.ranges.length - 1].max;
+    }
+    contains(pos) {
+        for (let s = 0; s < this.ranges.length; s += 1) {
+            const r = this.ranges[s];
+            if (r.min <= pos && r.max >= pos) {
+                return true;
+            }
+        }
+        return false;
+    }
+    isContiguous() {
+        return this.ranges.length > 1;
+    }
+    getRanges() {
+        return this.ranges.map((r) => new Range(r.min, r.max));
+    }
+    toString() {
+        return this.ranges.map((r) => `[${r.min}-${r.max}]`).join(',');
+    }
+    union(s1) {
+        const ranges = this.getRanges().concat(s1.getRanges()).sort(this.rangeOrder);
+        const oranges = [];
+        let current = ranges[0];
+        for (let i = 1; i < ranges.length; i += 1) {
+            const nxt = ranges[i];
+            if (nxt.min() > current.max() + 1) {
+                oranges.push(current);
+                current = nxt;
+            }
+            else if (nxt.max() > current.max()) {
+                current = new Range(current.min(), nxt.max());
+            }
+        }
+        oranges.push(current);
+        if (oranges.length === 1) {
+            return oranges[0];
+        }
+        return new Range(oranges);
+    }
+    intersection(arg) {
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let s0 = this;
+        let s1 = arg;
+        const r0 = this.ranges();
+        const r1 = s1.ranges();
+        const l0 = r0.length;
+        const l1 = r1.length;
+        let i0 = 0;
+        let i1 = 0;
+        const or = [];
+        while (i0 < l0 && i1 < l1) {
+            s0 = r0[i0];
+            s1 = r1[i1];
+            const lapMin = Math.max(s0.min(), s1.min());
+            const lapMax = Math.min(s0.max(), s1.max());
+            if (lapMax >= lapMin) {
+                or.push(new Range(lapMin, lapMax));
+            }
+            if (s0.max() > s1.max()) {
+                i1 += 1;
+            }
+            else {
+                i0 += 1;
+            }
+        }
+        if (or.length === 0) {
+            throw new Error('found range of length 0');
+        }
+        if (or.length === 1) {
+            return or[0];
+        }
+        return new Range(or);
+    }
+    coverage() {
+        let tot = 0;
+        const rl = this.ranges();
+        for (let ri = 0; ri < rl.length; ri += 1) {
+            const r = rl[ri];
+            tot += r.max() - r.min() + 1;
+        }
+        return tot;
+    }
+    rangeOrder(tmpa, tmpb) {
+        let a = tmpa;
+        let b = tmpb;
+        if (arguments.length < 2) {
+            b = a;
+            a = this;
+        }
+        if (a.min() < b.min()) {
+            return -1;
+        }
+        if (a.min() > b.min()) {
+            return 1;
+        }
+        if (a.max() < b.max()) {
+            return -1;
+        }
+        if (b.max() > a.max()) {
+            return 1;
+        }
+        return 0;
+    }
+}
+exports.default = Range;

package/esm/util.d.ts

@@ -0,0 +1,24 @@
+export declare class AbortError extends Error {
+    code: string;
+    constructor(message: string);
+}
+export declare function groupBlocks(blocks: any[]): any[];
+/**
+ * Properly check if the given AbortSignal is aborted.
+ * Per the standard, if the signal reads as aborted,
+ * this function throws either a DOMException AbortError, or a regular error
+ * with a `code` attribute set to `ERR_ABORTED`.
+ *
+ * For convenience, passing `undefined` is a no-op
+ *
+ * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
+ * @returns nothing
+ */
+export declare function checkAbortSignal(signal?: AbortSignal): void;
+/**
+ * Skips to the next tick, then runs `checkAbortSignal`.
+ * Await this to inside an otherwise synchronous loop to
+ * provide a place to break when an abort signal is received.
+ * @param {AbortSignal} signal
+ */
+export declare function abortBreakPoint(signal?: AbortSignal): Promise<void>;

package/esm/util.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.abortBreakPoint = exports.checkAbortSignal = exports.groupBlocks = exports.AbortError = void 0;
+/* eslint no-bitwise: ["error", { "allow": ["|"] }] */
+class AbortError extends Error {
+    constructor(message) {
+        super(message);
+        this.code = 'ERR_ABORTED';
+    }
+}
+exports.AbortError = AbortError;
+// sort blocks by file offset and
+// group blocks that are within 2KB of eachother
+function groupBlocks(blocks) {
+    blocks.sort((b0, b1) => (b0.offset | 0) - (b1.offset | 0));
+    const blockGroups = [];
+    let lastBlock;
+    let lastBlockEnd;
+    for (let i = 0; i < blocks.length; i += 1) {
+        if (lastBlock && blocks[i].offset - lastBlockEnd <= 2000) {
+            lastBlock.length += blocks[i].length - lastBlockEnd + blocks[i].offset;
+            lastBlock.blocks.push(blocks[i]);
+        }
+        else {
+            blockGroups.push((lastBlock = {
+                blocks: [blocks[i]],
+                length: blocks[i].length,
+                offset: blocks[i].offset,
+            }));
+        }
+        lastBlockEnd = lastBlock.offset + lastBlock.length;
+    }
+    return blockGroups;
+}
+exports.groupBlocks = groupBlocks;
+/**
+ * Properly check if the given AbortSignal is aborted.
+ * Per the standard, if the signal reads as aborted,
+ * this function throws either a DOMException AbortError, or a regular error
+ * with a `code` attribute set to `ERR_ABORTED`.
+ *
+ * For convenience, passing `undefined` is a no-op
+ *
+ * @param {AbortSignal} [signal] an AbortSignal, or anything with an `aborted` attribute
+ * @returns nothing
+ */
+function checkAbortSignal(signal) {
+    if (!signal) {
+        return;
+    }
+    if (signal.aborted) {
+        // console.log('bam aborted!')
+        if (typeof DOMException !== 'undefined') {
+            throw new DOMException('aborted', 'AbortError');
+        }
+        else {
+            const e = new AbortError('aborted');
+            e.code = 'ERR_ABORTED';
+            throw e;
+        }
+    }
+}
+exports.checkAbortSignal = checkAbortSignal;
+/**
+ * Skips to the next tick, then runs `checkAbortSignal`.
+ * Await this to inside an otherwise synchronous loop to
+ * provide a place to break when an abort signal is received.
+ * @param {AbortSignal} signal
+ */
+async function abortBreakPoint(signal) {
+    await Promise.resolve();
+    checkAbortSignal(signal);
+}
+exports.abortBreakPoint = abortBreakPoint;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@gmod/bbi",
-  "version": "1.0.30",
+  "version": "1.0.31",
   "description": "Parser for BigWig/BigBed files",
   "license": "MIT",
   "repository": "GMOD/bbi-js",
   "main": "dist/index.js",
+  "module": "esm/index.js",
   "author": {
     "name": "Colin Diesh",
     "email": "colin.diesh@gmail.com",
@@ -14,17 +15,16 @@
     "node": ">=6"
   },
   "files": [
-    "dist"
+    "dist",
+    "esm"
   ],
   "scripts": {
     "test": "jest",
     "coverage": "npm test -- --coverage",
     "lint": "eslint --report-unused-disable-directives --max-warnings 0 --ext .js,.ts src",
-    "clean": "rimraf dist",
+    "clean": "rimraf dist esm",
     "prebuild": "npm run clean",
-    "build:types": "tsc --emitDeclarationOnly",
-    "build:js": "babel src --out-dir dist --extensions \".ts,.tsx\" --source-maps inline",
-    "build": "npm run build:types && npm run build:js",
+    "build": "tsc --target es2018 --outDir esm && tsc --target es5 --outDir dist",
     "preversion": "npm run lint && npm test && npm run build",
     "version": "standard-changelog && git add CHANGELOG.md",
     "postpublish": "git push origin master --follow-tags"
@@ -38,9 +38,8 @@
     "genomics"
   ],
   "dependencies": {
-    "@babel/runtime": "^7.4.4",
-    "@gmod/binary-parser": "^1.3.5",
-    "abortable-promise-cache": "^1.0.1",
+    "@gmod/binary-parser": "^1.4.0",
+    "abortable-promise-cache": "^1.4.1",
     "buffer-crc32": "^0.2.13",
     "es6-promisify": "^6.0.1",
     "generic-filehandle": "^2.0.0",
@@ -48,32 +47,23 @@
     "rxjs": "^6.5.2"
   },
   "devDependencies": {
-    "@babel/cli": "^7.4.4",
-    "@babel/core": "^7.4.4",
-    "@babel/plugin-proposal-class-properties": "^7.4.4",
-    "@babel/plugin-transform-runtime": "^7.4.4",
-    "@babel/preset-env": "^7.4.4",
-    "@babel/preset-typescript": "^7.3.3",
     "@gmod/bed": "^2.0.0",
-    "@types/jest": "^24.0.13",
+    "@types/jest": "^27.0.3",
     "@types/long": "^4.0.0",
     "@types/node": "^12.0.2",
     "@typescript-eslint/eslint-plugin": "^2.0.0",
     "@typescript-eslint/parser": "^2.0.0",
-    "babel-eslint": "^10.0.1",
-    "babel-preset-typescript": "^7.0.0-alpha.19",
     "cross-fetch": "^3.0.2",
-    "eslint": "^5.16.0",
-    "eslint-config-airbnb-base": "^13.1.0",
-    "eslint-config-prettier": "^4.2.0",
-    "eslint-plugin-import": "^2.17.2",
-    "eslint-plugin-jest": "^22.5.1",
-    "eslint-plugin-prettier": "^3.1.0",
-    "jest": "^24.8.0",
-    "prettier": "^1.17.1",
+    "eslint": "^7.0.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.25.3",
+    "eslint-plugin-prettier": "^4.0.0",
+    "jest": "^27.4.3",
+    "prettier": "^2.5.1",
     "rimraf": "^2.6.3",
     "standard-changelog": "^2.0.11",
-    "typescript": "^3.4.5"
+    "ts-jest": "^27.0.7",
+    "typescript": "^4.5.2"
   },
   "publishConfig": {
     "access": "public"

package/dist/declares.d.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbXX0=