{"version":3,"sources":["jsdelivr-header.js","/npm/@ipld/unixfs@3.0.0/gen/unixfs.js","/npm/@ipld/unixfs@3.0.0/src/unixfs.js","/npm/@ipld/unixfs@3.0.0/src/codec.js","/npm/@ipld/unixfs@3.0.0/src/file/chunker/indexed.js","/npm/@ipld/unixfs@3.0.0/src/file/chunker/buffer.js","/npm/@ipld/unixfs@3.0.0/src/writer/util.js","/npm/@ipld/unixfs@3.0.0/src/file/chunker.js","/npm/@ipld/unixfs@3.0.0/src/file/layout/queue.js","/npm/@ipld/unixfs@3.0.0/src/file/writer.js","/npm/@ipld/unixfs@3.0.0/src/file/chunker/fixed.js","/npm/@ipld/unixfs@3.0.0/src/file/layout/balanced.js","/npm/@ipld/unixfs@3.0.0/src/file.js","/npm/@ipld/unixfs@3.0.0/src/directory.js","/npm/@ipld/unixfs@3.0.0/src/sharded-directory.js","/npm/@ipld/unixfs@3.0.0/src/lib.js"],"names":[],"mappings":"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","file":"/npm/@ipld/unixfs@3.0.0/src/lib.js/+esm","sourceRoot":"","sourcesContent":["/**\n * Bundled by jsDelivr using Rollup v2.79.2 and Terser v5.39.0.\n * Original file: /npm/@ipld/unixfs@3.0.0/src/lib.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","/*eslint-disable*/\nimport $protobuf from \"protobufjs/minimal.js\";\n\n// Common aliases\nconst $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;\n\n// Exported root namespace\nconst $root = $protobuf.roots.unixfs || ($protobuf.roots.unixfs = {});\n\nexport const Data = $root.Data = (() => {\n\n    /**\n     * Properties of a Data.\n     * @exports IData\n     * @interface IData\n     * @property {Data.DataType} Type Data Type\n     * @property {Uint8Array|null} [Data] Data Data\n     * @property {number|null} [filesize] Data filesize\n     * @property {Array.<number>|null} [blocksizes] Data blocksizes\n     * @property {number|null} [hashType] Data hashType\n     * @property {number|null} [fanout] Data fanout\n     * @property {number|null} [mode] Data mode\n     * @property {IUnixTime|null} [mtime] Data mtime\n     */\n\n    /**\n     * Constructs a new Data.\n     * @exports Data\n     * @classdesc Represents a Data.\n     * @implements IData\n     * @constructor\n     * @param {IData=} [p] Properties to set\n     */\n    function Data(p) {\n        this.blocksizes = [];\n        if (p)\n            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)\n                if (p[ks[i]] != null)\n                    this[ks[i]] = p[ks[i]];\n    }\n\n    /**\n     * Data Type.\n     * @member {Data.DataType} Type\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.Type = 0;\n\n    /**\n     * Data Data.\n     * @member {Uint8Array} Data\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.Data = $util.newBuffer([]);\n\n    /**\n     * Data filesize.\n     * @member {number} filesize\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.filesize = $util.Long ? $util.Long.fromBits(0,0,true) : 0;\n\n    /**\n     * Data blocksizes.\n     * @member {Array.<number>} blocksizes\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.blocksizes = $util.emptyArray;\n\n    /**\n     * Data hashType.\n     * @member {number} hashType\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.hashType = $util.Long ? $util.Long.fromBits(0,0,true) : 0;\n\n    /**\n     * Data fanout.\n     * @member {number} fanout\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.fanout = $util.Long ? $util.Long.fromBits(0,0,true) : 0;\n\n    /**\n     * Data mode.\n     * @member {number} mode\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.mode = 0;\n\n    /**\n     * Data mtime.\n     * @member {IUnixTime|null|undefined} mtime\n     * @memberof Data\n     * @instance\n     */\n    Data.prototype.mtime = null;\n\n    /**\n     * Encodes the specified Data message. Does not implicitly {@link Data.verify|verify} messages.\n     * @function encode\n     * @memberof Data\n     * @static\n     * @param {IData} m Data message or plain object to encode\n     * @param {$protobuf.Writer} [w] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Data.encode = function encode(m, w) {\n        if (!w)\n            w = $Writer.create();\n        w.uint32(8).int32(m.Type);\n        if (m.Data != null && Object.hasOwnProperty.call(m, \"Data\"))\n            w.uint32(18).bytes(m.Data);\n        if (m.filesize != null && Object.hasOwnProperty.call(m, \"filesize\"))\n            w.uint32(24).uint64(m.filesize);\n        if (m.blocksizes != null && m.blocksizes.length) {\n            for (var i = 0; i < m.blocksizes.length; ++i)\n                w.uint32(32).uint64(m.blocksizes[i]);\n        }\n        if (m.hashType != null && Object.hasOwnProperty.call(m, \"hashType\"))\n            w.uint32(40).uint64(m.hashType);\n        if (m.fanout != null && Object.hasOwnProperty.call(m, \"fanout\"))\n            w.uint32(48).uint64(m.fanout);\n        if (m.mode != null && Object.hasOwnProperty.call(m, \"mode\"))\n            w.uint32(56).uint32(m.mode);\n        if (m.mtime != null && Object.hasOwnProperty.call(m, \"mtime\"))\n            $root.UnixTime.encode(m.mtime, w.uint32(66).fork()).ldelim();\n        return w;\n    };\n\n    /**\n     * Decodes a Data message from the specified reader or buffer.\n     * @function decode\n     * @memberof Data\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from\n     * @param {number} [l] Message length if known beforehand\n     * @returns {Data} Data\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Data.decode = function decode(r, l) {\n        if (!(r instanceof $Reader))\n            r = $Reader.create(r);\n        var c = l === undefined ? r.len : r.pos + l, m = new $root.Data();\n        while (r.pos < c) {\n            var t = r.uint32();\n            switch (t >>> 3) {\n            case 1:\n                m.Type = r.int32();\n                break;\n            case 2:\n                m.Data = r.bytes();\n                break;\n            case 3:\n                m.filesize = r.uint64();\n                break;\n            case 4:\n                if (!(m.blocksizes && m.blocksizes.length))\n                    m.blocksizes = [];\n                if ((t & 7) === 2) {\n                    var c2 = r.uint32() + r.pos;\n                    while (r.pos < c2)\n                        m.blocksizes.push(r.uint64());\n                } else\n                    m.blocksizes.push(r.uint64());\n                break;\n            case 5:\n                m.hashType = r.uint64();\n                break;\n            case 6:\n                m.fanout = r.uint64();\n                break;\n            case 7:\n                m.mode = r.uint32();\n                break;\n            case 8:\n                m.mtime = $root.UnixTime.decode(r, r.uint32());\n                break;\n            default:\n                r.skipType(t & 7);\n                break;\n            }\n        }\n        if (!m.hasOwnProperty(\"Type\"))\n            throw $util.ProtocolError(\"missing required 'Type'\", { instance: m });\n        return m;\n    };\n\n    /**\n     * Creates a Data message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Data\n     * @static\n     * @param {Object.<string,*>} d Plain object\n     * @returns {Data} Data\n     */\n    Data.fromObject = function fromObject(d) {\n        if (d instanceof $root.Data)\n            return d;\n        var m = new $root.Data();\n        switch (d.Type) {\n        case \"Raw\":\n        case 0:\n            m.Type = 0;\n            break;\n        case \"Directory\":\n        case 1:\n            m.Type = 1;\n            break;\n        case \"File\":\n        case 2:\n            m.Type = 2;\n            break;\n        case \"Metadata\":\n        case 3:\n            m.Type = 3;\n            break;\n        case \"Symlink\":\n        case 4:\n            m.Type = 4;\n            break;\n        case \"HAMTShard\":\n        case 5:\n            m.Type = 5;\n            break;\n        }\n        if (d.Data != null) {\n            if (typeof d.Data === \"string\")\n                $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0);\n            else if (d.Data.length)\n                m.Data = d.Data;\n        }\n        if (d.filesize != null) {\n            if ($util.Long)\n                (m.filesize = $util.Long.fromValue(d.filesize)).unsigned = true;\n            else if (typeof d.filesize === \"string\")\n                m.filesize = parseInt(d.filesize, 10);\n            else if (typeof d.filesize === \"number\")\n                m.filesize = d.filesize;\n            else if (typeof d.filesize === \"object\")\n                m.filesize = new $util.LongBits(d.filesize.low >>> 0, d.filesize.high >>> 0).toNumber(true);\n        }\n        if (d.blocksizes) {\n            if (!Array.isArray(d.blocksizes))\n                throw TypeError(\".Data.blocksizes: array expected\");\n            m.blocksizes = [];\n            for (var i = 0; i < d.blocksizes.length; ++i) {\n                if ($util.Long)\n                    (m.blocksizes[i] = $util.Long.fromValue(d.blocksizes[i])).unsigned = true;\n                else if (typeof d.blocksizes[i] === \"string\")\n                    m.blocksizes[i] = parseInt(d.blocksizes[i], 10);\n                else if (typeof d.blocksizes[i] === \"number\")\n                    m.blocksizes[i] = d.blocksizes[i];\n                else if (typeof d.blocksizes[i] === \"object\")\n                    m.blocksizes[i] = new $util.LongBits(d.blocksizes[i].low >>> 0, d.blocksizes[i].high >>> 0).toNumber(true);\n            }\n        }\n        if (d.hashType != null) {\n            if ($util.Long)\n                (m.hashType = $util.Long.fromValue(d.hashType)).unsigned = true;\n            else if (typeof d.hashType === \"string\")\n                m.hashType = parseInt(d.hashType, 10);\n            else if (typeof d.hashType === \"number\")\n                m.hashType = d.hashType;\n            else if (typeof d.hashType === \"object\")\n                m.hashType = new $util.LongBits(d.hashType.low >>> 0, d.hashType.high >>> 0).toNumber(true);\n        }\n        if (d.fanout != null) {\n            if ($util.Long)\n                (m.fanout = $util.Long.fromValue(d.fanout)).unsigned = true;\n            else if (typeof d.fanout === \"string\")\n                m.fanout = parseInt(d.fanout, 10);\n            else if (typeof d.fanout === \"number\")\n                m.fanout = d.fanout;\n            else if (typeof d.fanout === \"object\")\n                m.fanout = new $util.LongBits(d.fanout.low >>> 0, d.fanout.high >>> 0).toNumber(true);\n        }\n        if (d.mode != null) {\n            m.mode = d.mode >>> 0;\n        }\n        if (d.mtime != null) {\n            if (typeof d.mtime !== \"object\")\n                throw TypeError(\".Data.mtime: object expected\");\n            m.mtime = $root.UnixTime.fromObject(d.mtime);\n        }\n        return m;\n    };\n\n    /**\n     * Creates a plain object from a Data message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Data\n     * @static\n     * @param {Data} m Data\n     * @param {$protobuf.IConversionOptions} [o] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Data.toObject = function toObject(m, o) {\n        if (!o)\n            o = {};\n        var d = {};\n        if (o.arrays || o.defaults) {\n            d.blocksizes = [];\n        }\n        if (o.defaults) {\n            d.Type = o.enums === String ? \"Raw\" : 0;\n            if (o.bytes === String)\n                d.Data = \"\";\n            else {\n                d.Data = [];\n                if (o.bytes !== Array)\n                    d.Data = $util.newBuffer(d.Data);\n            }\n            if ($util.Long) {\n                var n = new $util.Long(0, 0, true);\n                d.filesize = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;\n            } else\n                d.filesize = o.longs === String ? \"0\" : 0;\n            if ($util.Long) {\n                var n = new $util.Long(0, 0, true);\n                d.hashType = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;\n            } else\n                d.hashType = o.longs === String ? \"0\" : 0;\n            if ($util.Long) {\n                var n = new $util.Long(0, 0, true);\n                d.fanout = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;\n            } else\n                d.fanout = o.longs === String ? \"0\" : 0;\n            d.mode = 0;\n            d.mtime = null;\n        }\n        if (m.Type != null && m.hasOwnProperty(\"Type\")) {\n            d.Type = o.enums === String ? $root.Data.DataType[m.Type] : m.Type;\n        }\n        if (m.Data != null && m.hasOwnProperty(\"Data\")) {\n            d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data;\n        }\n        if (m.filesize != null && m.hasOwnProperty(\"filesize\")) {\n            if (typeof m.filesize === \"number\")\n                d.filesize = o.longs === String ? String(m.filesize) : m.filesize;\n            else\n                d.filesize = o.longs === String ? $util.Long.prototype.toString.call(m.filesize) : o.longs === Number ? new $util.LongBits(m.filesize.low >>> 0, m.filesize.high >>> 0).toNumber(true) : m.filesize;\n        }\n        if (m.blocksizes && m.blocksizes.length) {\n            d.blocksizes = [];\n            for (var j = 0; j < m.blocksizes.length; ++j) {\n                if (typeof m.blocksizes[j] === \"number\")\n                    d.blocksizes[j] = o.longs === String ? String(m.blocksizes[j]) : m.blocksizes[j];\n                else\n                    d.blocksizes[j] = o.longs === String ? $util.Long.prototype.toString.call(m.blocksizes[j]) : o.longs === Number ? new $util.LongBits(m.blocksizes[j].low >>> 0, m.blocksizes[j].high >>> 0).toNumber(true) : m.blocksizes[j];\n            }\n        }\n        if (m.hashType != null && m.hasOwnProperty(\"hashType\")) {\n            if (typeof m.hashType === \"number\")\n                d.hashType = o.longs === String ? String(m.hashType) : m.hashType;\n            else\n                d.hashType = o.longs === String ? $util.Long.prototype.toString.call(m.hashType) : o.longs === Number ? new $util.LongBits(m.hashType.low >>> 0, m.hashType.high >>> 0).toNumber(true) : m.hashType;\n        }\n        if (m.fanout != null && m.hasOwnProperty(\"fanout\")) {\n            if (typeof m.fanout === \"number\")\n                d.fanout = o.longs === String ? String(m.fanout) : m.fanout;\n            else\n                d.fanout = o.longs === String ? $util.Long.prototype.toString.call(m.fanout) : o.longs === Number ? new $util.LongBits(m.fanout.low >>> 0, m.fanout.high >>> 0).toNumber(true) : m.fanout;\n        }\n        if (m.mode != null && m.hasOwnProperty(\"mode\")) {\n            d.mode = m.mode;\n        }\n        if (m.mtime != null && m.hasOwnProperty(\"mtime\")) {\n            d.mtime = $root.UnixTime.toObject(m.mtime, o);\n        }\n        return d;\n    };\n\n    /**\n     * Converts this Data to JSON.\n     * @function toJSON\n     * @memberof Data\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Data.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    /**\n     * DataType enum.\n     * @name Data.DataType\n     * @enum {number}\n     * @property {number} Raw=0 Raw value\n     * @property {number} Directory=1 Directory value\n     * @property {number} File=2 File value\n     * @property {number} Metadata=3 Metadata value\n     * @property {number} Symlink=4 Symlink value\n     * @property {number} HAMTShard=5 HAMTShard value\n     */\n    Data.DataType = (function() {\n        const valuesById = {}, values = Object.create(valuesById);\n        values[valuesById[0] = \"Raw\"] = 0;\n        values[valuesById[1] = \"Directory\"] = 1;\n        values[valuesById[2] = \"File\"] = 2;\n        values[valuesById[3] = \"Metadata\"] = 3;\n        values[valuesById[4] = \"Symlink\"] = 4;\n        values[valuesById[5] = \"HAMTShard\"] = 5;\n        return values;\n    })();\n\n    return Data;\n})();\n\nexport const UnixTime = $root.UnixTime = (() => {\n\n    /**\n     * Properties of an UnixTime.\n     * @exports IUnixTime\n     * @interface IUnixTime\n     * @property {number} Seconds UnixTime Seconds\n     * @property {number|null} [FractionalNanoseconds] UnixTime FractionalNanoseconds\n     */\n\n    /**\n     * Constructs a new UnixTime.\n     * @exports UnixTime\n     * @classdesc Represents an UnixTime.\n     * @implements IUnixTime\n     * @constructor\n     * @param {IUnixTime=} [p] Properties to set\n     */\n    function UnixTime(p) {\n        if (p)\n            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)\n                if (p[ks[i]] != null)\n                    this[ks[i]] = p[ks[i]];\n    }\n\n    /**\n     * UnixTime Seconds.\n     * @member {number} Seconds\n     * @memberof UnixTime\n     * @instance\n     */\n    UnixTime.prototype.Seconds = $util.Long ? $util.Long.fromBits(0,0,false) : 0;\n\n    /**\n     * UnixTime FractionalNanoseconds.\n     * @member {number} FractionalNanoseconds\n     * @memberof UnixTime\n     * @instance\n     */\n    UnixTime.prototype.FractionalNanoseconds = 0;\n\n    /**\n     * Encodes the specified UnixTime message. Does not implicitly {@link UnixTime.verify|verify} messages.\n     * @function encode\n     * @memberof UnixTime\n     * @static\n     * @param {IUnixTime} m UnixTime message or plain object to encode\n     * @param {$protobuf.Writer} [w] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    UnixTime.encode = function encode(m, w) {\n        if (!w)\n            w = $Writer.create();\n        w.uint32(8).int64(m.Seconds);\n        if (m.FractionalNanoseconds != null && Object.hasOwnProperty.call(m, \"FractionalNanoseconds\"))\n            w.uint32(21).fixed32(m.FractionalNanoseconds);\n        return w;\n    };\n\n    /**\n     * Decodes an UnixTime message from the specified reader or buffer.\n     * @function decode\n     * @memberof UnixTime\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from\n     * @param {number} [l] Message length if known beforehand\n     * @returns {UnixTime} UnixTime\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    UnixTime.decode = function decode(r, l) {\n        if (!(r instanceof $Reader))\n            r = $Reader.create(r);\n        var c = l === undefined ? r.len : r.pos + l, m = new $root.UnixTime();\n        while (r.pos < c) {\n            var t = r.uint32();\n            switch (t >>> 3) {\n            case 1:\n                m.Seconds = r.int64();\n                break;\n            case 2:\n                m.FractionalNanoseconds = r.fixed32();\n                break;\n            default:\n                r.skipType(t & 7);\n                break;\n            }\n        }\n        if (!m.hasOwnProperty(\"Seconds\"))\n            throw $util.ProtocolError(\"missing required 'Seconds'\", { instance: m });\n        return m;\n    };\n\n    /**\n     * Creates an UnixTime message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof UnixTime\n     * @static\n     * @param {Object.<string,*>} d Plain object\n     * @returns {UnixTime} UnixTime\n     */\n    UnixTime.fromObject = function fromObject(d) {\n        if (d instanceof $root.UnixTime)\n            return d;\n        var m = new $root.UnixTime();\n        if (d.Seconds != null) {\n            if ($util.Long)\n                (m.Seconds = $util.Long.fromValue(d.Seconds)).unsigned = false;\n            else if (typeof d.Seconds === \"string\")\n                m.Seconds = parseInt(d.Seconds, 10);\n            else if (typeof d.Seconds === \"number\")\n                m.Seconds = d.Seconds;\n            else if (typeof d.Seconds === \"object\")\n                m.Seconds = new $util.LongBits(d.Seconds.low >>> 0, d.Seconds.high >>> 0).toNumber();\n        }\n        if (d.FractionalNanoseconds != null) {\n            m.FractionalNanoseconds = d.FractionalNanoseconds >>> 0;\n        }\n        return m;\n    };\n\n    /**\n     * Creates a plain object from an UnixTime message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof UnixTime\n     * @static\n     * @param {UnixTime} m UnixTime\n     * @param {$protobuf.IConversionOptions} [o] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    UnixTime.toObject = function toObject(m, o) {\n        if (!o)\n            o = {};\n        var d = {};\n        if (o.defaults) {\n            if ($util.Long) {\n                var n = new $util.Long(0, 0, false);\n                d.Seconds = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;\n            } else\n                d.Seconds = o.longs === String ? \"0\" : 0;\n            d.FractionalNanoseconds = 0;\n        }\n        if (m.Seconds != null && m.hasOwnProperty(\"Seconds\")) {\n            if (typeof m.Seconds === \"number\")\n                d.Seconds = o.longs === String ? String(m.Seconds) : m.Seconds;\n            else\n                d.Seconds = o.longs === String ? $util.Long.prototype.toString.call(m.Seconds) : o.longs === Number ? new $util.LongBits(m.Seconds.low >>> 0, m.Seconds.high >>> 0).toNumber() : m.Seconds;\n        }\n        if (m.FractionalNanoseconds != null && m.hasOwnProperty(\"FractionalNanoseconds\")) {\n            d.FractionalNanoseconds = m.FractionalNanoseconds;\n        }\n        return d;\n    };\n\n    /**\n     * Converts this UnixTime to JSON.\n     * @function toJSON\n     * @memberof UnixTime\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    UnixTime.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return UnixTime;\n})();\n\nexport const Metadata = $root.Metadata = (() => {\n\n    /**\n     * Properties of a Metadata.\n     * @exports IMetadata\n     * @interface IMetadata\n     * @property {string|null} [MimeType] Metadata MimeType\n     */\n\n    /**\n     * Constructs a new Metadata.\n     * @exports Metadata\n     * @classdesc Represents a Metadata.\n     * @implements IMetadata\n     * @constructor\n     * @param {IMetadata=} [p] Properties to set\n     */\n    function Metadata(p) {\n        if (p)\n            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)\n                if (p[ks[i]] != null)\n                    this[ks[i]] = p[ks[i]];\n    }\n\n    /**\n     * Metadata MimeType.\n     * @member {string} MimeType\n     * @memberof Metadata\n     * @instance\n     */\n    Metadata.prototype.MimeType = \"\";\n\n    /**\n     * Encodes the specified Metadata message. Does not implicitly {@link Metadata.verify|verify} messages.\n     * @function encode\n     * @memberof Metadata\n     * @static\n     * @param {IMetadata} m Metadata message or plain object to encode\n     * @param {$protobuf.Writer} [w] Writer to encode to\n     * @returns {$protobuf.Writer} Writer\n     */\n    Metadata.encode = function encode(m, w) {\n        if (!w)\n            w = $Writer.create();\n        if (m.MimeType != null && Object.hasOwnProperty.call(m, \"MimeType\"))\n            w.uint32(10).string(m.MimeType);\n        return w;\n    };\n\n    /**\n     * Decodes a Metadata message from the specified reader or buffer.\n     * @function decode\n     * @memberof Metadata\n     * @static\n     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from\n     * @param {number} [l] Message length if known beforehand\n     * @returns {Metadata} Metadata\n     * @throws {Error} If the payload is not a reader or valid buffer\n     * @throws {$protobuf.util.ProtocolError} If required fields are missing\n     */\n    Metadata.decode = function decode(r, l) {\n        if (!(r instanceof $Reader))\n            r = $Reader.create(r);\n        var c = l === undefined ? r.len : r.pos + l, m = new $root.Metadata();\n        while (r.pos < c) {\n            var t = r.uint32();\n            switch (t >>> 3) {\n            case 1:\n                m.MimeType = r.string();\n                break;\n            default:\n                r.skipType(t & 7);\n                break;\n            }\n        }\n        return m;\n    };\n\n    /**\n     * Creates a Metadata message from a plain object. Also converts values to their respective internal types.\n     * @function fromObject\n     * @memberof Metadata\n     * @static\n     * @param {Object.<string,*>} d Plain object\n     * @returns {Metadata} Metadata\n     */\n    Metadata.fromObject = function fromObject(d) {\n        if (d instanceof $root.Metadata)\n            return d;\n        var m = new $root.Metadata();\n        if (d.MimeType != null) {\n            m.MimeType = String(d.MimeType);\n        }\n        return m;\n    };\n\n    /**\n     * Creates a plain object from a Metadata message. Also converts values to other types if specified.\n     * @function toObject\n     * @memberof Metadata\n     * @static\n     * @param {Metadata} m Metadata\n     * @param {$protobuf.IConversionOptions} [o] Conversion options\n     * @returns {Object.<string,*>} Plain object\n     */\n    Metadata.toObject = function toObject(m, o) {\n        if (!o)\n            o = {};\n        var d = {};\n        if (o.defaults) {\n            d.MimeType = \"\";\n        }\n        if (m.MimeType != null && m.hasOwnProperty(\"MimeType\")) {\n            d.MimeType = m.MimeType;\n        }\n        return d;\n    };\n\n    /**\n     * Converts this Metadata to JSON.\n     * @function toJSON\n     * @memberof Metadata\n     * @instance\n     * @returns {Object.<string,*>} JSON object\n     */\n    Metadata.prototype.toJSON = function toJSON() {\n        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);\n    };\n\n    return Metadata;\n})();\n\nexport { $root as default };\n","// @ts-nocheck\n\n/**\n * This is file is shadowed by api.ts and only exists so JS could import it to\n * refer to types without encountering runtime errors\n * @see https://github.com/microsoft/TypeScript/issues/41825\n */\n\nimport { Data } from \"../gen/unixfs.js\"\nexport const NodeType = Data.DataType\n","import * as PB from \"@ipld/dag-pb\"\nimport * as UnixFS from \"./unixfs.js\"\nimport { NodeType } from \"./unixfs.js\"\nimport { Data } from \"../gen/unixfs.js\"\n\nexport * from \"./unixfs.js\"\n\n/** @type {ReadonlyArray<any>} */\nconst EMPTY = Object.freeze([])\nconst EMPTY_BUFFER = new Uint8Array(0)\n\nconst BLANK = Object.freeze({})\nexport const DEFAULT_FILE_MODE = parseInt(\"0644\", 8)\nexport const DEFAULT_DIRECTORY_MODE = parseInt(\"0755\", 8)\n\nexport const code = PB.code\nexport const name = \"UnixFS\"\n\n/**\n * @param {UnixFS.IData} data\n * @param {ReadonlyArray<UnixFS.PBLink>} links\n */\nconst encodePB = (data, links) => {\n  Object(globalThis).debug && console.log({ data, links })\n\n  return PB.encode(\n    // We run through prepare as links need to be sorted by name which it will\n    // do.\n    PB.prepare({\n      Data: Data.encode(data).finish(),\n      // We can cast to mutable array as we know no mutation occurs there\n      Links:\n        /** @type {PB.PBLink[]} */ (links),\n    })\n  )\n}\n\n/**\n * @param {Uint8Array} content\n * @returns {UnixFS.Raw}\n */\nexport const createRaw = content => ({\n  type: NodeType.Raw,\n  content,\n})\n\n/**\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.SimpleFile}\n */\nexport const createEmptyFile = metadata =>\n  createSimpleFile(EMPTY_BUFFER, metadata)\n\n/**\n * @param {Uint8Array} content\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.SimpleFile}\n */\nexport const createSimpleFile = (content, metadata) => ({\n  type: NodeType.File,\n  layout: \"simple\",\n  content,\n  metadata: decodeMetadata(metadata),\n})\n\n/**\n * @param {Uint8Array} content\n * @returns {UnixFS.FileChunk}\n */\nexport const createFileChunk = content => ({\n  type: NodeType.File,\n  layout: \"simple\",\n  content,\n})\n\n/**\n * @param {UnixFS.FileLink[]} parts\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.AdvancedFile}\n */\nexport const createAdvancedFile = (parts, metadata) => ({\n  type: NodeType.File,\n  layout: \"advanced\",\n  parts,\n  metadata: decodeMetadata(metadata),\n})\n\n/**\n * @param {UnixFS.FileLink[]} parts\n * @returns {UnixFS.FileShard}\n */\nexport const createFileShard = parts => ({\n  type: NodeType.File,\n  layout: \"advanced\",\n  parts,\n})\n\n/**\n * @deprecated\n * @param {Uint8Array} content\n * @param {UnixFS.FileLink[]} parts\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.ComplexFile}\n */\nexport const createComplexFile = (content, parts, metadata) => ({\n  type: NodeType.File,\n  layout: \"complex\",\n  content,\n  parts,\n  metadata: decodeMetadata(metadata),\n})\n\n/**\n * @param {UnixFS.DirectoryEntryLink[]} entries\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.FlatDirectory}\n */\nexport const createFlatDirectory = (entries, metadata) => ({\n  type: NodeType.Directory,\n  metadata: decodeMetadata(metadata),\n  entries,\n})\n\n/**\n * @param {UnixFS.ShardedDirectoryLink[]} entries\n * @param {Uint8Array} bitfield\n * @param {number} fanout\n * @param {number} hashType\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.ShardedDirectory}\n */\nexport const createShardedDirectory = (\n  entries,\n  bitfield,\n  fanout,\n  hashType,\n  metadata = BLANK\n) => ({\n  type: NodeType.HAMTShard,\n  bitfield,\n  fanout: readFanout(fanout),\n  hashType: readInt(hashType),\n  entries,\n  metadata: decodeMetadata(metadata),\n})\n\n/**\n * @param {UnixFS.ShardedDirectoryLink[]} entries\n * @param {Uint8Array} bitfield\n * @param {number} fanout\n * @param {number} hashType\n * @returns {UnixFS.DirectoryShard}\n */\nexport const createDirectoryShard = (entries, bitfield, fanout, hashType) => ({\n  type: NodeType.HAMTShard,\n  bitfield,\n  fanout: readFanout(fanout),\n  hashType: readInt(hashType),\n  entries,\n})\n\n/**\n *\n * @param {Uint8Array} content\n * @returns {UnixFS.ByteView<UnixFS.Raw>}\n */\nexport const encodeRaw = content =>\n  encodePB(\n    {\n      Type: NodeType.Raw,\n      // TODO:\n      Data: content.byteLength > 0 ? content : undefined,\n      filesize: content.byteLength,\n      // @ts-ignore\n      blocksizes: EMPTY,\n    },\n    []\n  )\n\n/**\n * @param {UnixFS.File|UnixFS.FileChunk|UnixFS.FileShard} node\n * @param {boolean} [ignoreMetadata]\n * @returns {UnixFS.ByteView<UnixFS.SimpleFile|UnixFS.AdvancedFile|UnixFS.ComplexFile>}\n */\nexport const encodeFile = (node, ignoreMetadata = false) => {\n  const metadata = ignoreMetadata ? BLANK : Object(node).metadata\n  switch (node.layout) {\n    case \"simple\":\n      return encodeSimpleFile(node.content, metadata)\n    case \"advanced\":\n      return encodeAdvancedFile(node.parts, metadata)\n    case \"complex\":\n      return encodeComplexFile(node.content, node.parts, metadata)\n    default:\n      throw new TypeError(\n        `File with unknown layout \"${Object(node).layout}\" was passed`\n      )\n  }\n}\n\n/**\n * @param {Uint8Array} content\n * @returns {UnixFS.ByteView<UnixFS.FileChunk>}\n */\nexport const encodeFileChunk = content => encodeSimpleFile(content, BLANK)\n\n/**\n * @param {ReadonlyArray<UnixFS.FileLink>} parts\n * @returns {UnixFS.ByteView<UnixFS.FileShard>}\n */\nexport const encodeFileShard = parts =>\n  encodePB(\n    {\n      Type: NodeType.File,\n      blocksizes: parts.map(contentByteLength),\n      filesize: cumulativeContentByteLength(parts),\n    },\n    parts.map(encodeLink)\n  )\n\n/**\n * @param {ReadonlyArray<UnixFS.FileLink>} parts\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.ByteView<UnixFS.AdvancedFile>}\n */\nexport const encodeAdvancedFile = (parts, metadata = BLANK) =>\n  encodePB(\n    {\n      Type: NodeType.File,\n      blocksizes: parts.map(contentByteLength),\n      filesize: cumulativeContentByteLength(parts),\n\n      ...encodeMetadata(metadata),\n    },\n    parts.map(encodeLink)\n  )\n\n/**\n * @param {UnixFS.DAGLink} dag\n * @returns {UnixFS.PBLink}\n */\nexport const encodeLink = dag => ({\n  Name: \"\",\n  Tsize: dag.dagByteLength,\n  // @ts-ignore - @see https://github.com/multiformats/js-multiformats/pull/161\n  Hash: dag.cid,\n})\n\n/**\n * @param {Uint8Array} content\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.ByteView<UnixFS.SimpleFile>}\n */\n\nexport const encodeSimpleFile = (content, metadata = BLANK) =>\n  encodePB(\n    {\n      Type: NodeType.File,\n      // adding empty file to both go-ipfs and js-ipfs produces block in\n      // which `Data` is omitted but filesize and blocksizes are present.\n      // For the sake of hash consistency we do the same.\n      Data: content.byteLength > 0 ? content : undefined,\n      filesize: content.byteLength,\n      blocksizes: [],\n      ...encodeMetadata(metadata),\n    },\n    []\n  )\n\n/**\n *\n * @param {Uint8Array} content\n * @param {ReadonlyArray<UnixFS.FileLink>} parts\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.ByteView<UnixFS.ComplexFile>}\n */\nexport const encodeComplexFile = (content, parts, metadata = BLANK) =>\n  encodePB(\n    {\n      Type: NodeType.File,\n      Data: content,\n      filesize: content.byteLength + cumulativeContentByteLength(parts),\n      blocksizes: parts.map(contentByteLength),\n    },\n    parts.map(encodeLink)\n  )\n\n/**\n * @param {UnixFS.FlatDirectory} node\n * @returns {UnixFS.ByteView<UnixFS.FlatDirectory>}\n */\nexport const encodeDirectory = node =>\n  encodePB(\n    {\n      Type: node.type,\n      ...encodeDirectoryMetadata(node.metadata || BLANK),\n    },\n    node.entries.map(encodeNamedLink)\n  )\n\n/**\n * @param {UnixFS.ShardedDirectory|UnixFS.DirectoryShard} node\n * @returns {UnixFS.ByteView<UnixFS.ShardedDirectory>}\n */\nexport const encodeHAMTShard = ({\n  bitfield,\n  fanout,\n  hashType,\n  entries,\n  metadata = BLANK,\n}) =>\n  encodePB(\n    {\n      Type: NodeType.HAMTShard,\n      Data: bitfield.byteLength > 0 ? bitfield : undefined,\n      fanout: readFanout(fanout),\n      hashType: readInt(hashType),\n\n      ...encodeDirectoryMetadata(metadata),\n    },\n    entries.map(encodeNamedLink)\n  )\n\n/**\n * @param {number} n\n * @returns {number}\n */\nconst readFanout = n => {\n  if (Math.log2(n) % 1 === 0) {\n    return n\n  } else {\n    throw new TypeError(\n      `Expected hamt size to be a power of two instead got ${n}`\n    )\n  }\n}\n\n/**\n * @param {number} n\n * @returns {number}\n */\n\nconst readInt = n => {\n  if (Number.isInteger(n)) {\n    return n\n  } else {\n    throw new TypeError(`Expected an integer value instead got ${n}`)\n  }\n}\n\n/**\n * @param {Uint8Array} bytes\n */\nconst readData = bytes => (bytes.byteLength > 0 ? bytes : undefined)\n\n/**\n * @param {Uint8Array} path\n * @param {UnixFS.Metadata} [metadata]\n * @returns {UnixFS.Symlink}\n */\nexport const createSymlink = (path, metadata = BLANK) => ({\n  type: NodeType.Symlink,\n  content: path,\n  metadata: decodeMetadata(metadata),\n})\n\n/**\n * @param {UnixFS.Symlink} node\n * @param {boolean} [ignoreMetadata]\n * @returns {UnixFS.ByteView<UnixFS.Symlink>}\n */\nexport const encodeSymlink = (node, ignoreMetadata = false) => {\n  const metadata = ignoreMetadata ? BLANK : Object(node).metadata\n  // We do not include filesize on symlinks because that is what go-ipfs does\n  // when doing `ipfs add mysymlink`. js-ipfs on the other hand seems to store\n  // it, here we choose to follow go-ipfs\n  // @see https://explore.ipld.io/#/explore/QmPZ1CTc5fYErTH2XXDGrfsPsHicYXtkZeVojGycwAfm3v\n  // @see https://github.com/ipfs/js-ipfs-unixfs/issues/195\n  return encodePB(\n    {\n      Type: NodeType.Symlink,\n      Data: node.content,\n      ...encodeMetadata(metadata || BLANK),\n    },\n    []\n  )\n}\n\n/**\n * @template {UnixFS.Node} T\n * @param {T} node\n * @param {boolean} root\n */\nexport const encode = (node, root = true) => {\n  switch (node.type) {\n    case NodeType.Raw:\n      return encodeRaw(node.content)\n    case NodeType.File:\n      return encodeFile(node)\n    case NodeType.Directory:\n      return encodeDirectory(node)\n    case NodeType.HAMTShard:\n      return encodeHAMTShard(node)\n    case NodeType.Symlink:\n      return encodeSymlink(node)\n    default:\n      throw new Error(`Unknown node type ${Object(node).type}`)\n  }\n}\n\n/**\n * @param {UnixFS.ByteView<UnixFS.Node>} bytes\n * @returns {UnixFS.Node}\n */\nexport const decode = bytes => {\n  const pb = PB.decode(bytes)\n  const message = Data.decode(/** @type {Uint8Array} */ (pb.Data))\n\n  const {\n    Type: type,\n    Data: data,\n    mtime,\n    mode,\n    blocksizes,\n    ...rest\n  } = Data.toObject(message, {\n    defaults: false,\n    arrays: true,\n    longs: Number,\n    objects: false,\n  })\n  const metadata = {\n    ...(mode && { mode }),\n    ...decodeMtime(mtime),\n  }\n  /** @type {UnixFS.PBLink[]} */\n  const links = pb.Links\n\n  switch (message.Type) {\n    case NodeType.Raw:\n      return createRaw(data)\n    case NodeType.File:\n      if (links.length === 0) {\n        return new SimpleFileView(data, metadata)\n      } else if (data.byteLength === 0) {\n        return new AdvancedFileView(\n          decodeFileLinks(rest.blocksizes, links),\n          metadata\n        )\n      } else {\n        return new ComplexFileView(\n          data,\n          decodeFileLinks(rest.blocksizes, links),\n          metadata\n        )\n      }\n    case NodeType.Directory:\n      return createFlatDirectory(decodeDirectoryLinks(links), metadata)\n    case NodeType.HAMTShard:\n      return createShardedDirectory(\n        decodeDirectoryLinks(links),\n        data || EMPTY_BUFFER,\n        rest.fanout,\n        rest.hashType,\n        metadata\n      )\n    case NodeType.Symlink:\n      return createSymlink(data, metadata)\n    default:\n      throw new TypeError(`Unsupported node type ${message.Type}`)\n  }\n}\n\n/**\n * @param {UnixFS.UnixTime|undefined} mtime\n */\nconst decodeMtime = mtime =>\n  mtime == null\n    ? undefined\n    : {\n        mtime: { secs: mtime.Seconds, nsecs: mtime.FractionalNanoseconds || 0 },\n      }\n\n/**\n * @param {NodeType} type\n * @param {number[]|undefined} blocksizes\n */\nconst decodeBlocksizes = (type, blocksizes) => {\n  switch (type) {\n    case NodeType.File:\n      return blocksizes && blocksizes.length > 0 ? { blocksizes } : undefined\n    default:\n      return undefined\n  }\n}\n\n/**\n *\n * @param {number[]} blocksizes\n * @param {UnixFS.PBLink[]} links\n * @returns {UnixFS.FileLink[]}\n */\n\nconst decodeFileLinks = (blocksizes, links) => {\n  const parts = []\n  const length = blocksizes.length\n  let n = 0\n  while (n < length) {\n    parts.push(\n      /** @type {UnixFS.FileLink} */ ({\n        cid: links[n].Hash,\n        dagByteLength: links[n].Tsize || 0,\n        contentByteLength: blocksizes[n],\n      })\n    )\n  }\n  return parts\n}\n\n/**\n * @param {UnixFS.PBLink[]} links\n * @returns {UnixFS.DirectoryEntryLink[]}\n */\nconst decodeDirectoryLinks = links =>\n  links.map(\n    link =>\n      /** @type {UnixFS.DirectoryEntryLink} */ ({\n        cid: link.Hash,\n        name: link.Name || \"\",\n        dagByteLength: link.Tsize || 0,\n      })\n  )\n\n/**\n * @param {ReadonlyArray<UnixFS.FileLink>} links\n * @returns {number}\n */\nexport const cumulativeContentByteLength = links =>\n  links.reduce((size, link) => size + link.contentByteLength, 0)\n\n/**\n * @param {Uint8Array} root\n * @param {ReadonlyArray<UnixFS.DAGLink>} links\n * @returns {number}\n */\nexport const cumulativeDagByteLength = (root, links) =>\n  links.reduce((size, link) => size + link.dagByteLength, root.byteLength)\n\n/**\n *\n * @param {UnixFS.FileLink} link\n */\nconst contentByteLength = link => link.contentByteLength\n\n/**\n * @param {UnixFS.NamedDAGLink<unknown>} link\n * @returns {UnixFS.PBLink}\n */\nconst encodeNamedLink = ({ name, dagByteLength, cid }) => ({\n  Name: name,\n  Tsize: dagByteLength,\n  Hash: cid,\n})\n\n/**\n * @param {UnixFS.Metadata} metadata\n */\nexport const encodeDirectoryMetadata = metadata =>\n  encodeMetadata(metadata, DEFAULT_DIRECTORY_MODE)\n\n/**\n * @param {UnixFS.Metadata} metadata\n * @param {UnixFS.Mode} defaultMode\n */\nexport const encodeMetadata = (\n  { mode, mtime },\n  defaultMode = DEFAULT_FILE_MODE\n) => ({\n  mode: mode != null ? encodeMode(mode, defaultMode) : undefined,\n  mtime: mtime != null ? encodeMTime(mtime) : undefined,\n})\n\n/**\n * @param {UnixFS.Metadata} [data]\n */\nexport const decodeMetadata = data =>\n  data == null\n    ? BLANK\n    : {\n        ...(data.mode == null ? undefined : { mode: decodeMode(data.mode) }),\n        ...(data.mtime == null ? undefined : { mtime: data.mtime }),\n      }\n\n/**\n * @param {UnixFS.MTime} mtime\n */\nconst encodeMTime = mtime => {\n  return mtime == null\n    ? undefined\n    : mtime.nsecs !== 0\n    ? { Seconds: mtime.secs, FractionalNanoseconds: mtime.nsecs }\n    : { Seconds: mtime.secs }\n}\n\n/**\n * @param {number} specifiedMode\n * @param {number} defaultMode\n */\nexport const encodeMode = (specifiedMode, defaultMode) => {\n  const mode = specifiedMode == null ? undefined : decodeMode(specifiedMode)\n  return mode === defaultMode || mode == null ? undefined : mode\n}\n\n/**\n * @param {UnixFS.Mode} mode\n * @returns {UnixFS.Mode}\n */\nconst decodeMode = mode => (mode & 0xfff) | (mode & 0xfffff000)\n\n/**\n * @param {{content?: Uint8Array, parts?: ReadonlyArray<UnixFS.FileLink>, metadata?: UnixFS.Metadata }} node\n * @returns {UnixFS.SimpleFile|UnixFS.AdvancedFile|UnixFS.ComplexFile}\n */\nexport const matchFile = ({\n  content = EMPTY_BUFFER,\n  parts = EMPTY,\n  metadata = BLANK,\n  ...rest\n}) => {\n  if (parts.length === 0) {\n    return new SimpleFileView(content, metadata)\n  } else if (content.byteLength === 0) {\n    return new AdvancedFileView(parts, metadata)\n  } else {\n    return new ComplexFileView(content, parts, metadata)\n  }\n}\n\n/**\n * @implements {UnixFS.SimpleFile}\n */\nclass SimpleFileView {\n  /**\n   * @param {Uint8Array} content\n   * @param {UnixFS.Metadata} metadata\n   */\n  constructor(content, metadata) {\n    this.content = content\n    this.metadata = metadata\n    /**\n     * @readonly\n     * @type {\"simple\"}\n     */\n    this.layout = \"simple\"\n    /**\n     * @readonly\n     * @type {NodeType.File}\n     */\n    this.type = NodeType.File\n  }\n\n  get filesize() {\n    return this.content.byteLength\n  }\n\n  encode() {\n    return encodeSimpleFile(this.content, this.metadata)\n  }\n}\n\n/**\n * @implements {UnixFS.AdvancedFile}\n */\nclass AdvancedFileView {\n  /**\n   * @param {ReadonlyArray<UnixFS.FileLink>} parts\n   * @param {UnixFS.Metadata} metadata\n   */\n  constructor(parts, metadata) {\n    this.parts = parts\n    this.metadata = metadata\n  }\n  /** @type {\"advanced\"} */\n  get layout() {\n    return \"advanced\"\n  }\n\n  /**\n   * @returns {NodeType.File}\n   */\n  get type() {\n    return NodeType.File\n  }\n  get fileSize() {\n    return cumulativeContentByteLength(this.parts)\n  }\n  get blockSizes() {\n    return this.parts.map(contentByteLength)\n  }\n\n  encode() {\n    return encodeAdvancedFile(this.parts, this.metadata)\n  }\n}\n\n/**\n * @implements {UnixFS.ComplexFile}\n */\nclass ComplexFileView {\n  /**\n   * @param {Uint8Array} content\n   * @param {ReadonlyArray<UnixFS.FileLink>} parts\n   * @param {UnixFS.Metadata} metadata\n   */\n  constructor(content, parts, metadata) {\n    this.content = content\n    this.parts = parts\n    this.metadata = metadata\n  }\n  /** @type {\"complex\"} */\n  get layout() {\n    return \"complex\"\n  }\n\n  /**\n   * @returns {NodeType.File}\n   */\n  get type() {\n    return NodeType.File\n  }\n  get fileSize() {\n    return this.content.byteLength + cumulativeContentByteLength(this.parts)\n  }\n  get blockSizes() {\n    return this.parts.map(contentByteLength)\n  }\n\n  encode() {\n    return encodeComplexFile(this.content, this.parts, this.metadata)\n  }\n}\n\n/**\n * @param {UnixFS.File|UnixFS.Raw|UnixFS.FileChunk|UnixFS.FileShard|UnixFS.Symlink} node\n * @returns {number}\n */\nexport const filesize = node => {\n  switch (node.type) {\n    case NodeType.Raw:\n    case NodeType.Symlink:\n      return node.content.byteLength\n    case NodeType.File:\n      switch (node.layout) {\n        case \"simple\":\n          return node.content.byteLength\n        case \"advanced\":\n          return cumulativeContentByteLength(node.parts)\n        case \"complex\":\n          return (\n            node.content.byteLength + cumulativeContentByteLength(node.parts)\n          )\n      }\n    default:\n      return 0\n  }\n}\n","function Indexed() {}\n\nObject.defineProperties(Indexed, {\n  prototype: {\n    value: new Proxy(Object.prototype, {\n      /**\n       * @param {object} target\n       * @param {PropertyKey} property\n       * @param {{get(key:PropertyKey): any}} receiver\n       */\n      get(target, property, receiver) {\n        return typeof property === \"symbol\"\n          ? Reflect.get(target, property, receiver)\n          : receiver.get(property)\n      },\n    }),\n  },\n})\n\nexport { Indexed }\n","import { Indexed } from \"./indexed.js\"\n\n/**\n * @typedef {{\n * readonly byteOffset: number\n * readonly byteLength: number\n * readonly segments: Uint8Array[]\n * }} BufferSlice\n */\n\n/** @typedef {BufferView} View */\nexport const empty = () => new BufferView()\n\n/**\n * @param {Uint8Array[]} segments\n * @param {number} byteOffset\n * @param {number} byteLength\n */\nexport const create = (\n  segments,\n  byteOffset = 0,\n  byteLength = totalByteLength(segments)\n) => new BufferView(segments, byteOffset, byteLength)\n\n/**\n *\n * @param {Uint8Array[]} segments\n * @returns\n */\nconst totalByteLength = segments => {\n  let byteLength = 0\n  for (const segment of segments) {\n    byteLength += segment.byteLength\n  }\n  return byteLength\n}\n\n/**\n * @param {BufferSlice} buffer\n * @param {number} [startOffset]\n * @param {number} [endOffset]\n */\nexport const slice = (\n  buffer,\n  startOffset = 0,\n  endOffset = buffer.byteLength\n) => {\n  const segments = []\n  const start = startOffset < 0 ? buffer.byteLength - startOffset : startOffset\n  const end = endOffset < 0 ? buffer.byteLength - endOffset : endOffset\n\n  // If start at 0 offset and end is past buffer range it is effectively\n  // as same buffer.\n  if (start === 0 && end >= buffer.byteLength) {\n    return buffer\n  }\n\n  // If range is not within the current buffer just create an empty slice.\n  if (start > end || start > buffer.byteLength || end <= 0) {\n    return empty()\n  }\n\n  let byteLength = 0\n  let offset = 0\n  for (const segment of buffer.segments) {\n    const nextOffset = offset + segment.byteLength\n    // Have not found a start yet\n    if (byteLength === 0) {\n      // If end offset is within the current segment we know start is also,\n      // because it preceeds the end & we had not found start yet.\n      // In such case we create a view with only single segment of bytes\n      // in the range.\n      if (end <= nextOffset) {\n        const range = segment.subarray(start - offset, end - offset)\n        segments.push(range)\n        byteLength = range.byteLength\n        break\n      }\n      // If start offeset falls with in current range (but not the end)\n      // we save matching buffer slice and update byteLength.\n      else if (start < nextOffset) {\n        const range =\n          start === offset ? segment : segment.subarray(start - offset)\n        segments.push(range)\n        byteLength = range.byteLength\n      }\n    }\n    // Otherwise we already started collecting matching segments and are looking\n    // for the end end of the slice. If it is with in the current range capture\n    // the segment and create a view.\n    else if (end <= nextOffset) {\n      const range =\n        end === nextOffset ? segment : segment.subarray(0, end - offset)\n      segments.push(range)\n      byteLength += range.byteLength\n      break\n    }\n    // If end is past current range we just save the segment and continue.\n    else {\n      segments.push(segment)\n      byteLength += segment.byteLength\n    }\n\n    offset = nextOffset\n  }\n\n  return new BufferView(segments, buffer.byteOffset + start, byteLength)\n}\n\n/**\n * @param {BufferSlice} buffer\n * @param {Uint8Array} part\n */\n\nexport const push = (buffer, part) => {\n  if (part.byteLength > 0) {\n    // We MUTATE here but that is ok because it is out of bound for the passed\n    // buffer view so there will be no visible side effects.\n    buffer.segments.push(part)\n    return new BufferView(\n      buffer.segments,\n      buffer.byteOffset,\n      buffer.byteLength + part.byteLength\n    )\n  } else {\n    return buffer\n  }\n}\n\n/**\n * @param {BufferSlice} buffer\n * @param {number} n\n */\nexport const get = (buffer, n) => {\n  if (n < buffer.byteLength) {\n    let offset = 0\n    for (const segment of buffer.segments) {\n      if (n < offset + segment.byteLength) {\n        return segment[n - offset]\n      } else {\n        offset += segment.byteLength\n      }\n    }\n  }\n\n  return undefined\n}\n\n/**\n *\n * @param {BufferView} buffer\n * @param {Uint8Array} target\n * @param {number} byteOffset\n */\nexport const copyTo = (buffer, target, byteOffset) => {\n  let offset = byteOffset\n  for (const segment of buffer.segments) {\n    target.set(segment, offset)\n    offset += segment.byteLength\n  }\n\n  return target\n}\n\n/**\n *\n * @param {BufferView} buffer\n */\nexport function* iterate(buffer) {\n  for (const part of buffer.segments) {\n    yield* part\n  }\n}\n\n/**\n * @extends {Indexed<number>}\n */\nclass BufferView extends Indexed {\n  /**\n   * @param {Uint8Array[]} segments\n   * @param {number} byteOffset\n   * @param {number} byteLength\n   */\n  constructor(segments = [], byteOffset = 0, byteLength = 0) {\n    super()\n    /** @hide */\n    this.segments = segments\n    /** @readonly */\n    this.byteLength = byteLength\n    /** @readonly */\n    this.length = byteLength\n    /** @readonly */\n    this.byteOffset = byteOffset\n  }\n\n  [Symbol.iterator]() {\n    return iterate(this)\n  }\n\n  /**\n   * @param {number} [start]\n   * @param {number} [end]\n   */\n  slice(start, end) {\n    return /** @type {BufferView} */ (slice(this, start, end))\n  }\n\n  /**\n   * @param {number} [start]\n   * @param {number} [end]\n   */\n  subarray(start, end) {\n    return /** @type {BufferView} */ (slice(this, start, end))\n  }\n\n  /**\n   *\n   * @param {Uint8Array} bytes\n   */\n  push(bytes) {\n    return /** @type {BufferView} */ (push(this, bytes))\n  }\n\n  /**\n   * @param {number} n\n   */\n  get(n) {\n    return get(this, n)\n  }\n\n  /**\n   *\n   * @param {Uint8Array} target\n   * @param {number} offset\n   */\n  copyTo(target, offset) {\n    return copyTo(this, target, offset)\n  }\n}\n","/**\n * @param {string} reason\n * @returns {never}\n */\nexport const panic = reason => {\n  throw new Error(reason)\n}\n\n/**\n * @param {{ raw: readonly string[] | ArrayLike<string>}} template\n * @param {never} [subject]\n * @param {unknown[]} substitutions\n * @returns {never}\n */\nexport const unreachable = (template, subject, ...substitutions) =>\n  panic(String.raw(template, JSON.stringify(subject), ...substitutions))\n\nexport const EMPTY_BUFFER = new Uint8Array(0)\n/** @type {any[]} */\nexport const EMPTY = []\n","import * as BufferQueue from \"./chunker/buffer.js\"\nimport * as Chunker from \"./chunker/api.js\"\nimport { EMPTY } from \"../writer/util.js\"\nexport * from \"./chunker/api.js\"\n\n/**\n * @typedef {{\n * chunker: Chunker.Chunker\n * }} Config\n *\n *\n * @typedef {{\n * buffer: BufferQueue.View\n * config: Config\n * }} Chunker\n *\n * @typedef {Chunker & {chunks: Chunker.Chunk[]}} ChunkerWithChunks\n */\n\n/**\n * @param {Config} config\n * @returns {Chunker}\n */\nexport const open = config => ({\n  config,\n  buffer: BufferQueue.empty(),\n})\n\n/**\n * @param {Chunker} state\n * @param {Uint8Array} bytes\n * @returns {ChunkerWithChunks}\n */\nexport const write = (state, bytes) =>\n  bytes.byteLength > 0\n    ? split(state.config, state.buffer.push(bytes), false)\n    : { ...state, chunks: EMPTY }\n\n/**\n * @param {Chunker} state\n * @returns {ChunkerWithChunks}\n */\nexport const close = state => split(state.config, state.buffer, true)\n\n/**\n * @param {Config} config\n * @param {BufferQueue.View} buffer\n * @param {boolean} end\n * @returns {ChunkerWithChunks}\n */\n\nexport const split = (config, buffer, end) => {\n  const chunker = config.chunker\n  const chunks = []\n\n  let offset = 0\n  for (const size of chunker.cut(chunker.context, buffer, end)) {\n    // We may be splitting empty buffer in which case there will be no chunks\n    // in it so we make sure that we do not emit empty buffer.\n    if (size > 0) {\n      const chunk = buffer.subarray(offset, offset + size)\n      chunks.push(chunk)\n      offset += size\n    }\n  }\n\n  return { config, chunks, buffer: buffer.subarray(offset) }\n}\n","import * as Layout from \"./api.js\"\nimport * as Queue from \"./queue/api.js\"\nexport * from \"./queue/api.js\"\n\n/**\n * @returns {Queue.Result}\n */\nexport const empty = () => ({\n  mutable: false,\n  needs: {},\n  nodes: {},\n  links: {},\n  linked: [],\n})\n\nexport const mutable = () => ({\n  mutable: true,\n  needs: {},\n  nodes: {},\n  links: {},\n  linked: EMPTY,\n})\n\n/**\n * Adds given layout node to the layout queue. If links for all of the node\n * children are available correspnoding linked node is added (removing links\n * form the queue) otherwise `nood` is added to the wait queue until all the\n * needed links are added.\n *\n *\n * @param {Layout.Branch} node\n * @param {Queue.Queue} queue\n * @returns {Queue.Result}\n */\nexport const addNode = (node, queue) => addNodes([node], queue)\n\n/**\n *\n * @param {Layout.Branch[]} newNodes\n * @param {Queue.Queue} input\n * @returns {Queue.Result}\n */\nexport const addNodes = (newNodes, input) => {\n  let queue = patch(input, {})\n  for (const node of newNodes) {\n    const { ready, has, wants } = collect(node.children, queue.links)\n    // If node isn't waiting on any of the children it's ready to be linked\n    // so we add linked node diretly.\n    if (wants.length === 0) {\n      queue = patch(queue, {\n        links: assign(undefined, has),\n        linked: [{ id: node.id, links: ready }],\n      })\n    } else {\n      queue = patch(queue, {\n        needs: assign(node.id, wants),\n        nodes: {\n          [node.id]: {\n            children: node.children,\n            count: wants.length,\n          },\n        },\n      })\n    }\n  }\n\n  return queue\n}\n\n/**\n * Adds link to the queue. If queue contains a node that needs this link it gets\n * updated. Either it's gets linked (when it was blocked only on this link) or\n * it's want could is reduced. If no node needed this link it just gets stored\n * for the future node that will need it.\n *\n *\n * @param {Queue.NodeID} id\n * @param {Queue.Link} link\n * @param {Queue.Queue} queue\n * @returns {Queue.Result}\n */\n\nexport const addLink = (id, link, queue) => {\n  const nodeID = queue.needs[id]\n  const node = queue.nodes[nodeID]\n  // We have node than needs this link.\n  if (node != null) {\n    // This is the only link it needed so we materialize the node and remove\n    // links and needs associated with it.\n    if (node.count === 1) {\n      const { ready, has } = collect(node.children, {\n        ...queue.links,\n        [id]: link,\n      })\n\n      return patch(queue, {\n        needs: { [id]: undefined },\n        links: assign(undefined, has),\n        nodes: { [nodeID]: undefined },\n        linked: [{ id: nodeID, links: ready }],\n      })\n    }\n    // If node needs more links we just reduce a want count and remove this\n    // need.\n    else {\n      return patch(queue, {\n        needs: { [id]: undefined },\n        links: { [id]: link },\n        nodes: {\n          [nodeID]: {\n            ...node,\n            count: node.count - 1,\n          },\n        },\n      })\n    }\n  }\n  // If we have no one waiting for this link just add it to the queue\n  else {\n    return patch(queue, {\n      links: { [id]: link },\n    })\n  }\n}\n\n/**\n *\n * @param {Queue.Queue} queue\n * @param {Queue.Delta} delta\n */\n\nconst patch = (queue, { needs, nodes, links, linked }) => {\n  const result = queue.mutable ? queue : { ...queue }\n  const original = queue.mutable ? BLANK : undefined\n\n  if (needs) {\n    result.needs = patchDict(queue.needs, needs, original)\n  }\n\n  if (nodes) {\n    result.nodes = patchDict(queue.nodes, nodes, original)\n  }\n\n  if (links) {\n    result.links = patchDict(queue.links, links, original)\n  }\n\n  result.linked = linked\n    ? append(queue.linked || EMPTY, linked, EMPTY)\n    : queue.linked || []\n\n  return /** @type {Queue.Result} */ (result)\n}\n\n/**\n * @template V\n * @template {PropertyKey} K\n * @param {V} value\n * @param {K[]} keys\n * @returns {Record<K, V>}\n */\n\nconst assign = (value, keys) => {\n  const delta = /** @type {Record<K, V>} */ ({})\n  for (const key of keys) {\n    delta[key] = value\n  }\n\n  return delta\n}\n\n/**\n * @template {PropertyKey} K\n * @template V\n * @param {Record<K, V>} target\n *\n * @param {Record<K, V|void>} delta\n * @param {Record<K, V>} original\n * @returns {Record<K, V>}\n */\n\nconst patchDict = (target, delta, original = target) => {\n  const result = target === original ? { ...target } : target\n  for (const entry of Object.entries(delta)) {\n    const [id, value] = /** @type {[K, V|void]} */ (entry)\n    if (value == null) {\n      delete result[id]\n    } else {\n      result[id] = value\n    }\n  }\n\n  return result\n}\n/**\n *\n * @param {Iterable<[Queue.NodeID, Queue.Link]>} entries\n * @param {Queue.Queue} queue\n * @returns {Queue.Queue}\n */\nexport const addLinks = (entries, queue) => {\n  for (const [id, link] of entries) {\n    queue = addLink(id, link, queue)\n  }\n  return queue\n}\n\n/**\n * @param {Queue.Queue} queue\n */\n\nexport const isEmpty = queue =>\n  Object.keys(queue.nodes).length === 0 && Object.keys(queue.links).length === 0\n\n/**\n * @template T\n * @param {T[]} target\n * @param {T[]} items\n * @param {T[]} original\n */\nconst append = (target, items, original = target) => {\n  if (target === original) {\n    return [...target, ...items]\n  } else {\n    for (const item of items) {\n      target.push(item)\n    }\n    return target\n  }\n}\n\n/**\n * @param {Queue.NodeID[]} children\n * @param {Record<Queue.NodeID, Queue.Link>} source\n * @returns {{has:Queue.NodeID[], wants:Queue.NodeID[], ready:Queue.Link[]}}\n */\nconst collect = (children, source) => {\n  const has = []\n  const wants = []\n  const ready = []\n  for (const child of children) {\n    const link = source[child]\n    if (link) {\n      has.push(child)\n      ready.push(link)\n    } else {\n      wants.push(child)\n    }\n  }\n\n  return { has, wants, ready }\n}\n\nconst EMPTY = /** @type {never[]} */ (Object.freeze([]))\n\nconst BLANK = /** @type {Record<never, never>} */ (Object.freeze({}))\n","import * as Task from \"actor\"\nimport * as API from \"./api.js\"\nimport * as Layout from \"./layout/api.js\"\nimport * as UnixFS from \"../codec.js\"\nimport * as Chunker from \"./chunker.js\"\nimport { EMPTY_BUFFER, panic, unreachable } from \"../writer/util.js\"\nimport * as Queue from \"./layout/queue.js\"\n\n/**\n * @template Layout\n * @typedef {{\n * readonly status: 'open'\n * readonly metadata: UnixFS.Metadata\n * readonly config: API.EncoderSettings<Layout>\n * readonly writer: API.BlockWriter\n * chunker: Chunker.Chunker\n * layout: Layout\n * nodeQueue: Queue.Queue\n * }} Open\n */\n/**\n * @template Layout\n * @typedef {{\n * readonly status: 'closed'\n * readonly metadata: UnixFS.Metadata\n * readonly config: API.EncoderSettings<Layout>\n * readonly writer: API.BlockWriter\n * readonly rootID: Layout.NodeID\n * readonly end?: Task.Fork<void, never>\n * chunker?: null\n * layout?: null\n * nodeQueue: Queue.Queue\n * }} Closed\n */\n/**\n * @template Layout\n * @typedef {{\n * readonly status: 'linked'\n * readonly metadata: UnixFS.Metadata\n * readonly config: API.EncoderSettings<Layout>\n * readonly writer: API.BlockWriter\n * readonly link: Layout.Link\n * chunker?: null\n * layout?: null\n * nodeQueue: Queue.Queue\n * }} Linked\n */\n\n/**\n * @template Layout\n * @typedef {Open<Layout>|Closed<Layout>|Linked<Layout>} State\n */\n\n/**\n * @template {object} Layout\n * @typedef {{\n * state: State<Layout>\n * effect: Task.Effect<Message>\n * }} Update\n */\n/**\n * @typedef {never\n * |{type:\"write\", bytes:Uint8Array}\n * |{type:\"link\", link:API.EncodedFile}\n * |{type:\"block\"}\n * |{type: \"close\"}\n * |{type: \"end\"}\n * } Message\n */\n\n/**\n * @template Layout\n * @param {Message} message\n * @param {State<Layout>} state\n */\nexport const update = (message, state) => {\n  switch (message.type) {\n    case \"write\":\n      return write(state, message.bytes)\n    case \"link\":\n      return link(state, message.link)\n    /* c8 ignore next 2 */\n    case \"block\":\n      return { state, effect: Task.none() }\n    case \"close\":\n      return close(state)\n    case \"end\":\n      return { state, effect: Task.none() }\n    default:\n      return unreachable`File Writer got unknown message ${message}`\n  }\n}\n\n/**\n * @template Layout\n * @param {API.BlockWriter} writer\n * @param {UnixFS.Metadata} metadata\n * @param {API.EncoderSettings} config\n * @returns {State<Layout>}\n */\nexport const init = (writer, metadata, config) => {\n  return {\n    status: \"open\",\n    metadata,\n    config,\n    writer,\n    chunker: Chunker.open({ chunker: config.chunker }),\n    layout: config.fileLayout.open(),\n    // Note: Writing in large slices e.g. 1GiB at a time creates large queues\n    // with around `16353` items. Immutable version ends up copying it every\n    // time state of the queue changes, which introduces significant overhead.\n    // To avoid this overhead we use mutable implementation which is API\n    // compatible but makes in place updates.\n    // TODO: We should consider using Persistent bit-partitioned vector tries\n    // instead of arrays which would provide immutable interface with neglegable\n    // overhead.\n    // @see https://github.com/Gozala/vectrie\n    nodeQueue: Queue.mutable(),\n  }\n}\n/**\n * @template Layout\n * @param {State<Layout>} state\n * @param {Uint8Array} bytes\n * @returns {Update<Layout>}\n */\nexport const write = (state, bytes) => {\n  if (state.status === \"open\") {\n    // Chunk up provided bytes\n    const { chunks, ...chunker } = Chunker.write(state.chunker, bytes)\n\n    // Pass chunks to layout engine to produce nodes\n    const { nodes, leaves, layout } = state.config.fileLayout.write(\n      state.layout,\n      chunks\n    )\n\n    const { linked, ...nodeQueue } = Queue.addNodes(nodes, state.nodeQueue)\n\n    // Create leaf encode tasks for all new leaves\n    const tasks = [\n      ...encodeLeaves(leaves, state.config),\n      ...encodeBranches(linked, state.config),\n    ]\n\n    return {\n      state: {\n        ...state,\n        chunker,\n        layout,\n        nodeQueue,\n      },\n      effect: Task.listen({\n        link: Task.effects(tasks),\n      }),\n    }\n  } else {\n    return panic(\"Unable to perform write on closed file\")\n  }\n}\n\n/**\n * @template Layout\n * @param {State<Layout>} state\n * @param {API.EncodedFile} entry\n * @returns {Update<Layout>}\n */\nexport const link = (state, { id, link, block }) => {\n  let { linked, ...nodeQueue } = Queue.addLink(id, link, state.nodeQueue)\n\n  const tasks = encodeBranches(linked, state.config)\n\n  /** @type {State<Layout>} */\n  const newState =\n    state.status === \"closed\" && id === state.rootID\n      ? {\n          ...state,\n          status: \"linked\",\n          link,\n          nodeQueue,\n        }\n      : { ...state, nodeQueue }\n\n  // If we just linked a root and there is a **suspended** \"end\" task we create\n  // a task to resume it.\n  const end =\n    state.status === \"closed\" && id === state.rootID && state.end\n      ? state.end.resume()\n      : Task.none()\n\n  return {\n    state: newState,\n    effect: Task.listen({\n      link: Task.effects(tasks),\n      block: writeBlock(state.writer, block),\n      end,\n    }),\n  }\n}\n\n/**\n * @template Layout\n * @param {State<Layout>} state\n * @returns {Update<Layout>}\n */\nexport const close = state => {\n  if (state.status === \"open\") {\n    const { chunks } = Chunker.close(state.chunker)\n    const { layout, ...write } = state.config.fileLayout.write(\n      state.layout,\n      chunks\n    )\n\n    const { root, ...close } = state.config.fileLayout.close(\n      layout,\n      state.metadata\n    )\n\n    const [nodes, leaves] = isLeafNode(root)\n      ? [\n          [...write.nodes, ...close.nodes],\n          [...write.leaves, ...close.leaves, root],\n        ]\n      : [\n          [...write.nodes, ...close.nodes, root],\n          [...write.leaves, ...close.leaves],\n        ]\n\n    const { linked, ...nodeQueue } = Queue.addNodes(nodes, state.nodeQueue)\n\n    const tasks = [\n      ...encodeLeaves(leaves, state.config),\n      ...encodeBranches(linked, state.config),\n    ]\n\n    // We want to keep run loop around until root node is linked. To\n    // accomplish this we fork a task that suspends itself, which we will\n    // resume when root is linked (see link function).\n    // Below we join this forked task in our effect, this way effect is not\n    // complete until task forked task is, which will do once we link the\n    // root.\n    const fork = Task.fork(Task.suspend())\n\n    return {\n      state: {\n        ...state,\n        chunker: null,\n        layout: null,\n        rootID: root.id,\n        status: \"closed\",\n        end: fork,\n        nodeQueue,\n      },\n      effect: Task.listen({\n        link: Task.effects(tasks),\n        end: Task.join(fork),\n      }),\n    }\n  } else {\n    return { state, effect: Task.none() }\n  }\n}\n\n/**\n * Creates concurrent leaf encode tasks. Each one will have an ID corresponding\n * to index in the queue.\n *\n * @param {Layout.Leaf[]} leaves\n * @param {API.EncoderSettings} config\n */\nconst encodeLeaves = (leaves, config) =>\n  leaves.map(leaf => encodeLeaf(config, leaf, config.fileChunkEncoder))\n\n/**\n * @param {API.EncoderSettings} config\n * @param {Layout.Leaf} leaf\n * @param {API.FileChunkEncoder} encoder\n * @returns {Task.Task<API.EncodedFile, never>}\n */\nconst encodeLeaf = function* ({ hasher, linker }, { id, content }, encoder) {\n  const bytes = encoder.encode(content ? asUint8Array(content) : EMPTY_BUFFER)\n  const hash = yield* Task.wait(hasher.digest(bytes))\n  const cid = linker.createLink(encoder.code, hash)\n\n  const block = { cid, bytes }\n  const link = /** @type {UnixFS.FileLink} */ ({\n    cid,\n    contentByteLength: content ? content.byteLength : 0,\n    dagByteLength: bytes.byteLength,\n  })\n\n  return { id, block, link }\n}\n\n/**\n * @param {Queue.LinkedNode[]} nodes\n * @param {API.EncoderSettings} config\n */\nconst encodeBranches = (nodes, config) =>\n  nodes.map(node => encodeBranch(config, node))\n\n/**\n * @template Layout\n * @param {API.EncoderSettings<Layout>} config\n * @param {Queue.LinkedNode} node\n * @param {UnixFS.Metadata} [metadata]\n * @returns {Task.Task<API.EncodedFile>}\n */\nexport const encodeBranch = function* (config, { id, links }, metadata) {\n  const bytes = config.fileEncoder.encode({\n    type: UnixFS.NodeType.File,\n    layout: \"advanced\",\n    parts: links,\n    metadata,\n  })\n  const hash = yield* Task.wait(Promise.resolve(config.hasher.digest(bytes)))\n  const cid = config.linker.createLink(config.fileEncoder.code, hash)\n  const block = { bytes, cid }\n  const link = /** @type {UnixFS.FileLink} */ ({\n    cid,\n    contentByteLength: UnixFS.cumulativeContentByteLength(links),\n    dagByteLength: UnixFS.cumulativeDagByteLength(bytes, links),\n  })\n\n  return { id, block, link }\n}\n\n/**\n * @param {API.BlockWriter} writer\n * @param {UnixFS.Block} block\n * @returns {Task.Task<void, never>}\n */\n\nexport const writeBlock = function* (writer, block) {\n  if ((writer.desiredSize || 0) <= 0) {\n    yield* Task.wait(writer.ready)\n  }\n  writer.write(block)\n}\n\n/**\n *\n * @param {Uint8Array|Chunker.Chunk} buffer\n * @returns\n */\n\nconst asUint8Array = buffer =>\n  buffer instanceof Uint8Array\n    ? buffer\n    : buffer.copyTo(new Uint8Array(buffer.byteLength), 0)\n\n/**\n * @param {Layout.Node} node\n * @returns {node is Layout.Leaf}\n */\nconst isLeafNode = node => node.children == null\n","import * as API from \"./api.js\"\n\nexport const name = \"fixed\"\n/**\n * @typedef {Object} FixedSize\n * @property {number} maxChunkSize\n */\n\n/** @type {FixedSize} */\nexport const context = {\n  maxChunkSize: 262144,\n}\n\nexport const type = \"Stateless\"\n\n/**\n * @param {number} maxChunkSize\n * @returns {API.StatelessChunker<FixedSize>}\n */\nexport const withMaxChunkSize = maxChunkSize => ({\n  type: \"Stateless\",\n  context: { maxChunkSize },\n  name,\n  cut,\n})\n\n/**\n * @param {FixedSize} maxChunkSize\n * @param {API.Chunk} buffer\n * @param {boolean} end\n * @returns {number[]}\n */\nexport const cut = ({ maxChunkSize }, { byteLength }, end) => {\n  // number of fixed size chunks that would fit\n  const n = (byteLength / maxChunkSize) | 0\n  const chunks = new Array(n).fill(maxChunkSize)\n  const lastChunkSize = end ? byteLength - n * maxChunkSize : 0\n  if (lastChunkSize > 0) {\n    chunks.push(lastChunkSize)\n  }\n  return chunks\n}\n","import * as Layout from \"./api.js\"\nimport * as Chunker from \"./../chunker/api.js\"\n\n/**\n * Type representing a state of the balanced tree. First row hold leaves coming\n * into a builder, once number of leaves in the stack reaches `maxChildren` they\n * are moved into `RootNode` instance which is pushed into the next row of nodes.\n * If next row now contains `maxChildren` nodes from there are again moved into\n * a new `RootNode` and pushed into next row etc...\n *\n * For illustration let's assume we have `maxChildren: 3`, after 3 leafs were\n * added tree will have following layout\n *\n * ```\n *           (root1)\n *              |\n *    ----------------------\n *    |         |          |\n * (leaf1)   (leaf2)    (leaf3)\n * ```\n *\n * Which in our model before flushing is represented as follows:\n *\n * ```js\n * {\n *    width: 3\n *    leafIndex: [leaf1, leaf2, leaf3]\n *    nodeIndex: []\n *    nodes: []\n * }\n * ```\n *\n * After flushing 3 leaves (which is width) are moved into a `RootNode` that\n * is added to `nodes` array (and returned so that caller can create a block).\n * Additionally position of the added node is captured in the `index` at an\n * appropriate depth `0` (that is because we don't count leaves into depth).\n *\n * ```js\n * {\n *    width: 3\n *    leafIndex: []\n *    nodeIndex: [[0]]\n *    nodes: [new RootNode([leaf1, leaf2, leaf3])]\n * }\n * ```\n *\n * Increasing number of leaves to 10 would produce following tree layout\n *\n *```\n *                                                         (root7)\n *                                                           |\n *                                    ------------------------------------------\n *                                    |                                        |\n *                                 (root4)                                  (root6)\n *                                    |                                        |\n *            -------------------------------------------------                |\n *            |                       |                       |                |\n *         (root1)                 (root2)                 (root3)          (root5)\n *            |                       |                       |                |\n *    --------|--------       --------|--------       --------|--------        |\n *    |       |       |       |       |       |       |       |       |        |\n * (leaf1) (leaf2) (leaf3) (leaf4) (leaf5) (leaf6) (leaf7) (leaf8) (leaf9) (leaf10)\n * ```\n *\n * Which in our model will look as follows (note we do not have root5 - root7\n * in model because they are build once width is reached or once builder is\n * closed)\n *\n * ```js\n * {\n *    width: 3\n *    leafIndex: [leaf10]\n *    nodeIndex: [\n *      [0, 1, 2], // [r1, r2, r3]\n *      [3]        // [r4]\n *     ]\n *    nodes: [\n *      new Node([leaf1, leaf2, leaf3]), // r1\n *      new Node([leaf4, leaf5, leaf6]), // r2\n *      new Node([leaf7, leaf8, leaf9]), // r3\n *      new Node([ // r4\n *         new Node([leaf1, leaf2, leaf3]), // r1\n *         new Node([leaf4, leaf5, leaf6]), // r2\n *         new Node([leaf7, leaf8, leaf9]), // r3\n *      ])\n *    ]\n * }\n * ```\n *\n * @typedef {{\n * width: number\n * head: Chunker.Chunk | null\n * leafIndex: number[]\n * nodeIndex: number[][]\n * lastID: number\n * }} Balanced\n */\n\nclass Node {\n  /**\n   *\n   * @param {number} id\n   * @param {number[]} children\n   * @param {Layout.Metadata} [metadata]\n   */\n  constructor(id, children, metadata) {\n    this.id = id\n    this.children = children\n    this.metadata = metadata\n  }\n}\n\n/**\n * @typedef Options\n * @property {number} width - Max children per node.\n *\n * @param {number} width\n * @returns {Layout.LayoutEngine<Balanced>}\n */\nexport const withWidth = width => ({\n  open: () => open({ width }),\n  write,\n  close,\n})\n\nexport const defaults = { width: 174 }\n\n/**\n * @param {Options} options\n * @returns {Balanced}\n */\nexport const open = ({ width } = defaults) => ({\n  width,\n\n  head: null,\n  leafIndex: [],\n  nodeIndex: [],\n  lastID: 0,\n})\n\n/**\n *\n * @param {Balanced} layout\n * @param {Chunker.Chunk[]} chunks\n * @returns {Layout.WriteResult<Balanced>}\n */\nexport const write = (layout, chunks) => {\n  if (chunks.length === 0) {\n    return { layout, nodes: EMPTY, leaves: EMPTY }\n  } else {\n    let { lastID } = layout\n    // We need to hold on to the first chunk until we either get a second chunk\n    // (at which point we know our layout will have branches) or until we close\n    // (at which point our layout will be single leaf or node depneding on\n    // metadata)\n    const [head, slices] = layout.head\n      ? // If we had a head we have more then two chunks (we already checked\n        // chunks weren't empty) so we process head along with other chunks.\n        [null, (chunks.unshift(layout.head), chunks)]\n      : // If we have no head no leaves and got only one chunk we have to save it\n      // until we can decide what to do with it.\n      chunks.length === 1 && layout.leafIndex.length === 0\n      ? [chunks[0], EMPTY]\n      : // Otherwise we have no head but got enough chunks to know we'll have a\n        // node.\n        [null, chunks]\n\n    if (slices.length === 0) {\n      return { layout: { ...layout, head }, nodes: EMPTY, leaves: EMPTY }\n    } else {\n      const leafIndex = [...layout.leafIndex]\n      const leaves = []\n      for (const chunk of slices) {\n        const leaf = { id: ++lastID, content: chunk }\n        leaves.push(leaf)\n        leafIndex.push(leaf.id)\n      }\n\n      if (leafIndex.length > layout.width) {\n        return flush({ ...layout, leafIndex, head, lastID }, leaves)\n      } else {\n        return {\n          layout: { ...layout, head, leafIndex, lastID },\n          leaves,\n          nodes: EMPTY,\n        }\n      }\n    }\n  }\n}\n\n/**\n * @param {Balanced} state\n * @param {Layout.Leaf[]} leaves\n * @param {Layout.Branch[]} [nodes]\n * @param {boolean} [close]\n * @returns {Layout.WriteResult<Balanced>}\n */\nexport const flush = (state, leaves = EMPTY, nodes = [], close = false) => {\n  let { lastID } = state\n  const nodeIndex = state.nodeIndex.map(row => [...row])\n  const leafIndex = [...state.leafIndex]\n  const { width } = state\n\n  // Move leaves into nodes\n  while (leafIndex.length > width || (leafIndex.length > 0 && close)) {\n    grow(nodeIndex, 1)\n    const node = new Node(++lastID, leafIndex.splice(0, width))\n    nodeIndex[0].push(node.id)\n    nodes.push(node)\n  }\n\n  let depth = 0\n  while (depth < nodeIndex.length) {\n    const row = nodeIndex[depth]\n    depth++\n\n    while (\n      row.length > width ||\n      (row.length > 0 && close && depth < nodeIndex.length)\n    ) {\n      const node = new Node(++lastID, row.splice(0, width))\n      grow(nodeIndex, depth + 1)\n      nodeIndex[depth].push(node.id)\n      nodes.push(node)\n    }\n  }\n\n  return { layout: { ...state, lastID, leafIndex, nodeIndex }, leaves, nodes }\n}\n\n/**\n * @param {Balanced} layout\n * @param {Layout.Metadata} [metadata]\n * @returns {Layout.CloseResult}\n */\nexport const close = (layout, metadata) => {\n  const state = layout\n  if (layout.head) {\n    return {\n      root: { id: 1, content: layout.head, metadata },\n      leaves: EMPTY,\n      nodes: EMPTY,\n    }\n  } else if (layout.leafIndex.length === 0) {\n    return {\n      root: { id: 1, metadata },\n      leaves: EMPTY,\n      nodes: EMPTY,\n    }\n  } else {\n    // Flush with width 1 so all the items will be propagate up the tree\n    // and height of `depth-1` so we propagate nodes all but from the top\n    // most level\n    const { nodes, layout } = flush(state, EMPTY, [], true)\n\n    const { nodeIndex } = layout\n    const height = nodeIndex.length - 1\n\n    const top = nodeIndex[height]\n    if (top.length === 1) {\n      const root = nodes[nodes.length - 1]\n      nodes.length = nodes.length - 1\n      return { root, nodes, leaves: EMPTY }\n    } else {\n      const root = new Node(layout.lastID + 1, top, metadata)\n      return { root, nodes, leaves: EMPTY }\n    }\n  }\n}\n\n/**\n * @template T\n * @param {T[][]} index\n * @param {number} length\n */\nconst grow = (index, length) => {\n  while (index.length < length) {\n    index.push([])\n  }\n  return index\n}\n\n/** @type {never[]} */\nconst EMPTY = []\n","import * as API from \"./file/api.js\"\nimport * as UnixFS from \"./codec.js\"\nimport * as Writer from \"./file/writer.js\"\nimport * as Task from \"actor\"\nimport { panic } from \"./writer/util.js\"\nimport * as FixedSize from \"./file/chunker/fixed.js\"\nimport { sha256 } from \"multiformats/hashes/sha2\"\nimport { CID } from \"multiformats/cid\"\nimport * as Balanced from \"./file/layout/balanced.js\"\n\nexport * from \"./file/api.js\"\n\n/**\n * @returns {API.EncoderSettings}\n */\nexport const defaults = () => ({\n  chunker: FixedSize,\n  fileChunkEncoder: UnixFSLeaf,\n  smallFileEncoder: UnixFSLeaf,\n  fileEncoder: UnixFS,\n  fileLayout: Balanced.withWidth(174),\n  hasher: sha256,\n  linker: { createLink: CID.createV1 },\n})\n\n/**\n * @template {unknown} Layout\n * @param {Partial<API.EncoderSettings<Layout>>} config\n * @returns {API.EncoderSettings<Layout>}\n */\nexport const configure = config => ({\n  ...defaults(),\n  ...config,\n})\n\nexport const UnixFSLeaf = {\n  code: UnixFS.code,\n  name: UnixFS.name,\n  encode: UnixFS.encodeFileChunk,\n}\n\nexport const UnixFSRawLeaf = {\n  code: UnixFS.code,\n  name: UnixFS.name,\n  encode: UnixFS.encodeRaw,\n}\n\n/**\n * @template Layout\n * @param {API.Options<Layout>} options\n * @returns {API.View<Layout>}\n */\nexport const create = ({ writer, metadata = {}, settings = defaults() }) =>\n  new FileWriterView(Writer.init(writer, metadata, configure(settings)))\n\n/**\n * @template T\n * @param {API.View<T>} view\n * @param {Uint8Array} bytes\n * @return {Promise<API.View<T>>}\n */\n\nexport const write = async (view, bytes) => {\n  await perform(view, Task.send({ type: \"write\", bytes }))\n  return view\n}\n\n/**\n * @template T\n * @param {API.View<T>} view\n * @param {API.CloseOptions} options\n */\nexport const close = async (\n  view,\n  { releaseLock = false, closeWriter = false } = {}\n) => {\n  await perform(view, Task.send({ type: \"close\" }))\n  const { state } = view\n  if (state.status === \"linked\") {\n    if (closeWriter) {\n      await view.state.writer.close()\n    } else if (releaseLock) {\n      view.state.writer.releaseLock()\n    }\n    return state.link\n    /* c8 ignore next 5 */\n  } else {\n    panic(\n      `Expected writer to be in 'linked' state after close, but it is in \"${state.status}\" instead`\n    )\n  }\n}\n\n/**\n * @template T\n * @param {API.View<T>} view\n * @param {Task.Effect<Writer.Message>} effect\n */\nconst perform = (view, effect) =>\n  Task.fork(\n    Task.loop(effect, message => {\n      const { state, effect } = Writer.update(message, view.state)\n      view.state = state\n      return effect\n    })\n  )\n\n/**\n * @template Layout\n * @implements {API.View<Layout>}\n */\nclass FileWriterView {\n  /**\n   * @param {Writer.State<Layout>} state\n   */\n  constructor(state) {\n    this.state = state\n  }\n  get writer() {\n    return this.state.writer\n  }\n  get settings() {\n    return this.state.config\n  }\n  /**\n   * @param {Uint8Array} bytes\n   * @returns {Promise<API.View<Layout>>}\n   */\n  write(bytes) {\n    return write(this, bytes)\n  }\n  /**\n   * @param {API.CloseOptions} [options]\n   * @returns {Promise<UnixFS.FileLink>}\n   */\n  close(options) {\n    return close(this, options)\n  }\n}\n","import * as API from \"./directory/api.js\"\nimport * as File from \"./file.js\"\nimport * as UnixFS from \"./codec.js\"\nexport * from \"./directory/api.js\"\n\nexport const configure = File.configure\nexport const defaults = File.defaults\n\n/**\n * @template [Layout=unknown]\n * @param {API.Options<Layout>} config\n * @returns {API.View<Layout>}\n */\nexport const create = ({ writer, settings = defaults(), metadata = {} }) =>\n  new DirectoryWriter({\n    writer,\n    metadata,\n    settings,\n    entries: new Map(),\n    closed: false,\n  })\n\n/**\n * @template {unknown} L\n * @template {{ state: API.State<L> }} View\n * @param {View} view\n * @param {string} name\n * @param {API.EntryLink} link\n * @param {API.WriteOptions} options\n */\nexport const set = (view, name, link, { overwrite = false } = {}) => {\n  const writable = asWritable(view.state)\n  if (name.includes(\"/\")) {\n    throw new Error(\n      `Directory entry name \"${name}\" contains forbidden \"/\" character`\n    )\n  }\n  if (!overwrite && writable.entries.has(name)) {\n    throw new Error(`Directory already contains entry with name \"${name}\"`)\n  } else {\n    writable.entries.set(name, link)\n    return view\n  }\n}\n\n/**\n * @template {unknown} L\n * @template {{ state: API.State<L> }} View\n * @param {View} view\n * @param {string} name\n */\nexport const remove = (view, name) => {\n  const writer = asWritable(view.state)\n  writer.entries.delete(name)\n  return view\n}\n\n/**\n * @template {API.State} Writer\n * @param {Writer} writer\n * @returns {Writer}\n */\nconst asWritable = writer => {\n  if (!writer.closed) {\n    return writer\n  } else {\n    throw new Error(\n      `Can not change written directory, but you can .fork() and make changes to it`\n    )\n  }\n}\n\n/**\n * @template {unknown} Layout\n * @param {{ state: API.State<Layout> }} view\n * @param {API.CloseOptions} options\n * @returns {Promise<UnixFS.DirectoryLink>}\n */\nexport const close = async (\n  view,\n  { closeWriter = false, releaseLock = false } = {}\n) => {\n  const { writer, settings, metadata } = asWritable(view.state)\n  view.state.closed = true\n  const entries = [...links(view)]\n  const node = UnixFS.createFlatDirectory(entries, metadata)\n  const bytes = UnixFS.encodeDirectory(node)\n  const digest = await settings.hasher.digest(bytes)\n  /** @type {UnixFS.Link<UnixFS.Directory>} */\n  const cid = settings.linker.createLink(UnixFS.code, digest)\n\n  // we make sure that writer has some capacity for this write. If it\n  // does not we await.\n  if ((writer.desiredSize || 0) <= 0) {\n    await writer.ready\n  }\n  // once writer has some capacity we write a block, however we do not\n  // await completion as we don't care when it's taken off the stream.\n  writer.write({ cid, bytes })\n\n  if (closeWriter) {\n    await writer.close()\n  } else if (releaseLock) {\n    writer.releaseLock()\n  }\n\n  return {\n    cid,\n    dagByteLength: UnixFS.cumulativeDagByteLength(bytes, entries),\n  }\n}\n\n/**\n * @template {unknown} Layout\n * @param {{ state: API.State<Layout> }} view\n * @returns {IterableIterator<UnixFS.DirectoryEntryLink>}\n */\nexport const links = function* ({ state }) {\n  for (const [name, { dagByteLength, cid }] of state.entries) {\n    yield /** @type {UnixFS.DirectoryEntryLink} */ ({\n      name,\n      dagByteLength,\n      cid,\n    })\n  }\n}\n\n/**\n * @template L1, L2\n * @param {API.View<L1>} state\n * @param {Partial<API.Options<L1|L2>>} options\n * @returns {API.View<L1|L2>}\n */\nexport const fork = (\n  { state },\n  {\n    writer = state.writer,\n    metadata = state.metadata,\n    settings = state.settings,\n  } = {}\n) =>\n  new DirectoryWriter({\n    writer,\n    metadata,\n    settings,\n    entries: new Map(state.entries.entries()),\n    closed: false,\n  })\n\n/**\n * @template [Layout=unknown]\n * @implements {API.View<Layout>}\n */\nclass DirectoryWriter {\n  /**\n   * @param {API.State<Layout>} state\n   */\n  constructor(state) {\n    this.state = state\n  }\n  get writer() {\n    return this.state.writer\n  }\n  get settings() {\n    return this.state.settings\n  }\n\n  links() {\n    return links(this)\n  }\n\n  /**\n   * @param {string} name\n   * @param {UnixFS.FileLink | UnixFS.DirectoryLink} link\n   * @param {API.WriteOptions} [options]\n   */\n\n  set(name, link, options) {\n    return set(this, name, link, options)\n  }\n\n  /**\n   * @param {string} name\n   */\n  remove(name) {\n    return remove(this, name)\n  }\n\n  /**\n   * @template L\n   * @param {Partial<API.Options<L>>} [options]\n   * @returns {API.View<Layout|L>}\n   */\n  fork(options) {\n    return fork(this, options)\n  }\n\n  /**\n   * @param {API.CloseOptions} [options]\n   * @returns {Promise<UnixFS.DirectoryLink>}\n   */\n  close(options) {\n    return close(this, options)\n  }\n\n  entries() {\n    return this.state.entries.entries()\n  }\n  /**\n   * @param {string} name\n   */\n  has(name) {\n    return this.state.entries.has(name)\n  }\n  get size() {\n    return this.state.entries.size\n  }\n}\n","\nimport * as PermaMap from \"@perma/map\"\nimport * as UnixFSPermaMap from \"@perma/map/unixfs\"\nimport * as PB from \"@ipld/dag-pb\"\nimport { murmur364 } from \"@multiformats/murmur3\"\nimport { Block } from 'multiformats/block'\nimport * as API from \"./directory/api.js\"\nimport * as File from \"./file.js\"\nimport * as UnixFS from \"./codec.js\"\nimport { set, remove } from \"./directory.js\"\n\nexport * from \"./directory/api.js\"\nexport { set, remove } from \"./directory.js\"\n\nexport const configure = File.configure\nexport const defaults = File.defaults\n\n/**\n * @template [Layout=unknown]\n * @param {API.Options<Layout>} config\n * @returns {API.View<Layout>}\n */\nexport const create = ({ writer, settings = defaults(), metadata = {} }) =>\n  new HAMTDirectoryWriter({\n    writer,\n    metadata,\n    settings,\n    entries: new HashMap(),\n    closed: false,\n  })\n\n/**\n * @template {API.State} Writer\n * @param {Writer} writer\n * @returns {Writer}\n */\nconst asWritable = writer => {\n  if (!writer.closed) {\n    return writer\n  } else {\n    throw new Error(\"Can not change written HAMT directory, but you can .fork() and make changes to it\")\n  }\n}\n\n/**\n * @template {unknown} Layout\n * @param {{ state: API.State<Layout> }} view\n * @param {API.CloseOptions} options\n * @returns {Promise<UnixFS.DirectoryLink>}\n */\nexport const close = async (\n  view,\n  { closeWriter = false, releaseLock = false } = {}\n) => {\n  const { writer, settings, metadata } = asWritable(view.state)\n  view.state.closed = true\n\n  const { entries } = view.state\n  /* c8 ignore next 3 */\n  if (!(entries instanceof HashMap)) {\n    throw new Error(`not a HAMT: ${entries}`)\n  }\n\n  const hamt = entries.builder.build()\n  const blocks = iterateBlocks(hamt, hamt.root, settings)\n\n  /** @type {UnixFS.BlockView<UnixFS.DirectoryShard>?} */\n  let root = null\n  for await (const block of blocks) {\n    root = block\n    // we make sure that writer has some capacity for this write. If it\n    // does not we await.\n    if ((writer.desiredSize || 0) <= 0) {\n      await writer.ready\n    }\n    // once writer has some capacity we write a block, however we do not\n    // await completion as we don't care when it's taken off the stream.\n    writer.write(block)\n  }\n  /* c8 ignore next */\n  if (root == null) throw new Error(\"no root block yielded\")\n\n  if (closeWriter) {\n    await writer.close()\n  } else if (releaseLock) {\n    writer.releaseLock()\n  }\n\n  return {\n    cid: root.cid,\n    dagByteLength: UnixFS.cumulativeDagByteLength(root.bytes, root.value.entries),\n  }\n}\n\n/**\n * @template {unknown} Layout\n * @param {UnixFSPermaMap.PersistentHashMap<API.EntryLink>} hamt\n * @param {UnixFSPermaMap.BitmapIndexedNode<API.EntryLink>} node\n * @param {API.EncoderSettings<Layout>} settings\n * @returns {AsyncIterableIterator<UnixFS.BlockView<UnixFS.DirectoryShard>>}\n */\nconst iterateBlocks = async function* (hamt, node, settings) {\n  /** @type {UnixFS.DirectoryEntryLink[]} */\n  const entries = []\n  for (const ent of UnixFSPermaMap.iterate(node)) {\n    if ('key' in ent) {\n      entries.push(/** @type {UnixFS.DirectoryEntryLink} */ ({\n        name: `${ent.prefix ?? ''}${ent.key ?? ''}`,\n        dagByteLength: ent.value.dagByteLength,\n        cid: ent.value.cid,\n      }))\n    } else {\n      /** @type {UnixFS.BlockView<UnixFS.DirectoryShard>?} */\n      let root = null\n      for await (const block of iterateBlocks(hamt, ent.node, settings)) {\n        yield block\n        root = block\n      }\n      /* c8 ignore next */\n      if (root == null) throw new Error(\"no root block yielded\")\n\n      entries.push(/** @type {UnixFS.ShardedDirectoryLink} */ ({\n        name: ent.prefix,\n        dagByteLength: UnixFS.cumulativeDagByteLength(root.bytes, root.value.entries),\n        cid: root.cid\n      }))\n    }\n  }\n\n  const shard = UnixFS.createDirectoryShard(\n    entries,\n    UnixFSPermaMap.bitField(node),\n    UnixFSPermaMap.tableSize(hamt),\n    murmur364.code\n  )\n  yield await encodeHAMTShardBlock(shard, settings)\n}\n\n/**\n * @template {unknown} Layout\n * @param {UnixFS.DirectoryShard} shard\n * @param {API.EncoderSettings<Layout>} settings\n * @returns {Promise<UnixFS.BlockView<UnixFS.DirectoryShard>>}\n */\nasync function encodeHAMTShardBlock (shard, settings) {\n  const bytes = UnixFS.encodeHAMTShard(shard)\n  const hash = await settings.hasher.digest(bytes)\n  const cid = settings.linker.createLink(PB.code, hash)\n  // @ts-ignore Link is not CID\n  return new Block({ cid, bytes, value: shard })\n}\n\n/**\n * @template L1, L2\n * @param {API.View<L1>} state\n * @param {Partial<API.Options<L1|L2>>} options\n * @returns {API.View<L1|L2>}\n */\nexport const fork = (\n  { state },\n  {\n    writer = state.writer,\n    metadata = state.metadata,\n    settings = state.settings,\n  } = {}\n) =>\n  new HAMTDirectoryWriter({\n    writer,\n    metadata,\n    settings,\n    entries: new HashMap(UnixFSPermaMap.from(state.entries.entries()).createBuilder()),\n    closed: false,\n  })\n\n/**\n * @template [Layout=unknown]\n * @implements {API.View<Layout>}\n */\nclass HAMTDirectoryWriter {\n  /**\n   * @param {API.State<Layout>} state\n   */\n  constructor(state) {\n    this.state = state\n  }\n  get writer() {\n    return this.state.writer\n  }\n  get settings() {\n    return this.state.settings\n  }\n\n  /**\n   * @param {string} name\n   * @param {UnixFS.FileLink | UnixFS.DirectoryLink} link\n   * @param {API.WriteOptions} [options]\n   */\n\n  set(name, link, options) {\n    return set(this, name, link, options)\n  }\n\n  /**\n   * @param {string} name\n   */\n  remove(name) {\n    return remove(this, name)\n  }\n\n  /**\n   * @template L\n   * @param {Partial<API.Options<L>>} [options]\n   * @returns {API.View<Layout|L>}\n   */\n  fork(options) {\n    return fork(this, options)\n  }\n\n  /**\n   * @param {API.CloseOptions} [options]\n   * @returns {Promise<UnixFS.DirectoryLink>}\n   */\n  close(options) {\n    return close(this, options)\n  }\n\n  entries() {\n    return this.state.entries.entries()\n  }\n  /**\n   * @param {string} name\n   */\n  has(name) {\n    return this.state.entries.has(name)\n  }\n  get size() {\n    return this.state.entries.size\n  }\n}\n\n/**\n * @implements {Map<string, API.EntryLink>}\n */\nclass HashMap extends Map {\n  /**\n   * @param {UnixFSPermaMap.HashMapBuilder} [builder]\n   */\n  constructor (builder = UnixFSPermaMap.builder()) {\n    super()\n    /** @type {UnixFSPermaMap.HashMapBuilder} */\n    this.builder = builder\n  }\n\n  clear() {\n    this.builder = UnixFSPermaMap.builder()\n  }\n\n  /**\n   * @param {string} key\n   */\n  delete(key) {\n    const { root } = this.builder\n    this.builder.delete(key)\n    return this.builder.root !== root\n  }\n\n  /**\n   * @param {(value: API.EntryLink, key: string, map: Map<string, API.EntryLink>) => void} callbackfn\n   * @param {any} [thisArg]\n   */\n  forEach(callbackfn, thisArg = this) {\n    for (const [k, v] of this.builder.root.entries()) {\n      callbackfn.call(thisArg, v, k, this)\n    }\n  }\n\n  /**\n   * @param {string} key\n   */\n  get(key) {\n    return PermaMap.get(this.builder, key)\n  }\n\n  /**\n   * @param {string} key\n   */\n  has(key) {\n    return PermaMap.has(this.builder, key)\n  }\n\n  /**\n   * @param {string} key \n   * @param {API.EntryLink} value \n   */\n  set(key, value) {\n    this.builder.set(key, value)\n    return this\n  }\n\n  get size () {\n    return this.builder.size\n  }\n\n  [Symbol.iterator]() {\n    return this.builder.root.entries()\n  }\n\n  entries() {\n    return this.builder.root.entries()\n  }\n\n  keys() {\n    return this.builder.root.keys()\n  }\n\n  values() {\n    return this.builder.root.values()\n  }\n}\n","import * as API from \"./api.js\"\nimport * as File from \"./file.js\"\nimport * as Directory from \"./directory.js\"\n\nexport * from \"./api.js\"\n\nexport { encode, decode, NodeType, code } from \"./codec.js\"\nexport {\n  create as createFileWriter,\n  close as closeFile,\n  write,\n  configure,\n  defaults,\n  UnixFSLeaf,\n  UnixFSRawLeaf,\n} from \"./file.js\"\nexport {\n  create as createDirectoryWriter,\n  close as closeDirectory,\n  fork as forkDirectory,\n  set,\n  remove,\n} from \"./directory.js\"\nexport {\n  create as createShardedDirectoryWriter,\n  close as closeShardedDirectory,\n  fork as forkShardedDirectory,\n} from \"./sharded-directory.js\"\n\n/**\n * @template [Layout=unknown]\n * @param {API.Options<Layout>} options\n * @returns {API.View<Layout>}\n */\nexport const createWriter = ({ writable, settings = File.defaults() }) =>\n  new FileSystemWriter({\n    writer: writable.getWriter(),\n    settings,\n  })\n\n/**\n * @template {{writer:API.BlockWriter}} View\n * @param {View} view\n * @param {API.CloseOptions} options\n */\nexport const close = async (\n  view,\n  { releaseLock = true, closeWriter = true } = {}\n) => {\n  if (closeWriter) {\n    await view.writer.close()\n  } else if (releaseLock) {\n    view.writer.releaseLock()\n  }\n\n  return view\n}\n\n/**\n * @template [Layout=unknown]\n * @implemets {API.View<Layout>}\n */\nclass FileSystemWriter {\n  /**\n   * @param {object} options\n   * @param {API.BlockWriter} options.writer\n   * @param {Partial<API.EncoderSettings<Layout>>} options.settings\n   */\n  constructor({ writer, settings }) {\n    this.writer = writer\n    this.settings = File.configure(settings)\n  }\n\n  /**\n   * @template [L=unknown]\n   * @param {API.WriterOptions<L|Layout>} config\n   */\n  createFileWriter({ settings = this.settings, metadata } = {}) {\n    return File.create({\n      writer: this.writer,\n      settings,\n      metadata,\n    })\n  }\n\n  /**\n   * @template [L=unknown]\n   * @param {API.WriterOptions<L|Layout>} config\n   */\n  createDirectoryWriter({ settings = this.settings, metadata } = {}) {\n    return Directory.create({\n      writer: this.writer,\n      settings,\n      metadata,\n    })\n  }\n\n  /**\n   * @param {API.CloseOptions} [options]\n   */\n  close(options) {\n    return close(this, options)\n  }\n}\n\n// BlockSizeLimit specifies the maximum size an imported block can have.\n// @see https://github.com/ipfs/go-unixfs/blob/68c015a6f317ed5e21a4870f7c423a4b38b90a96/importer/helpers/helpers.go#L7-L8\nexport const BLOCK_SIZE_LIMIT = 1048576 // 1 MB\nexport const defaultCapacity = BLOCK_SIZE_LIMIT * 100\n\n/**\n * Creates `QueuingStrategy` that can fit blocks with total size up to given\n * byteLength.\n *\n * @param {number} byteLength\n * @returns {Required<QueuingStrategy<API.Block>>}\n */\nexport const withCapacity = (byteLength = defaultCapacity) => ({\n  highWaterMark: byteLength,\n  size: block => block.bytes.length,\n})\n"]}