@kamino-finance/klend-sdk 7.3.5-beta.0 → 7.3.5

package/dist/chunk-5RQOM3VO.js

@@ -1,1628 +0,0 @@
-import { __commonJS } from './chunk-PR4QN5HX.js';
-
-// node_modules/buffer-layout/lib/Layout.js
-var require_Layout = __commonJS({
-  "node_modules/buffer-layout/lib/Layout.js"(exports$1) {
-    var Layout = class {
-      constructor(span, property) {
-        if (!Number.isInteger(span)) {
-          throw new TypeError("span must be an integer");
-        }
-        this.span = span;
-        this.property = property;
-      }
-      /** Function to create an Object into which decoded properties will
-       * be written.
-       *
-       * Used only for layouts that {@link Layout#decode|decode} to Object
-       * instances, which means:
-       * * {@link Structure}
-       * * {@link Union}
-       * * {@link VariantLayout}
-       * * {@link BitStructure}
-       *
-       * If left undefined the JavaScript representation of these layouts
-       * will be Object instances.
-       *
-       * See {@link bindConstructorLayout}.
-       */
-      makeDestinationObject() {
-        return {};
-      }
-      /**
-       * Decode from a Buffer into an JavaScript value.
-       *
-       * @param {Buffer} b - the buffer from which encoded data is read.
-       *
-       * @param {Number} [offset] - the offset at which the encoded data
-       * starts.  If absent a zero offset is inferred.
-       *
-       * @returns {(Number|Array|Object)} - the value of the decoded data.
-       *
-       * @abstract
-       */
-      decode(b, offset) {
-        throw new Error("Layout is abstract");
-      }
-      /**
-       * Encode a JavaScript value into a Buffer.
-       *
-       * @param {(Number|Array|Object)} src - the value to be encoded into
-       * the buffer.  The type accepted depends on the (sub-)type of {@link
-       * Layout}.
-       *
-       * @param {Buffer} b - the buffer into which encoded data will be
-       * written.
-       *
-       * @param {Number} [offset] - the offset at which the encoded data
-       * starts.  If absent a zero offset is inferred.
-       *
-       * @returns {Number} - the number of bytes encoded, including the
-       * space skipped for internal padding, but excluding data such as
-       * {@link Sequence#count|lengths} when stored {@link
-       * ExternalLayout|externally}.  This is the adjustment to `offset`
-       * producing the offset where data for the next layout would be
-       * written.
-       *
-       * @abstract
-       */
-      encode(src, b, offset) {
-        throw new Error("Layout is abstract");
-      }
-      /**
-       * Calculate the span of a specific instance of a layout.
-       *
-       * @param {Buffer} b - the buffer that contains an encoded instance.
-       *
-       * @param {Number} [offset] - the offset at which the encoded instance
-       * starts.  If absent a zero offset is inferred.
-       *
-       * @return {Number} - the number of bytes covered by the layout
-       * instance.  If this method is not overridden in a subclass the
-       * definition-time constant {@link Layout#span|span} will be
-       * returned.
-       *
-       * @throws {RangeError} - if the length of the value cannot be
-       * determined.
-       */
-      getSpan(b, offset) {
-        if (0 > this.span) {
-          throw new RangeError("indeterminate span");
-        }
-        return this.span;
-      }
-      /**
-       * Replicate the layout using a new property.
-       *
-       * This function must be used to get a structurally-equivalent layout
-       * with a different name since all {@link Layout} instances are
-       * immutable.
-       *
-       * **NOTE** This is a shallow copy.  All fields except {@link
-       * Layout#property|property} are strictly equal to the origin layout.
-       *
-       * @param {String} property - the value for {@link
-       * Layout#property|property} in the replica.
-       *
-       * @returns {Layout} - the copy with {@link Layout#property|property}
-       * set to `property`.
-       */
-      replicate(property) {
-        const rv = Object.create(this.constructor.prototype);
-        Object.assign(rv, this);
-        rv.property = property;
-        return rv;
-      }
-      /**
-       * Create an object from layout properties and an array of values.
-       *
-       * **NOTE** This function returns `undefined` if invoked on a layout
-       * that does not return its value as an Object.  Objects are
-       * returned for things that are a {@link Structure}, which includes
-       * {@link VariantLayout|variant layouts} if they are structures, and
-       * excludes {@link Union}s.  If you want this feature for a union
-       * you must use {@link Union.getVariant|getVariant} to select the
-       * desired layout.
-       *
-       * @param {Array} values - an array of values that correspond to the
-       * default order for properties.  As with {@link Layout#decode|decode}
-       * layout elements that have no property name are skipped when
-       * iterating over the array values.  Only the top-level properties are
-       * assigned; arguments are not assigned to properties of contained
-       * layouts.  Any unused values are ignored.
-       *
-       * @return {(Object|undefined)}
-       */
-      fromArray(values) {
-        return void 0;
-      }
-    };
-    exports$1.Layout = Layout;
-    function nameWithProperty(name, lo) {
-      if (lo.property) {
-        return name + "[" + lo.property + "]";
-      }
-      return name;
-    }
-    exports$1.nameWithProperty = nameWithProperty;
-    function bindConstructorLayout(Class, layout) {
-      if ("function" !== typeof Class) {
-        throw new TypeError("Class must be constructor");
-      }
-      if (Class.hasOwnProperty("layout_")) {
-        throw new Error("Class is already bound to a layout");
-      }
-      if (!(layout && layout instanceof Layout)) {
-        throw new TypeError("layout must be a Layout");
-      }
-      if (layout.hasOwnProperty("boundConstructor_")) {
-        throw new Error("layout is already bound to a constructor");
-      }
-      Class.layout_ = layout;
-      layout.boundConstructor_ = Class;
-      layout.makeDestinationObject = (() => new Class());
-      Object.defineProperty(Class.prototype, "encode", {
-        value: function(b, offset) {
-          return layout.encode(this, b, offset);
-        },
-        writable: true
-      });
-      Object.defineProperty(Class, "decode", {
-        value: function(b, offset) {
-          return layout.decode(b, offset);
-        },
-        writable: true
-      });
-    }
-    exports$1.bindConstructorLayout = bindConstructorLayout;
-    var ExternalLayout = class extends Layout {
-      /**
-       * Return `true` iff the external layout decodes to an unsigned
-       * integer layout.
-       *
-       * In that case it can be used as the source of {@link
-       * Sequence#count|Sequence counts}, {@link Blob#length|Blob lengths},
-       * or as {@link UnionLayoutDiscriminator#layout|external union
-       * discriminators}.
-       *
-       * @abstract
-       */
-      isCount() {
-        throw new Error("ExternalLayout is abstract");
-      }
-    };
-    var GreedyCount = class extends ExternalLayout {
-      constructor(elementSpan, property) {
-        if (void 0 === elementSpan) {
-          elementSpan = 1;
-        }
-        if (!Number.isInteger(elementSpan) || 0 >= elementSpan) {
-          throw new TypeError("elementSpan must be a (positive) integer");
-        }
-        super(-1, property);
-        this.elementSpan = elementSpan;
-      }
-      /** @override */
-      isCount() {
-        return true;
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const rem = b.length - offset;
-        return Math.floor(rem / this.elementSpan);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        return 0;
-      }
-    };
-    var OffsetLayout = class extends ExternalLayout {
-      constructor(layout, offset, property) {
-        if (!(layout instanceof Layout)) {
-          throw new TypeError("layout must be a Layout");
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        } else if (!Number.isInteger(offset)) {
-          throw new TypeError("offset must be integer or undefined");
-        }
-        super(layout.span, property || layout.property);
-        this.layout = layout;
-        this.offset = offset;
-      }
-      /** @override */
-      isCount() {
-        return this.layout instanceof UInt || this.layout instanceof UIntBE;
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return this.layout.decode(b, offset + this.offset);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return this.layout.encode(src, b, offset + this.offset);
-      }
-    };
-    var UInt = class extends Layout {
-      constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-          throw new RangeError("span must not exceed 6 bytes");
-        }
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readUIntLE(offset, this.span);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeUIntLE(src, offset, this.span);
-        return this.span;
-      }
-    };
-    var UIntBE = class extends Layout {
-      constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-          throw new RangeError("span must not exceed 6 bytes");
-        }
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readUIntBE(offset, this.span);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeUIntBE(src, offset, this.span);
-        return this.span;
-      }
-    };
-    var Int = class extends Layout {
-      constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-          throw new RangeError("span must not exceed 6 bytes");
-        }
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readIntLE(offset, this.span);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeIntLE(src, offset, this.span);
-        return this.span;
-      }
-    };
-    var IntBE = class extends Layout {
-      constructor(span, property) {
-        super(span, property);
-        if (6 < this.span) {
-          throw new RangeError("span must not exceed 6 bytes");
-        }
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readIntBE(offset, this.span);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeIntBE(src, offset, this.span);
-        return this.span;
-      }
-    };
-    var V2E32 = Math.pow(2, 32);
-    function divmodInt64(src) {
-      const hi32 = Math.floor(src / V2E32);
-      const lo32 = src - hi32 * V2E32;
-      return { hi32, lo32 };
-    }
-    function roundedInt64(hi32, lo32) {
-      return hi32 * V2E32 + lo32;
-    }
-    var NearUInt64 = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const lo32 = b.readUInt32LE(offset);
-        const hi32 = b.readUInt32LE(offset + 4);
-        return roundedInt64(hi32, lo32);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const split = divmodInt64(src);
-        b.writeUInt32LE(split.lo32, offset);
-        b.writeUInt32LE(split.hi32, offset + 4);
-        return 8;
-      }
-    };
-    var NearUInt64BE = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const hi32 = b.readUInt32BE(offset);
-        const lo32 = b.readUInt32BE(offset + 4);
-        return roundedInt64(hi32, lo32);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const split = divmodInt64(src);
-        b.writeUInt32BE(split.hi32, offset);
-        b.writeUInt32BE(split.lo32, offset + 4);
-        return 8;
-      }
-    };
-    var NearInt64 = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const lo32 = b.readUInt32LE(offset);
-        const hi32 = b.readInt32LE(offset + 4);
-        return roundedInt64(hi32, lo32);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const split = divmodInt64(src);
-        b.writeUInt32LE(split.lo32, offset);
-        b.writeInt32LE(split.hi32, offset + 4);
-        return 8;
-      }
-    };
-    var NearInt64BE = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const hi32 = b.readInt32BE(offset);
-        const lo32 = b.readUInt32BE(offset + 4);
-        return roundedInt64(hi32, lo32);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const split = divmodInt64(src);
-        b.writeInt32BE(split.hi32, offset);
-        b.writeUInt32BE(split.lo32, offset + 4);
-        return 8;
-      }
-    };
-    var Float = class extends Layout {
-      constructor(property) {
-        super(4, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readFloatLE(offset);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeFloatLE(src, offset);
-        return 4;
-      }
-    };
-    var FloatBE = class extends Layout {
-      constructor(property) {
-        super(4, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readFloatBE(offset);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeFloatBE(src, offset);
-        return 4;
-      }
-    };
-    var Double = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readDoubleLE(offset);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeDoubleLE(src, offset);
-        return 8;
-      }
-    };
-    var DoubleBE = class extends Layout {
-      constructor(property) {
-        super(8, property);
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.readDoubleBE(offset);
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        b.writeDoubleBE(src, offset);
-        return 8;
-      }
-    };
-    var Sequence = class extends Layout {
-      constructor(elementLayout, count, property) {
-        if (!(elementLayout instanceof Layout)) {
-          throw new TypeError("elementLayout must be a Layout");
-        }
-        if (!(count instanceof ExternalLayout && count.isCount() || Number.isInteger(count) && 0 <= count)) {
-          throw new TypeError("count must be non-negative integer or an unsigned integer ExternalLayout");
-        }
-        let span = -1;
-        if (!(count instanceof ExternalLayout) && 0 < elementLayout.span) {
-          span = count * elementLayout.span;
-        }
-        super(span, property);
-        this.elementLayout = elementLayout;
-        this.count = count;
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (0 <= this.span) {
-          return this.span;
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let span = 0;
-        let count = this.count;
-        if (count instanceof ExternalLayout) {
-          count = count.decode(b, offset);
-        }
-        if (0 < this.elementLayout.span) {
-          span = count * this.elementLayout.span;
-        } else {
-          let idx = 0;
-          while (idx < count) {
-            span += this.elementLayout.getSpan(b, offset + span);
-            ++idx;
-          }
-        }
-        return span;
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const rv = [];
-        let i = 0;
-        let count = this.count;
-        if (count instanceof ExternalLayout) {
-          count = count.decode(b, offset);
-        }
-        while (i < count) {
-          rv.push(this.elementLayout.decode(b, offset));
-          offset += this.elementLayout.getSpan(b, offset);
-          i += 1;
-        }
-        return rv;
-      }
-      /** Implement {@link Layout#encode|encode} for {@link Sequence}.
-       *
-       * **NOTE** If `src` is shorter than {@link Sequence#count|count} then
-       * the unused space in the buffer is left unchanged.  If `src` is
-       * longer than {@link Sequence#count|count} the unneeded elements are
-       * ignored.
-       *
-       * **NOTE** If {@link Layout#count|count} is an instance of {@link
-       * ExternalLayout} then the length of `src` will be encoded as the
-       * count after `src` is encoded. */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const elo = this.elementLayout;
-        const span = src.reduce((span2, v) => {
-          return span2 + elo.encode(v, b, offset + span2);
-        }, 0);
-        if (this.count instanceof ExternalLayout) {
-          this.count.encode(src.length, b, offset);
-        }
-        return span;
-      }
-    };
-    var Structure = class extends Layout {
-      constructor(fields, property, decodePrefixes) {
-        if (!(Array.isArray(fields) && fields.reduce((acc, v) => acc && v instanceof Layout, true))) {
-          throw new TypeError("fields must be array of Layout instances");
-        }
-        if ("boolean" === typeof property && void 0 === decodePrefixes) {
-          decodePrefixes = property;
-          property = void 0;
-        }
-        for (const fd of fields) {
-          if (0 > fd.span && void 0 === fd.property) {
-            throw new Error("fields cannot contain unnamed variable-length layout");
-          }
-        }
-        let span = -1;
-        try {
-          span = fields.reduce((span2, fd) => span2 + fd.getSpan(), 0);
-        } catch (e) {
-        }
-        super(span, property);
-        this.fields = fields;
-        this.decodePrefixes = !!decodePrefixes;
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (0 <= this.span) {
-          return this.span;
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let span = 0;
-        try {
-          span = this.fields.reduce((span2, fd) => {
-            const fsp = fd.getSpan(b, offset);
-            offset += fsp;
-            return span2 + fsp;
-          }, 0);
-        } catch (e) {
-          throw new RangeError("indeterminate span");
-        }
-        return span;
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const dest = this.makeDestinationObject();
-        for (const fd of this.fields) {
-          if (void 0 !== fd.property) {
-            dest[fd.property] = fd.decode(b, offset);
-          }
-          offset += fd.getSpan(b, offset);
-          if (this.decodePrefixes && b.length === offset) {
-            break;
-          }
-        }
-        return dest;
-      }
-      /** Implement {@link Layout#encode|encode} for {@link Structure}.
-       *
-       * If `src` is missing a property for a member with a defined {@link
-       * Layout#property|property} the corresponding region of the buffer is
-       * left unmodified. */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const firstOffset = offset;
-        let lastOffset = 0;
-        let lastWrote = 0;
-        for (const fd of this.fields) {
-          let span = fd.span;
-          lastWrote = 0 < span ? span : 0;
-          if (void 0 !== fd.property) {
-            const fv = src[fd.property];
-            if (void 0 !== fv) {
-              lastWrote = fd.encode(fv, b, offset);
-              if (0 > span) {
-                span = fd.getSpan(b, offset);
-              }
-            }
-          }
-          lastOffset = offset;
-          offset += span;
-        }
-        return lastOffset + lastWrote - firstOffset;
-      }
-      /** @override */
-      fromArray(values) {
-        const dest = this.makeDestinationObject();
-        for (const fd of this.fields) {
-          if (void 0 !== fd.property && 0 < values.length) {
-            dest[fd.property] = values.shift();
-          }
-        }
-        return dest;
-      }
-      /**
-       * Get access to the layout of a given property.
-       *
-       * @param {String} property - the structure member of interest.
-       *
-       * @return {Layout} - the layout associated with `property`, or
-       * undefined if there is no such property.
-       */
-      layoutFor(property) {
-        if ("string" !== typeof property) {
-          throw new TypeError("property must be string");
-        }
-        for (const fd of this.fields) {
-          if (fd.property === property) {
-            return fd;
-          }
-        }
-      }
-      /**
-       * Get the offset of a structure member.
-       *
-       * @param {String} property - the structure member of interest.
-       *
-       * @return {Number} - the offset in bytes to the start of `property`
-       * within the structure, or undefined if `property` is not a field
-       * within the structure.  If the property is a member but follows a
-       * variable-length structure member a negative number will be
-       * returned.
-       */
-      offsetOf(property) {
-        if ("string" !== typeof property) {
-          throw new TypeError("property must be string");
-        }
-        let offset = 0;
-        for (const fd of this.fields) {
-          if (fd.property === property) {
-            return offset;
-          }
-          if (0 > fd.span) {
-            offset = -1;
-          } else if (0 <= offset) {
-            offset += fd.span;
-          }
-        }
-      }
-    };
-    var UnionDiscriminator = class {
-      constructor(property) {
-        this.property = property;
-      }
-      /** Analog to {@link Layout#decode|Layout decode} for union discriminators.
-       *
-       * The implementation of this method need not reference the buffer if
-       * variant information is available through other means. */
-      decode() {
-        throw new Error("UnionDiscriminator is abstract");
-      }
-      /** Analog to {@link Layout#decode|Layout encode} for union discriminators.
-       *
-       * The implementation of this method need not store the value if
-       * variant information is maintained through other means. */
-      encode() {
-        throw new Error("UnionDiscriminator is abstract");
-      }
-    };
-    var UnionLayoutDiscriminator = class extends UnionDiscriminator {
-      constructor(layout, property) {
-        if (!(layout instanceof ExternalLayout && layout.isCount())) {
-          throw new TypeError("layout must be an unsigned integer ExternalLayout");
-        }
-        super(property || layout.property || "variant");
-        this.layout = layout;
-      }
-      /** Delegate decoding to {@link UnionLayoutDiscriminator#layout|layout}. */
-      decode(b, offset) {
-        return this.layout.decode(b, offset);
-      }
-      /** Delegate encoding to {@link UnionLayoutDiscriminator#layout|layout}. */
-      encode(src, b, offset) {
-        return this.layout.encode(src, b, offset);
-      }
-    };
-    var Union = class extends Layout {
-      constructor(discr, defaultLayout, property) {
-        const upv = discr instanceof UInt || discr instanceof UIntBE;
-        if (upv) {
-          discr = new UnionLayoutDiscriminator(new OffsetLayout(discr));
-        } else if (discr instanceof ExternalLayout && discr.isCount()) {
-          discr = new UnionLayoutDiscriminator(discr);
-        } else if (!(discr instanceof UnionDiscriminator)) {
-          throw new TypeError("discr must be a UnionDiscriminator or an unsigned integer layout");
-        }
-        if (void 0 === defaultLayout) {
-          defaultLayout = null;
-        }
-        if (!(null === defaultLayout || defaultLayout instanceof Layout)) {
-          throw new TypeError("defaultLayout must be null or a Layout");
-        }
-        if (null !== defaultLayout) {
-          if (0 > defaultLayout.span) {
-            throw new Error("defaultLayout must have constant span");
-          }
-          if (void 0 === defaultLayout.property) {
-            defaultLayout = defaultLayout.replicate("content");
-          }
-        }
-        let span = -1;
-        if (defaultLayout) {
-          span = defaultLayout.span;
-          if (0 <= span && upv) {
-            span += discr.layout.span;
-          }
-        }
-        super(span, property);
-        this.discriminator = discr;
-        this.usesPrefixDiscriminator = upv;
-        this.defaultLayout = defaultLayout;
-        this.registry = {};
-        let boundGetSourceVariant = this.defaultGetSourceVariant.bind(this);
-        this.getSourceVariant = function(src) {
-          return boundGetSourceVariant(src);
-        };
-        this.configGetSourceVariant = function(gsv) {
-          boundGetSourceVariant = gsv.bind(this);
-        };
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (0 <= this.span) {
-          return this.span;
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const vlo = this.getVariant(b, offset);
-        if (!vlo) {
-          throw new Error("unable to determine span for unrecognized variant");
-        }
-        return vlo.getSpan(b, offset);
-      }
-      /**
-       * Method to infer a registered Union variant compatible with `src`.
-       *
-       * The first satisified rule in the following sequence defines the
-       * return value:
-       * * If `src` has properties matching the Union discriminator and
-       *   the default layout, `undefined` is returned regardless of the
-       *   value of the discriminator property (this ensures the default
-       *   layout will be used);
-       * * If `src` has a property matching the Union discriminator, the
-       *   value of the discriminator identifies a registered variant, and
-       *   either (a) the variant has no layout, or (b) `src` has the
-       *   variant's property, then the variant is returned (because the
-       *   source satisfies the constraints of the variant it identifies);
-       * * If `src` does not have a property matching the Union
-       *   discriminator, but does have a property matching a registered
-       *   variant, then the variant is returned (because the source
-       *   matches a variant without an explicit conflict);
-       * * An error is thrown (because we either can't identify a variant,
-       *   or we were explicitly told the variant but can't satisfy it).
-       *
-       * @param {Object} src - an object presumed to be compatible with
-       * the content of the Union.
-       *
-       * @return {(undefined|VariantLayout)} - as described above.
-       *
-       * @throws {Error} - if `src` cannot be associated with a default or
-       * registered variant.
-       */
-      defaultGetSourceVariant(src) {
-        if (src.hasOwnProperty(this.discriminator.property)) {
-          if (this.defaultLayout && src.hasOwnProperty(this.defaultLayout.property)) {
-            return void 0;
-          }
-          const vlo = this.registry[src[this.discriminator.property]];
-          if (vlo && (!vlo.layout || src.hasOwnProperty(vlo.property))) {
-            return vlo;
-          }
-        } else {
-          for (const tag in this.registry) {
-            const vlo = this.registry[tag];
-            if (src.hasOwnProperty(vlo.property)) {
-              return vlo;
-            }
-          }
-        }
-        throw new Error("unable to infer src variant");
-      }
-      /** Implement {@link Layout#decode|decode} for {@link Union}.
-       *
-       * If the variant is {@link Union#addVariant|registered} the return
-       * value is an instance of that variant, with no explicit
-       * discriminator.  Otherwise the {@link Union#defaultLayout|default
-       * layout} is used to decode the content. */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let dest;
-        const dlo = this.discriminator;
-        const discr = dlo.decode(b, offset);
-        let clo = this.registry[discr];
-        if (void 0 === clo) {
-          let contentOffset = 0;
-          clo = this.defaultLayout;
-          if (this.usesPrefixDiscriminator) {
-            contentOffset = dlo.layout.span;
-          }
-          dest = this.makeDestinationObject();
-          dest[dlo.property] = discr;
-          dest[clo.property] = this.defaultLayout.decode(b, offset + contentOffset);
-        } else {
-          dest = clo.decode(b, offset);
-        }
-        return dest;
-      }
-      /** Implement {@link Layout#encode|encode} for {@link Union}.
-       *
-       * This API assumes the `src` object is consistent with the union's
-       * {@link Union#defaultLayout|default layout}.  To encode variants
-       * use the appropriate variant-specific {@link VariantLayout#encode}
-       * method. */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const vlo = this.getSourceVariant(src);
-        if (void 0 === vlo) {
-          const dlo = this.discriminator;
-          const clo = this.defaultLayout;
-          let contentOffset = 0;
-          if (this.usesPrefixDiscriminator) {
-            contentOffset = dlo.layout.span;
-          }
-          dlo.encode(src[dlo.property], b, offset);
-          return contentOffset + clo.encode(
-            src[clo.property],
-            b,
-            offset + contentOffset
-          );
-        }
-        return vlo.encode(src, b, offset);
-      }
-      /** Register a new variant structure within a union.  The newly
-       * created variant is returned.
-       *
-       * @param {Number} variant - initializer for {@link
-       * VariantLayout#variant|variant}.
-       *
-       * @param {Layout} layout - initializer for {@link
-       * VariantLayout#layout|layout}.
-       *
-       * @param {String} property - initializer for {@link
-       * Layout#property|property}.
-       *
-       * @return {VariantLayout} */
-      addVariant(variant, layout, property) {
-        const rv = new VariantLayout(this, variant, layout, property);
-        this.registry[variant] = rv;
-        return rv;
-      }
-      /**
-       * Get the layout associated with a registered variant.
-       *
-       * If `vb` does not produce a registered variant the function returns
-       * `undefined`.
-       *
-       * @param {(Number|Buffer)} vb - either the variant number, or a
-       * buffer from which the discriminator is to be read.
-       *
-       * @param {Number} offset - offset into `vb` for the start of the
-       * union.  Used only when `vb` is an instance of {Buffer}.
-       *
-       * @return {({VariantLayout}|undefined)}
-       */
-      getVariant(vb, offset) {
-        let variant = vb;
-        if (Buffer.isBuffer(vb)) {
-          if (void 0 === offset) {
-            offset = 0;
-          }
-          variant = this.discriminator.decode(vb, offset);
-        }
-        return this.registry[variant];
-      }
-    };
-    var VariantLayout = class extends Layout {
-      constructor(union, variant, layout, property) {
-        if (!(union instanceof Union)) {
-          throw new TypeError("union must be a Union");
-        }
-        if (!Number.isInteger(variant) || 0 > variant) {
-          throw new TypeError("variant must be a (non-negative) integer");
-        }
-        if ("string" === typeof layout && void 0 === property) {
-          property = layout;
-          layout = null;
-        }
-        if (layout) {
-          if (!(layout instanceof Layout)) {
-            throw new TypeError("layout must be a Layout");
-          }
-          if (null !== union.defaultLayout && 0 <= layout.span && layout.span > union.defaultLayout.span) {
-            throw new Error("variant span exceeds span of containing union");
-          }
-          if ("string" !== typeof property) {
-            throw new TypeError("variant must have a String property");
-          }
-        }
-        let span = union.span;
-        if (0 > union.span) {
-          span = layout ? layout.span : 0;
-          if (0 <= span && union.usesPrefixDiscriminator) {
-            span += union.discriminator.layout.span;
-          }
-        }
-        super(span, property);
-        this.union = union;
-        this.variant = variant;
-        this.layout = layout || null;
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (0 <= this.span) {
-          return this.span;
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-          contentOffset = this.union.discriminator.layout.span;
-        }
-        return contentOffset + this.layout.getSpan(b, offset + contentOffset);
-      }
-      /** @override */
-      decode(b, offset) {
-        const dest = this.makeDestinationObject();
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        if (this !== this.union.getVariant(b, offset)) {
-          throw new Error("variant mismatch");
-        }
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-          contentOffset = this.union.discriminator.layout.span;
-        }
-        if (this.layout) {
-          dest[this.property] = this.layout.decode(b, offset + contentOffset);
-        } else if (this.property) {
-          dest[this.property] = true;
-        } else if (this.union.usesPrefixDiscriminator) {
-          dest[this.union.discriminator.property] = this.variant;
-        }
-        return dest;
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let contentOffset = 0;
-        if (this.union.usesPrefixDiscriminator) {
-          contentOffset = this.union.discriminator.layout.span;
-        }
-        if (this.layout && !src.hasOwnProperty(this.property)) {
-          throw new TypeError("variant lacks property " + this.property);
-        }
-        this.union.discriminator.encode(this.variant, b, offset);
-        let span = contentOffset;
-        if (this.layout) {
-          this.layout.encode(src[this.property], b, offset + contentOffset);
-          span += this.layout.getSpan(b, offset + contentOffset);
-          if (0 <= this.union.span && span > this.union.span) {
-            throw new Error("encoded variant overruns containing union");
-          }
-        }
-        return span;
-      }
-      /** Delegate {@link Layout#fromArray|fromArray} to {@link
-       * VariantLayout#layout|layout}. */
-      fromArray(values) {
-        if (this.layout) {
-          return this.layout.fromArray(values);
-        }
-      }
-    };
-    function fixBitwiseResult(v) {
-      if (0 > v) {
-        v += 4294967296;
-      }
-      return v;
-    }
-    var BitStructure = class extends Layout {
-      constructor(word, msb, property) {
-        if (!(word instanceof UInt || word instanceof UIntBE)) {
-          throw new TypeError("word must be a UInt or UIntBE layout");
-        }
-        if ("string" === typeof msb && void 0 === property) {
-          property = msb;
-          msb = void 0;
-        }
-        if (4 < word.span) {
-          throw new RangeError("word cannot exceed 32 bits");
-        }
-        super(word.span, property);
-        this.word = word;
-        this.msb = !!msb;
-        this.fields = [];
-        let value = 0;
-        this._packedSetValue = function(v) {
-          value = fixBitwiseResult(v);
-          return this;
-        };
-        this._packedGetValue = function() {
-          return value;
-        };
-      }
-      /** @override */
-      decode(b, offset) {
-        const dest = this.makeDestinationObject();
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const value = this.word.decode(b, offset);
-        this._packedSetValue(value);
-        for (const fd of this.fields) {
-          if (void 0 !== fd.property) {
-            dest[fd.property] = fd.decode(value);
-          }
-        }
-        return dest;
-      }
-      /** Implement {@link Layout#encode|encode} for {@link BitStructure}.
-       *
-       * If `src` is missing a property for a member with a defined {@link
-       * Layout#property|property} the corresponding region of the packed
-       * value is left unmodified.  Unused bits are also left unmodified. */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        const value = this.word.decode(b, offset);
-        this._packedSetValue(value);
-        for (const fd of this.fields) {
-          if (void 0 !== fd.property) {
-            const fv = src[fd.property];
-            if (void 0 !== fv) {
-              fd.encode(fv);
-            }
-          }
-        }
-        return this.word.encode(this._packedGetValue(), b, offset);
-      }
-      /** Register a new bitfield with a containing bit structure.  The
-       * resulting bitfield is returned.
-       *
-       * @param {Number} bits - initializer for {@link BitField#bits|bits}.
-       *
-       * @param {string} property - initializer for {@link
-       * Layout#property|property}.
-       *
-       * @return {BitField} */
-      addField(bits, property) {
-        const bf = new BitField(this, bits, property);
-        this.fields.push(bf);
-        return bf;
-      }
-      /** As with {@link BitStructure#addField|addField} for single-bit
-       * fields with `boolean` value representation.
-       *
-       * @param {string} property - initializer for {@link
-       * Layout#property|property}.
-       *
-       * @return {Boolean} */
-      addBoolean(property) {
-        const bf = new Boolean(this, property);
-        this.fields.push(bf);
-        return bf;
-      }
-      /**
-       * Get access to the bit field for a given property.
-       *
-       * @param {String} property - the bit field of interest.
-       *
-       * @return {BitField} - the field associated with `property`, or
-       * undefined if there is no such property.
-       */
-      fieldFor(property) {
-        if ("string" !== typeof property) {
-          throw new TypeError("property must be string");
-        }
-        for (const fd of this.fields) {
-          if (fd.property === property) {
-            return fd;
-          }
-        }
-      }
-    };
-    var BitField = class {
-      constructor(container, bits, property) {
-        if (!(container instanceof BitStructure)) {
-          throw new TypeError("container must be a BitStructure");
-        }
-        if (!Number.isInteger(bits) || 0 >= bits) {
-          throw new TypeError("bits must be positive integer");
-        }
-        const totalBits = 8 * container.span;
-        const usedBits = container.fields.reduce((sum, fd) => sum + fd.bits, 0);
-        if (bits + usedBits > totalBits) {
-          throw new Error("bits too long for span remainder (" + (totalBits - usedBits) + " of " + totalBits + " remain)");
-        }
-        this.container = container;
-        this.bits = bits;
-        this.valueMask = (1 << bits) - 1;
-        if (32 === bits) {
-          this.valueMask = 4294967295;
-        }
-        this.start = usedBits;
-        if (this.container.msb) {
-          this.start = totalBits - usedBits - bits;
-        }
-        this.wordMask = fixBitwiseResult(this.valueMask << this.start);
-        this.property = property;
-      }
-      /** Store a value into the corresponding subsequence of the containing
-       * bit field. */
-      decode() {
-        const word = this.container._packedGetValue();
-        const wordValue = fixBitwiseResult(word & this.wordMask);
-        const value = wordValue >>> this.start;
-        return value;
-      }
-      /** Store a value into the corresponding subsequence of the containing
-       * bit field.
-       *
-       * **NOTE** This is not a specialization of {@link
-       * Layout#encode|Layout.encode} and there is no return value. */
-      encode(value) {
-        if (!Number.isInteger(value) || value !== fixBitwiseResult(value & this.valueMask)) {
-          throw new TypeError(nameWithProperty("BitField.encode", this) + " value must be integer not exceeding " + this.valueMask);
-        }
-        const word = this.container._packedGetValue();
-        const wordValue = fixBitwiseResult(value << this.start);
-        this.container._packedSetValue(fixBitwiseResult(word & ~this.wordMask) | wordValue);
-      }
-    };
-    var Boolean = class extends BitField {
-      constructor(container, property) {
-        super(container, 1, property);
-      }
-      /** Override {@link BitField#decode|decode} for {@link Boolean|Boolean}.
-       *
-       * @returns {boolean} */
-      decode(b, offset) {
-        return !!BitField.prototype.decode.call(this, b, offset);
-      }
-      /** @override */
-      encode(value) {
-        if ("boolean" === typeof value) {
-          value = +value;
-        }
-        return BitField.prototype.encode.call(this, value);
-      }
-    };
-    var Blob = class extends Layout {
-      constructor(length, property) {
-        if (!(length instanceof ExternalLayout && length.isCount() || Number.isInteger(length) && 0 <= length)) {
-          throw new TypeError("length must be positive integer or an unsigned integer ExternalLayout");
-        }
-        let span = -1;
-        if (!(length instanceof ExternalLayout)) {
-          span = length;
-        }
-        super(span, property);
-        this.length = length;
-      }
-      /** @override */
-      getSpan(b, offset) {
-        let span = this.span;
-        if (0 > span) {
-          span = this.length.decode(b, offset);
-        }
-        return span;
-      }
-      /** @override */
-      decode(b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let span = this.span;
-        if (0 > span) {
-          span = this.length.decode(b, offset);
-        }
-        return b.slice(offset, offset + span);
-      }
-      /** Implement {@link Layout#encode|encode} for {@link Blob}.
-       *
-       * **NOTE** If {@link Layout#count|count} is an instance of {@link
-       * ExternalLayout} then the length of `src` will be encoded as the
-       * count after `src` is encoded. */
-      encode(src, b, offset) {
-        let span = this.length;
-        if (this.length instanceof ExternalLayout) {
-          span = src.length;
-        }
-        if (!(Buffer.isBuffer(src) && span === src.length)) {
-          throw new TypeError(nameWithProperty("Blob.encode", this) + " requires (length " + span + ") Buffer as src");
-        }
-        if (offset + span > b.length) {
-          throw new RangeError("encoding overruns Buffer");
-        }
-        b.write(src.toString("hex"), offset, span, "hex");
-        if (this.length instanceof ExternalLayout) {
-          this.length.encode(span, b, offset);
-        }
-        return span;
-      }
-    };
-    var CString = class extends Layout {
-      constructor(property) {
-        super(-1, property);
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (!Buffer.isBuffer(b)) {
-          throw new TypeError("b must be a Buffer");
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let idx = offset;
-        while (idx < b.length && 0 !== b[idx]) {
-          idx += 1;
-        }
-        return 1 + idx - offset;
-      }
-      /** @override */
-      decode(b, offset, dest) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let span = this.getSpan(b, offset);
-        return b.slice(offset, offset + span - 1).toString("utf-8");
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        if ("string" !== typeof src) {
-          src = src.toString();
-        }
-        const srcb = new Buffer(src, "utf8");
-        const span = srcb.length;
-        if (offset + span > b.length) {
-          throw new RangeError("encoding overruns Buffer");
-        }
-        srcb.copy(b, offset);
-        b[offset + span] = 0;
-        return span + 1;
-      }
-    };
-    var UTF8 = class extends Layout {
-      constructor(maxSpan, property) {
-        if ("string" === typeof maxSpan && void 0 === property) {
-          property = maxSpan;
-          maxSpan = void 0;
-        }
-        if (void 0 === maxSpan) {
-          maxSpan = -1;
-        } else if (!Number.isInteger(maxSpan)) {
-          throw new TypeError("maxSpan must be an integer");
-        }
-        super(-1, property);
-        this.maxSpan = maxSpan;
-      }
-      /** @override */
-      getSpan(b, offset) {
-        if (!Buffer.isBuffer(b)) {
-          throw new TypeError("b must be a Buffer");
-        }
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        return b.length - offset;
-      }
-      /** @override */
-      decode(b, offset, dest) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        let span = this.getSpan(b, offset);
-        if (0 <= this.maxSpan && this.maxSpan < span) {
-          throw new RangeError("text length exceeds maxSpan");
-        }
-        return b.slice(offset, offset + span).toString("utf-8");
-      }
-      /** @override */
-      encode(src, b, offset) {
-        if (void 0 === offset) {
-          offset = 0;
-        }
-        if ("string" !== typeof src) {
-          src = src.toString();
-        }
-        const srcb = new Buffer(src, "utf8");
-        const span = srcb.length;
-        if (0 <= this.maxSpan && this.maxSpan < span) {
-          throw new RangeError("text length exceeds maxSpan");
-        }
-        if (offset + span > b.length) {
-          throw new RangeError("encoding overruns Buffer");
-        }
-        srcb.copy(b, offset);
-        return span;
-      }
-    };
-    var Constant = class extends Layout {
-      constructor(value, property) {
-        super(0, property);
-        this.value = value;
-      }
-      /** @override */
-      decode(b, offset, dest) {
-        return this.value;
-      }
-      /** @override */
-      encode(src, b, offset) {
-        return 0;
-      }
-    };
-    exports$1.ExternalLayout = ExternalLayout;
-    exports$1.GreedyCount = GreedyCount;
-    exports$1.OffsetLayout = OffsetLayout;
-    exports$1.UInt = UInt;
-    exports$1.UIntBE = UIntBE;
-    exports$1.Int = Int;
-    exports$1.IntBE = IntBE;
-    exports$1.Float = Float;
-    exports$1.FloatBE = FloatBE;
-    exports$1.Double = Double;
-    exports$1.DoubleBE = DoubleBE;
-    exports$1.Sequence = Sequence;
-    exports$1.Structure = Structure;
-    exports$1.UnionDiscriminator = UnionDiscriminator;
-    exports$1.UnionLayoutDiscriminator = UnionLayoutDiscriminator;
-    exports$1.Union = Union;
-    exports$1.VariantLayout = VariantLayout;
-    exports$1.BitStructure = BitStructure;
-    exports$1.BitField = BitField;
-    exports$1.Boolean = Boolean;
-    exports$1.Blob = Blob;
-    exports$1.CString = CString;
-    exports$1.UTF8 = UTF8;
-    exports$1.Constant = Constant;
-    exports$1.greedy = ((elementSpan, property) => new GreedyCount(elementSpan, property));
-    exports$1.offset = ((layout, offset, property) => new OffsetLayout(layout, offset, property));
-    exports$1.u8 = ((property) => new UInt(1, property));
-    exports$1.u16 = ((property) => new UInt(2, property));
-    exports$1.u24 = ((property) => new UInt(3, property));
-    exports$1.u32 = ((property) => new UInt(4, property));
-    exports$1.u40 = ((property) => new UInt(5, property));
-    exports$1.u48 = ((property) => new UInt(6, property));
-    exports$1.nu64 = ((property) => new NearUInt64(property));
-    exports$1.u16be = ((property) => new UIntBE(2, property));
-    exports$1.u24be = ((property) => new UIntBE(3, property));
-    exports$1.u32be = ((property) => new UIntBE(4, property));
-    exports$1.u40be = ((property) => new UIntBE(5, property));
-    exports$1.u48be = ((property) => new UIntBE(6, property));
-    exports$1.nu64be = ((property) => new NearUInt64BE(property));
-    exports$1.s8 = ((property) => new Int(1, property));
-    exports$1.s16 = ((property) => new Int(2, property));
-    exports$1.s24 = ((property) => new Int(3, property));
-    exports$1.s32 = ((property) => new Int(4, property));
-    exports$1.s40 = ((property) => new Int(5, property));
-    exports$1.s48 = ((property) => new Int(6, property));
-    exports$1.ns64 = ((property) => new NearInt64(property));
-    exports$1.s16be = ((property) => new IntBE(2, property));
-    exports$1.s24be = ((property) => new IntBE(3, property));
-    exports$1.s32be = ((property) => new IntBE(4, property));
-    exports$1.s40be = ((property) => new IntBE(5, property));
-    exports$1.s48be = ((property) => new IntBE(6, property));
-    exports$1.ns64be = ((property) => new NearInt64BE(property));
-    exports$1.f32 = ((property) => new Float(property));
-    exports$1.f32be = ((property) => new FloatBE(property));
-    exports$1.f64 = ((property) => new Double(property));
-    exports$1.f64be = ((property) => new DoubleBE(property));
-    exports$1.struct = ((fields, property, decodePrefixes) => new Structure(fields, property, decodePrefixes));
-    exports$1.bits = ((word, msb, property) => new BitStructure(word, msb, property));
-    exports$1.seq = ((elementLayout, count, property) => new Sequence(elementLayout, count, property));
-    exports$1.union = ((discr, defaultLayout, property) => new Union(discr, defaultLayout, property));
-    exports$1.unionLayoutDiscriminator = ((layout, property) => new UnionLayoutDiscriminator(layout, property));
-    exports$1.blob = ((length, property) => new Blob(length, property));
-    exports$1.cstr = ((property) => new CString(property));
-    exports$1.utf8 = ((maxSpan, property) => new UTF8(maxSpan, property));
-    exports$1.const = ((value, property) => new Constant(value, property));
-  }
-});
-/*! Bundled license information:
-
-buffer-layout/lib/Layout.js:
-  (**
-   * Support for translating between Buffer instances and JavaScript
-   * native types.
-   *
-   * {@link module:Layout~Layout|Layout} is the basis of a class
-   * hierarchy that associates property names with sequences of encoded
-   * bytes.
-   *
-   * Layouts are supported for these scalar (numeric) types:
-   * * {@link module:Layout~UInt|Unsigned integers in little-endian
-   *   format} with {@link module:Layout.u8|8-bit}, {@link
-   *   module:Layout.u16|16-bit}, {@link module:Layout.u24|24-bit},
-   *   {@link module:Layout.u32|32-bit}, {@link
-   *   module:Layout.u40|40-bit}, and {@link module:Layout.u48|48-bit}
-   *   representation ranges;
-   * * {@link module:Layout~UIntBE|Unsigned integers in big-endian
-   *   format} with {@link module:Layout.u16be|16-bit}, {@link
-   *   module:Layout.u24be|24-bit}, {@link module:Layout.u32be|32-bit},
-   *   {@link module:Layout.u40be|40-bit}, and {@link
-   *   module:Layout.u48be|48-bit} representation ranges;
-   * * {@link module:Layout~Int|Signed integers in little-endian
-   *   format} with {@link module:Layout.s8|8-bit}, {@link
-   *   module:Layout.s16|16-bit}, {@link module:Layout.s24|24-bit},
-   *   {@link module:Layout.s32|32-bit}, {@link
-   *   module:Layout.s40|40-bit}, and {@link module:Layout.s48|48-bit}
-   *   representation ranges;
-   * * {@link module:Layout~IntBE|Signed integers in big-endian format}
-   *   with {@link module:Layout.s16be|16-bit}, {@link
-   *   module:Layout.s24be|24-bit}, {@link module:Layout.s32be|32-bit},
-   *   {@link module:Layout.s40be|40-bit}, and {@link
-   *   module:Layout.s48be|48-bit} representation ranges;
-   * * 64-bit integral values that decode to an exact (if magnitude is
-   *   less than 2^53) or nearby integral Number in {@link
-   *   module:Layout.nu64|unsigned little-endian}, {@link
-   *   module:Layout.nu64be|unsigned big-endian}, {@link
-   *   module:Layout.ns64|signed little-endian}, and {@link
-   *   module:Layout.ns64be|unsigned big-endian} encodings;
-   * * 32-bit floating point values with {@link
-   *   module:Layout.f32|little-endian} and {@link
-   *   module:Layout.f32be|big-endian} representations;
-   * * 64-bit floating point values with {@link
-   *   module:Layout.f64|little-endian} and {@link
-   *   module:Layout.f64be|big-endian} representations;
-   * * {@link module:Layout.const|Constants} that take no space in the
-   *   encoded expression.
-   *
-   * and for these aggregate types:
-   * * {@link module:Layout.seq|Sequence}s of instances of a {@link
-   *   module:Layout~Layout|Layout}, with JavaScript representation as
-   *   an Array and constant or data-dependent {@link
-   *   module:Layout~Sequence#count|length};
-   * * {@link module:Layout.struct|Structure}s that aggregate a
-   *   heterogeneous sequence of {@link module:Layout~Layout|Layout}
-   *   instances, with JavaScript representation as an Object;
-   * * {@link module:Layout.union|Union}s that support multiple {@link
-   *   module:Layout~VariantLayout|variant layouts} over a fixed
-   *   (padded) or variable (not padded) span of bytes, using an
-   *   unsigned integer at the start of the data or a separate {@link
-   *   module:Layout.unionLayoutDiscriminator|layout element} to
-   *   determine which layout to use when interpreting the buffer
-   *   contents;
-   * * {@link module:Layout.bits|BitStructure}s that contain a sequence
-   *   of individual {@link
-   *   module:Layout~BitStructure#addField|BitField}s packed into an 8,
-   *   16, 24, or 32-bit unsigned integer starting at the least- or
-   *   most-significant bit;
-   * * {@link module:Layout.cstr|C strings} of varying length;
-   * * {@link module:Layout.blob|Blobs} of fixed- or variable-{@link
-   *   module:Layout~Blob#length|length} raw data.
-   *
-   * All {@link module:Layout~Layout|Layout} instances are immutable
-   * after construction, to prevent internal state from becoming
-   * inconsistent.
-   *
-   * @local Layout
-   * @local ExternalLayout
-   * @local GreedyCount
-   * @local OffsetLayout
-   * @local UInt
-   * @local UIntBE
-   * @local Int
-   * @local IntBE
-   * @local NearUInt64
-   * @local NearUInt64BE
-   * @local NearInt64
-   * @local NearInt64BE
-   * @local Float
-   * @local FloatBE
-   * @local Double
-   * @local DoubleBE
-   * @local Sequence
-   * @local Structure
-   * @local UnionDiscriminator
-   * @local UnionLayoutDiscriminator
-   * @local Union
-   * @local VariantLayout
-   * @local BitStructure
-   * @local BitField
-   * @local Boolean
-   * @local Blob
-   * @local CString
-   * @local Constant
-   * @local bindConstructorLayout
-   * @module Layout
-   * @license MIT
-   * @author Peter A. Bigot
-   * @see {@link https://github.com/pabigot/buffer-layout|buffer-layout on GitHub}
-   *)
-*/
-
-export { require_Layout };
-//# sourceMappingURL=chunk-5RQOM3VO.js.map
-//# sourceMappingURL=chunk-5RQOM3VO.js.map