core-3nweb-client-lib 0.20.9 → 0.23.0

package/build/lib-client/files/file-layout.js

@@ -1,456 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2020 3NSoft Inc.
- 
- This program is free software: you can redistribute it and/or modify it under
- the terms of the GNU General Public License as published by the Free Software
- Foundation, either version 3 of the License, or (at your option) any later
- version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- See the GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fileLayoutException = exports.RWFileLayout = exports.ROFileLayout = void 0;
-const assert_1 = require("../../lib-common/assert");
-const big_endian_1 = require("../../lib-common/big-endian");
-const json_utils_1 = require("../../lib-common/json-utils");
-class ROFileLayout {
-    constructor(sections, layoutOfs) {
-        this.sections = sections;
-        this.layoutOfs = layoutOfs;
-        Object.freeze(this);
-    }
-    static orderedWithSize(size) {
-        return new ROFileLayout(continuousSections(size), size);
-    }
-    static async readFromSrc(src, layoutOfs) {
-        const sections = await readSectionsFrom(src, layoutOfs);
-        return new ROFileLayout(sections, layoutOfs);
-    }
-    get contentSize() {
-        return sizeOfSections(this.sections);
-    }
-    getSectionsIn(ofs, len) {
-        return getSectionsIn(this.sections, ofs, len);
-    }
-    makeWritableClone() {
-        return new RWFileLayout(json_utils_1.copy(this.sections), this.layoutOfs);
-    }
-}
-exports.ROFileLayout = ROFileLayout;
-Object.freeze(ROFileLayout.prototype);
-Object.freeze(ROFileLayout);
-function sizeOfSections(sections) {
-    if (sections.length === 0) {
-        return 0;
-    }
-    const last = sections[sections.length - 1];
-    return (last.ofs + last.len);
-}
-function continuousSections(size) {
-    assert_1.assert(Number.isInteger(size) && (size >= 0));
-    return ((size === 0) ? [] : [{ ofsInSrc: 0, ofs: 0, len: size }]);
-}
-function getSectionsIn(sections, ofs, len) {
-    assert_1.assert(Number.isInteger(ofs) && (ofs >= 0));
-    assert_1.assert((len === undefined) || (Number.isInteger(len) && (len >= 0)));
-    const contentSize = sizeOfSections(sections);
-    if ((contentSize <= ofs) || (len === 0)) {
-        return [];
-    }
-    const fstInd = sections.findIndex(s => ((s.ofs <= ofs) && (ofs < (s.ofs + s.len))));
-    const s = [copySectionMovingOfs(sections[fstInd], ofs)];
-    const end = ((len === undefined) ? undefined : ofs + len);
-    const lastInd = (((end === undefined) || (end >= contentSize)) ?
-        sections.length - 1 :
-        sections.findIndex(s => (end <= (s.ofs + s.len))));
-    for (let i = (fstInd + 1); i <= lastInd; i += 1) {
-        s.push(json_utils_1.copy(sections[i]));
-    }
-    if (end !== undefined) {
-        const last = s[s.length - 1];
-        const sEnd = last.ofs + last.len;
-        if (end < sEnd) {
-            last.len -= sEnd - end;
-        }
-    }
-    return s;
-}
-/**
- * This layout expects that writes of new bytes always append raw source,
- * while cuts in raw source remove base bytes, but don't remove already written
- * new bytes, leaving them as noise.
- */
-class RWFileLayout {
-    constructor(sections, srcBaseLen) {
-        this.sections = sections;
-        this.srcBaseLen = srcBaseLen;
-        this.writePosition = this.srcBaseLen;
-        Object.seal(this);
-    }
-    static orderedWithBaseSize(size) {
-        return new RWFileLayout(continuousSections(size), size);
-    }
-    static async readFromSrc(src, layoutOfs) {
-        const sections = await readSectionsFrom(src, layoutOfs);
-        return new RWFileLayout(sections, layoutOfs);
-    }
-    get contentSize() {
-        return sizeOfSections(this.sections);
-    }
-    getSectionsIn(ofs, len) {
-        return getSectionsIn(this.sections, ofs, len);
-    }
-    getLayoutOfsInSink() {
-        return this.writePosition;
-    }
-    packIfNotTrivial(sinkLen) {
-        return (this.isTrivialLayout(sinkLen.size, sinkLen.isEndless) ?
-            undefined : packSections(this.sections));
-    }
-    isTrivialLayout(sinkSize, isSinkEndless) {
-        if (isSinkEndless) {
-            return false;
-        }
-        if (this.sections.length === 0) {
-            return (sinkSize === 0);
-        }
-        else if (this.sections.length === 1) {
-            const s = this.sections[0];
-            return ((s.ofsInSrc === 0) && (s.ofs === 0) && (s.len === sinkSize));
-        }
-        else {
-            return false;
-        }
-    }
-    toFileLayoutBasedOnSegs(segs) {
-        const l = { sections: [] };
-        if (typeof segs.base !== 'number') {
-            l.base = segs.base;
-        }
-        for (const s of this.sections) {
-            if (typeof s.ofsInSrc === 'number') {
-                l.sections.push(...contentSectionsInSegs(segs.sections, s.ofsInSrc, s.ofs, s.len));
-            }
-            else {
-                l.sections.push({ src: 'empty', ofs: s.ofs, len: s.len });
-            }
-        }
-        compressLayoutSections(l.sections);
-        return l;
-    }
-    findOffsetPosition(ofs) {
-        for (let ind = 0; ind < this.sections.length; ind += 1) {
-            const s = this.sections[ind];
-            if ((s.ofs <= ofs) && (ofs < (s.ofs + s.len))) {
-                return { s, ind, sOfs: ofs - s.ofs };
-            }
-        }
-        return;
-    }
-    cutSection(ofs, len) {
-        const left = this.findOffsetPosition(ofs);
-        if (!left) {
-            return [];
-        }
-        const right = this.findOffsetPosition(ofs + len);
-        if (!right) {
-            let cuts;
-            if (left.sOfs === 0) {
-                cuts = this.sections.splice(left.ind, this.sections.length);
-            }
-            else {
-                cuts = this.sections.splice(left.ind + 1, this.sections.length);
-                const cutOnLeft = cutTailOf(left.s, left.sOfs);
-                cuts.push(cutOnLeft);
-            }
-            return this.turnToBaseCutsAdjustingSrcOfs(cuts);
-        }
-        if (left.s === right.s) {
-            let cuts;
-            if (left.sOfs === 0) {
-                cuts = [cutHeadOf(left.s, right.sOfs)];
-                this.shiftSectonOffsets(left.ind, -len);
-            }
-            else {
-                const newRight = cutTailOf(left.s, right.sOfs);
-                cuts = [cutTailOf(left.s, left.sOfs)];
-                this.sections.splice(left.ind + 1, 0, newRight);
-                this.shiftSectonOffsets(left.ind + 1, -len);
-            }
-            this.checkAndCompactFourSections(Math.max(left.ind - 1, 0));
-            return this.turnToBaseCutsAdjustingSrcOfs(cuts);
-        }
-        let cuts;
-        if (left.sOfs === 0) {
-            cuts = this.sections.splice(left.ind, right.ind - left.ind);
-            if (right.sOfs > 0) {
-                const cutOnRight = cutHeadOf(right.s, right.sOfs);
-                cuts.push(cutOnRight);
-            }
-            this.shiftSectonOffsets(left.ind, -len);
-        }
-        else {
-            cuts = this.sections.splice(left.ind + 1, right.ind - left.ind - 1);
-            const cutOnLeft = cutTailOf(left.s, left.sOfs);
-            cuts.push(cutOnLeft);
-            if (right.sOfs > 0) {
-                const cutOnRight = cutHeadOf(right.s, right.sOfs);
-                cuts.push(cutOnRight);
-            }
-            this.shiftSectonOffsets(left.ind + 1, -len);
-        }
-        this.checkAndCompactFourSections(Math.max(left.ind - 1, 0));
-        return this.turnToBaseCutsAdjustingSrcOfs(cuts);
-    }
-    shiftSectonOffsets(fromInd, delta) {
-        for (let i = fromInd; i < this.sections.length; i += 1) {
-            this.sections[i].ofs += delta;
-        }
-    }
-    turnToBaseCutsAdjustingSrcOfs(cuts) {
-        const baseSections = [];
-        let totalCutLen = 0;
-        for (const s of cuts) {
-            if ((typeof s.ofsInSrc === 'number')
-                && (s.ofsInSrc < this.srcBaseLen)) {
-                const cut = {
-                    len: Math.min(s.len, this.srcBaseLen - s.ofsInSrc),
-                    ofs: s.ofsInSrc
-                };
-                baseSections.push(cut);
-                totalCutLen += cut.len;
-            }
-        }
-        this.srcBaseLen -= totalCutLen;
-        this.writePosition -= totalCutLen;
-        assert_1.assert(this.srcBaseLen >= 0);
-        for (const b of baseSections) {
-            for (const s of this.sections) {
-                if ((typeof s.ofsInSrc === 'number') && (b.ofs < s.ofsInSrc)) {
-                    s.ofsInSrc -= b.len;
-                    assert_1.assert(s.ofsInSrc >= 0);
-                }
-            }
-        }
-        return baseSections;
-    }
-    checkAndCompactFourSections(startInd) {
-        for (let i = 0; i < 3; i += 1) {
-            const leftInd = startInd + i;
-            const rightInd = leftInd + 1;
-            if (rightInd >= this.sections.length) {
-                return;
-            }
-            const left = this.sections[leftInd];
-            const right = this.sections[rightInd];
-            assert_1.assert(((left.ofs + left.len) === right.ofs) && (right.len > 0));
-            if (left.ofsInSrc === undefined) {
-                if (right.ofsInSrc !== undefined) {
-                    continue;
-                }
-            }
-            else {
-                if ((right.ofsInSrc === undefined)
-                    || ((left.ofsInSrc + left.len) !== right.ofsInSrc)) {
-                    continue;
-                }
-            }
-            left.len += right.len;
-            this.sections.splice(rightInd, 1);
-            i -= 1;
-        }
-    }
-    appendEmptySection(len) {
-        if (this.sections.length > 0) {
-            const lastSec = this.sections[this.sections.length - 1];
-            if (typeof lastSec.ofsInSrc !== 'number') {
-                lastSec.len += len;
-            }
-            else {
-                this.sections.push({ ofs: (lastSec.ofs + lastSec.len), len });
-            }
-        }
-        else {
-            this.sections.push({ ofs: 0, len });
-        }
-    }
-    insertSection(ofs, len) {
-        const initContentSize = this.contentSize;
-        const ofsInSrc = this.writePosition;
-        this.writePosition += len;
-        // adding at the end
-        if (initContentSize <= ofs) {
-            const gapLen = ofs - initContentSize;
-            if (gapLen > 0) {
-                this.appendEmptySection(gapLen);
-            }
-            this.sections.push({ ofs, len, ofsInSrc });
-            if (this.sections.length >= 2) {
-                this.checkAndCompactFourSections(this.sections.length - 2);
-            }
-            return ofsInSrc;
-        }
-        // inserting inside
-        const insPos = this.findOffsetPosition(ofs);
-        if (!insPos) {
-            throw new Error(`Can't find ofs=${ofs} in sections`);
-        }
-        const newSection = { ofs, len, ofsInSrc };
-        if (insPos.sOfs === 0) {
-            this.sections.splice(insPos.ind, 0, newSection);
-            this.shiftSectonOffsets(insPos.ind + 1, len);
-        }
-        else {
-            const left = insPos.s;
-            const right = cutTailOf(left, insPos.sOfs);
-            this.sections.splice(insPos.ind + 1, 0, newSection, right);
-            this.shiftSectonOffsets(insPos.ind + 2, len);
-        }
-        this.checkAndCompactFourSections(Math.max(0, insPos.ind - 1));
-        return ofsInSrc;
-    }
-}
-exports.RWFileLayout = RWFileLayout;
-Object.freeze(RWFileLayout.prototype);
-Object.freeze(RWFileLayout);
-function cutHeadOf(s, sOfs) {
-    const head = {
-        len: sOfs,
-        ofs: s.ofs,
-        ofsInSrc: ((typeof s.ofsInSrc === 'number') ? s.ofsInSrc : undefined)
-    };
-    s.len -= head.len;
-    s.ofs += head.len;
-    if (typeof s.ofsInSrc === 'number') {
-        s.ofsInSrc += head.len;
-    }
-    return head;
-}
-function cutTailOf(s, sOfs) {
-    const tail = {
-        len: s.len - sOfs,
-        ofs: s.ofs + sOfs,
-        ofsInSrc: ((typeof s.ofsInSrc === 'number') ?
-            s.ofsInSrc + sOfs : undefined)
-    };
-    s.len = sOfs;
-    return tail;
-}
-function fileLayoutException(msg, cause) {
-    return {
-        runtimeException: true,
-        type: 'file-layout',
-        cause, msg
-    };
-}
-exports.fileLayoutException = fileLayoutException;
-async function readSectionsFrom(src, layoutOfs) {
-    const initPos = await src.getPosition();
-    await src.seek(layoutOfs);
-    const bytes = await src.read(undefined);
-    await src.seek(initPos);
-    if (!bytes) {
-        throw fileLayoutException(`Reading at layout offset ${layoutOfs} produces no bytes (EOF?)`);
-    }
-    return parseSectionsFrom(bytes);
-}
-function parseSectionsFrom(bytes) {
-    if (bytes.length < 8) {
-        throw fileLayoutException(`Array len ${bytes.length} is too short for layout parsing`);
-    }
-    const expectedLen = big_endian_1.uintFrom8Bytes(bytes, 0);
-    if ((bytes.length - 8) < expectedLen) {
-        throw fileLayoutException(`Array len ${bytes.length - 8} is shorter than expected layout ${expectedLen}`);
-    }
-    const sections = [];
-    let i = 8;
-    let ofs = 0;
-    while (i < bytes.length) {
-        const ofsInStr = uintOrUndefinedFrom8Bytes(bytes, i);
-        i += 8;
-        const len = big_endian_1.uintFrom8Bytes(bytes, i);
-        i += 8;
-        sections.push({ ofsInSrc: ofsInStr, len, ofs });
-        ofs += len;
-    }
-    return sections;
-}
-function packSections(sections) {
-    const sectionsPackLen = 16 * sections.length;
-    const bytes = Buffer.allocUnsafe(8 + sectionsPackLen);
-    big_endian_1.packUintTo8Bytes(sectionsPackLen, bytes, 0);
-    let i = 8;
-    for (const s of sections) {
-        packUintOrUndefinedInto8Bytes(s.ofsInSrc, bytes, i);
-        i += 8;
-        big_endian_1.packUintTo8Bytes(s.len, bytes, i);
-        i += 8;
-    }
-    return bytes;
-}
-const UNINIT_OFS_VALUE = Buffer.alloc(8, 0xff);
-function uintOrUndefinedFrom8Bytes(bytes, i) {
-    for (let b = 0; b < 8; b += 1) {
-        if (bytes[i + b] !== 0xff) {
-            return big_endian_1.uintFrom8Bytes(bytes, i);
-        }
-    }
-    return;
-}
-function packUintOrUndefinedInto8Bytes(u, bytes, i) {
-    if (typeof u === 'number') {
-        big_endian_1.packUintTo8Bytes(u, bytes, i);
-    }
-    else {
-        bytes.set(UNINIT_OFS_VALUE, i);
-    }
-}
-function copySectionMovingOfs(sec, newOfs) {
-    const ofsDelta = newOfs - sec.ofs;
-    const copy = {
-        ofs: newOfs,
-        len: sec.len - ofsDelta,
-    };
-    if (typeof sec.ofsInSrc === 'number') {
-        copy.ofsInSrc = sec.ofsInSrc + ofsDelta;
-    }
-    return copy;
-}
-function contentSectionsInSegs(segs, segsOfs, contentOfs, contentLen) {
-    const fstSegInd = segs.findIndex(s => (typeof s.len !== 'number') || (segsOfs < (s.ofs + s.len)));
-    assert_1.assert(fstSegInd >= 0);
-    let i = fstSegInd;
-    const ls = [];
-    while (contentLen > 0) {
-        const seg = segs[i];
-        const len = (typeof seg.len !== 'number') ?
-            contentLen : Math.min(contentLen, seg.len);
-        ls.push({ src: seg.src, ofs: contentOfs, len });
-        contentOfs += len;
-        contentLen -= len;
-        i += 1;
-    }
-    return ls;
-}
-function compressLayoutSections(sections) {
-    if (sections.length === 0) {
-        return;
-    }
-    let prev = sections[0];
-    for (let i = 1; i < sections.length; i += 1) {
-        const s = sections[i];
-        if (prev.src === s.src) {
-            prev.len += s.len;
-            sections.splice(i, 1);
-            i -= 1;
-        }
-        prev = s;
-    }
-}
-Object.freeze(exports);

package/build/lib-client/files/file-sink.d.ts

@@ -1,33 +0,0 @@
-import { FileAttrs, AttrsHolder } from "./file-attrs";
-import { RWFileLayout } from "./file-layout";
-import { ByteSinkWithAttrs } from "xsp-files";
-declare type FileByteSink = web3n.files.FileByteSink;
-declare type FileLayout = web3n.files.FileLayout;
-/**
- * This implementation of a sink will put new bytes at the end of the raw sink.
- * Mapping from out-of-order writes to linear recording is captured in file
- * layout that is recorded after all bytes are written and placed at after all
- * bytes. Layout offset is written into attributes. If file layout is trivial,
- * i.e. all positions in raw sink correspond to file positions, it isn't written
- * and attributes have no layout offset.
- */
-export declare class FileSink implements FileByteSink {
-    private readonly rawSink;
-    private readonly layout;
-    private readonly attrs;
-    private err;
-    private isDone;
-    private constructor();
-    static from(sink: ByteSinkWithAttrs, attrs: AttrsHolder<FileAttrs>, layout: RWFileLayout): Promise<FileByteSink>;
-    getSize(): Promise<number>;
-    private throwUpIfDone;
-    private errThis;
-    showLayout(): Promise<FileLayout>;
-    truncate(size: number): Promise<void>;
-    splice(pos: number, del: number, bytes?: Uint8Array): Promise<void>;
-    private appendContentToRawSink;
-    private deleteBytes;
-    done(err?: any): Promise<void>;
-    private saveLayoutAndAttrs;
-}
-export {};

package/build/lib-client/files/file-sink.js

@@ -1,173 +0,0 @@
-"use strict";
-/*
- Copyright (C) 2020 3NSoft Inc.
- 
- This program is free software: you can redistribute it and/or modify it under
- the terms of the GNU General Public License as published by the Free Software
- Foundation, either version 3 of the License, or (at your option) any later
- version.
- 
- This program is distributed in the hope that it will be useful, but
- WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
- See the GNU General Public License for more details.
- 
- You should have received a copy of the GNU General Public License along with
- this program. If not, see <http://www.gnu.org/licenses/>. */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSink = void 0;
-const wrapping_1 = require("../../lib-common/byte-streaming/wrapping");
-const assert_1 = require("../../lib-common/assert");
-const error_1 = require("../../lib-common/exceptions/error");
-/**
- * This implementation of a sink will put new bytes at the end of the raw sink.
- * Mapping from out-of-order writes to linear recording is captured in file
- * layout that is recorded after all bytes are written and placed at after all
- * bytes. Layout offset is written into attributes. If file layout is trivial,
- * i.e. all positions in raw sink correspond to file positions, it isn't written
- * and attributes have no layout offset.
- */
-class FileSink {
-    constructor(rawSink, layout, attrs) {
-        this.rawSink = rawSink;
-        this.layout = layout;
-        this.attrs = attrs;
-        this.err = undefined;
-        this.isDone = false;
-        Object.seal(this);
-    }
-    static async from(sink, attrs, layout) {
-        await sink.setAttrSectionSize(attrs.serializedLen);
-        await sink.setSize(layout.getLayoutOfsInSink());
-        const fileSink = new FileSink(sink, layout, attrs);
-        return wrapping_1.wrapAndSyncFileSink(fileSink);
-    }
-    async getSize() {
-        return this.layout.contentSize;
-    }
-    throwUpIfDone() {
-        if (this.isDone) {
-            if (this.err) {
-                throw error_1.errWithCause(this.err, `File sink has already erred`);
-            }
-            else {
-                throw new Error(`File sink is already done`);
-            }
-        }
-    }
-    async errThis(err) {
-        if (this.err) {
-            return;
-        }
-        this.err = err;
-        await this.rawSink.done(this.err);
-        this.isDone = true;
-    }
-    async showLayout() {
-        const segs = await this.rawSink.showLayout();
-        return this.layout.toFileLayoutBasedOnSegs(segs);
-    }
-    async truncate(size) {
-        assert_1.assert(Number.isInteger(size) && (size >= 0), `Invalid size given: ${size}`);
-        this.throwUpIfDone();
-        try {
-            const delta = size - this.layout.contentSize;
-            if (delta < 0) {
-                await this.deleteBytes(size, -delta);
-            }
-            else if (delta > 0) {
-                this.layout.appendEmptySection(delta);
-            }
-        }
-        catch (err) {
-            await this.errThis(err);
-            throw err;
-        }
-    }
-    async splice(pos, del, bytes) {
-        assert_1.assert(Number.isInteger(pos) && (pos >= 0)
-            && Number.isInteger(del) && (del >= 0), `Invalid arguments given: pos=${pos}, del=${del}`);
-        this.throwUpIfDone();
-        const ins = (bytes ? bytes.length : 0);
-        if ((del === 0) && (ins === 0)) {
-            return;
-        }
-        try {
-            if (this.layout.contentSize <= pos) {
-                if (ins === 0) {
-                    return;
-                }
-                await this.appendContentToRawSink(pos, bytes);
-            }
-            else {
-                if (del > 0) {
-                    await this.deleteBytes(pos, del);
-                }
-                if (ins > 0) {
-                    await this.appendContentToRawSink(pos, bytes);
-                }
-            }
-        }
-        catch (err) {
-            await this.errThis(err);
-            throw err;
-        }
-    }
-    async appendContentToRawSink(pos, bytes) {
-        const ins = bytes.length;
-        const writePosition = this.layout.insertSection(pos, ins);
-        await this.rawSink.spliceLayout(writePosition, ins, ins);
-        await this.rawSink.write(writePosition, bytes);
-    }
-    async deleteBytes(pos, len) {
-        // Note 1: only  base section are given for removal from sink. New bytes
-        // become noise, cause we can't reliably splice them.
-        // Note 2: there are no explicit records for noise sections, cause this
-        // information is recoverable.
-        const rmSegs = this.layout.cutSection(pos, len);
-        if (rmSegs.length === 0) {
-            return;
-        }
-        rmSegs.sort((a, b) => a.ofs - b.ofs);
-        for (let i = (rmSegs.length - 1); i >= 0; i -= 1) {
-            const s = rmSegs[i];
-            await this.rawSink.spliceLayout(s.ofs, s.len, 0);
-        }
-    }
-    async done(err) {
-        if (this.isDone) {
-            if (!err && this.err) {
-                throw error_1.errWithCause(this.err, `File sink has already erred`);
-            }
-            return;
-        }
-        if (err) {
-            await this.errThis(err);
-            return;
-        }
-        await this.saveLayoutAndAttrs().catch(async (err) => {
-            await this.errThis(err);
-            throw err;
-        });
-        await this.rawSink.done();
-        this.isDone = true;
-    }
-    async saveLayoutAndAttrs() {
-        const sinkLen = await this.rawSink.getSize();
-        const layoutOfs = this.layout.getLayoutOfsInSink();
-        const bytes = this.layout.packIfNotTrivial(sinkLen);
-        if (bytes) {
-            this.attrs.setFileLayoutOfs(layoutOfs);
-            await this.rawSink.setSize(layoutOfs + bytes.length);
-            await this.rawSink.write(layoutOfs, bytes);
-        }
-        else {
-            this.attrs.setContinuousFileSize(layoutOfs);
-        }
-        await this.rawSink.writeAttrs(this.attrs.toBytes());
-    }
-}
-exports.FileSink = FileSink;
-Object.freeze(FileSink.prototype);
-Object.freeze(FileSink);
-Object.freeze(exports);

package/build/lib-client/files/file-source.d.ts

@@ -1,19 +0,0 @@
-import { AttrsHolder, FileAttrs } from "./file-attrs";
-import { ByteSource } from "xsp-files";
-declare type FileByteSource = web3n.files.FileByteSource;
-declare type FileSection = web3n.files.FileSection;
-export declare class FileBytes implements FileByteSource {
-    private readonly rawSrc;
-    private readonly layout;
-    private pos;
-    private constructor();
-    static from(src: ByteSource, attrs: AttrsHolder<FileAttrs> | undefined): Promise<FileByteSource>;
-    getFileSections(ofs: number, len: number): FileSection[];
-    read(len: number | undefined): Promise<Uint8Array | undefined>;
-    private getSectionBytes;
-    getSize(): Promise<number>;
-    seek(offset: number): Promise<void>;
-    getPosition(): Promise<number>;
-}
-export declare function fileSrcFromContinuousSrc(src: ByteSource): FileByteSource;
-export {};