.deno/gen/https/deno.land/2d42e05955049935cf121ad3d14d949da14b4c2ec355b1ac41b8bd233b186fc6.js

import { assert } from "../_util/assert.ts";
// MIN_READ is the minimum ArrayBuffer size passed to a read call by
// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond
// what is required to hold the contents of r, readFrom() will not grow the
// underlying buffer.
const MIN_READ = 32 * 1024;
const MAX_SIZE = 2 ** 32 - 2;
// `off` is the offset into `dst` where it will at which to begin writing values
// from `src`.
// Returns the number of bytes copied.
function copyBytes(src, dst, off = 0) {
    const r = dst.byteLength - off;
    if (src.byteLength > r) {
        src = src.subarray(0, r);
    }
    dst.set(src, off);
    return src.byteLength;
}
/** A variable-sized buffer of bytes with `read()` and `write()` methods.
 *
 * Buffer is almost always used with some I/O like files and sockets. It allows
 * one to buffer up a download from a socket. Buffer grows and shrinks as
 * necessary.
 *
 * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in
 * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a
 * non-standard ArrayBuffer.
 *
 * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of
 * ArrayBuffer.
 *
 * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */ export class Buffer {
    #buf;
    #off = 0;
    constructor(ab){
        if (ab === undefined) {
            this.#buf = new Uint8Array(0);
            return;
        }
        this.#buf = new Uint8Array(ab);
    }
    /** Returns a slice holding the unread portion of the buffer.
   *
   * The slice is valid for use only until the next buffer modification (that
   * is, only until the next call to a method like `read()`, `write()`,
   * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at
   * least until the next buffer modification, so immediate changes to the
   * slice will affect the result of future reads.
   * @param options Defaults to `{ copy: true }`
   */ bytes(options = {
        copy: true
    }) {
        if (options.copy === false) return this.#buf.subarray(this.#off);
        return this.#buf.slice(this.#off);
    }
    /** Returns whether the unread portion of the buffer is empty. */ empty() {
        return this.#buf.byteLength <= this.#off;
    }
    /** A read only number of bytes of the unread portion of the buffer. */ get length() {
        return this.#buf.byteLength - this.#off;
    }
    /** The read only capacity of the buffer's underlying byte slice, that is,
   * the total space allocated for the buffer's data. */ get capacity() {
        return this.#buf.buffer.byteLength;
    }
    /** Discards all but the first `n` unread bytes from the buffer but
   * continues to use the same allocated storage. It throws if `n` is
   * negative or greater than the length of the buffer. */ truncate(n) {
        if (n === 0) {
            this.reset();
            return;
        }
        if (n < 0 || n > this.length) {
            throw Error("bytes.Buffer: truncation out of range");
        }
        this.#reslice(this.#off + n);
    }
    reset() {
        this.#reslice(0);
        this.#off = 0;
    }
    #tryGrowByReslice = (n)=>{
        const l = this.#buf.byteLength;
        if (n <= this.capacity - l) {
            this.#reslice(l + n);
            return l;
        }
        return -1;
    };
    #reslice = (len)=>{
        assert(len <= this.#buf.buffer.byteLength);
        this.#buf = new Uint8Array(this.#buf.buffer, 0, len);
    };
    /** Reads the next `p.length` bytes from the buffer or until the buffer is
   * drained. Returns the number of bytes read. If the buffer has no data to
   * return, the return is EOF (`null`). */ readSync(p) {
        if (this.empty()) {
            // Buffer is empty, reset to recover space.
            this.reset();
            if (p.byteLength === 0) {
                // this edge case is tested in 'bufferReadEmptyAtEOF' test
                return 0;
            }
            return null;
        }
        const nread = copyBytes(this.#buf.subarray(this.#off), p);
        this.#off += nread;
        return nread;
    }
    /** Reads the next `p.length` bytes from the buffer or until the buffer is
   * drained. Resolves to the number of bytes read. If the buffer has no
   * data to return, resolves to EOF (`null`).
   *
   * NOTE: This methods reads bytes synchronously; it's provided for
   * compatibility with `Reader` interfaces.
   */ read(p) {
        const rr = this.readSync(p);
        return Promise.resolve(rr);
    }
    writeSync(p) {
        const m = this.#grow(p.byteLength);
        return copyBytes(p, this.#buf, m);
    }
    /** NOTE: This methods writes bytes synchronously; it's provided for
   * compatibility with `Writer` interface. */ write(p) {
        const n = this.writeSync(p);
        return Promise.resolve(n);
    }
    #grow = (n)=>{
        const m = this.length;
        // If buffer is empty, reset to recover space.
        if (m === 0 && this.#off !== 0) {
            this.reset();
        }
        // Fast: Try to grow by means of a reslice.
        const i = this.#tryGrowByReslice(n);
        if (i >= 0) {
            return i;
        }
        const c = this.capacity;
        if (n <= Math.floor(c / 2) - m) {
            // We can slide things down instead of allocating a new
            // ArrayBuffer. We only need m+n <= c to slide, but
            // we instead let capacity get twice as large so we
            // don't spend all our time copying.
            copyBytes(this.#buf.subarray(this.#off), this.#buf);
        } else if (c + n > MAX_SIZE) {
            throw new Error("The buffer cannot be grown beyond the maximum size.");
        } else {
            // Not enough space anywhere, we need to allocate.
            const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));
            copyBytes(this.#buf.subarray(this.#off), buf);
            this.#buf = buf;
        }
        // Restore this.#off and len(this.#buf).
        this.#off = 0;
        this.#reslice(Math.min(m + n, MAX_SIZE));
        return m;
    };
    /** Grows the buffer's capacity, if necessary, to guarantee space for
   * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to
   * the buffer without another allocation. If `n` is negative, `.grow()` will
   * throw. If the buffer can't grow it will throw an error.
   *
   * Based on Go Lang's
   * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */ grow(n) {
        if (n < 0) {
            throw Error("Buffer.grow: negative count");
        }
        const m = this.#grow(n);
        this.#reslice(m);
    }
    /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
   * growing the buffer as needed. It resolves to the number of bytes read.
   * If the buffer becomes too large, `.readFrom()` will reject with an error.
   *
   * Based on Go Lang's
   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ async readFrom(r) {
        let n = 0;
        const tmp = new Uint8Array(MIN_READ);
        while(true){
            const shouldGrow = this.capacity - this.length < MIN_READ;
            // read into tmp buffer if there's not enough room
            // otherwise read directly into the internal buffer
            const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length);
            const nread = await r.read(buf);
            if (nread === null) {
                return n;
            }
            // write will grow if needed
            if (shouldGrow) this.writeSync(buf.subarray(0, nread));
            else this.#reslice(this.length + nread);
            n += nread;
        }
    }
    /** Reads data from `r` until EOF (`null`) and appends it to the buffer,
   * growing the buffer as needed. It returns the number of bytes read. If the
   * buffer becomes too large, `.readFromSync()` will throw an error.
   *
   * Based on Go Lang's
   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */ readFromSync(r) {
        let n = 0;
        const tmp = new Uint8Array(MIN_READ);
        while(true){
            const shouldGrow = this.capacity - this.length < MIN_READ;
            // read into tmp buffer if there's not enough room
            // otherwise read directly into the internal buffer
            const buf = shouldGrow ? tmp : new Uint8Array(this.#buf.buffer, this.length);
            const nread = r.readSync(buf);
            if (nread === null) {
                return n;
            }
            // write will grow if needed
            if (shouldGrow) this.writeSync(buf.subarray(0, nread));
            else this.#reslice(this.length + nread);
            n += nread;
        }
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["https://deno.land/std@0.92.0/io/buffer.ts"],"sourcesContent":["import { assert } from \"../_util/assert.ts\";\n\n// MIN_READ is the minimum ArrayBuffer size passed to a read call by\n// buffer.ReadFrom. As long as the Buffer has at least MIN_READ bytes beyond\n// what is required to hold the contents of r, readFrom() will not grow the\n// underlying buffer.\nconst MIN_READ = 32 * 1024;\nconst MAX_SIZE = 2 ** 32 - 2;\n\n// `off` is the offset into `dst` where it will at which to begin writing values\n// from `src`.\n// Returns the number of bytes copied.\nfunction copyBytes(src: Uint8Array, dst: Uint8Array, off = 0) {\n  const r = dst.byteLength - off;\n  if (src.byteLength > r) {\n    src = src.subarray(0, r);\n  }\n  dst.set(src, off);\n  return src.byteLength;\n}\n\n/** A variable-sized buffer of bytes with `read()` and `write()` methods.\n *\n * Buffer is almost always used with some I/O like files and sockets. It allows\n * one to buffer up a download from a socket. Buffer grows and shrinks as\n * necessary.\n *\n * Buffer is NOT the same thing as Node's Buffer. Node's Buffer was created in\n * 2009 before JavaScript had the concept of ArrayBuffers. It's simply a\n * non-standard ArrayBuffer.\n *\n * ArrayBuffer is a fixed memory allocation. Buffer is implemented on top of\n * ArrayBuffer.\n *\n * Based on [Go Buffer](https://golang.org/pkg/bytes/#Buffer). */\n\nexport class Buffer {\n  #buf: Uint8Array; // contents are the bytes buf[off : len(buf)]\n  #off = 0; // read at buf[off], write at buf[buf.byteLength]\n\n  constructor(ab?: ArrayBuffer) {\n    if (ab === undefined) {\n      this.#buf = new Uint8Array(0);\n      return;\n    }\n    this.#buf = new Uint8Array(ab);\n  }\n\n  /** Returns a slice holding the unread portion of the buffer.\n   *\n   * The slice is valid for use only until the next buffer modification (that\n   * is, only until the next call to a method like `read()`, `write()`,\n   * `reset()`, or `truncate()`). If `options.copy` is false the slice aliases the buffer content at\n   * least until the next buffer modification, so immediate changes to the\n   * slice will affect the result of future reads.\n   * @param options Defaults to `{ copy: true }`\n   */\n  bytes(options = { copy: true }): Uint8Array {\n    if (options.copy === false) return this.#buf.subarray(this.#off);\n    return this.#buf.slice(this.#off);\n  }\n\n  /** Returns whether the unread portion of the buffer is empty. */\n  empty(): boolean {\n    return this.#buf.byteLength <= this.#off;\n  }\n\n  /** A read only number of bytes of the unread portion of the buffer. */\n  get length(): number {\n    return this.#buf.byteLength - this.#off;\n  }\n\n  /** The read only capacity of the buffer's underlying byte slice, that is,\n   * the total space allocated for the buffer's data. */\n  get capacity(): number {\n    return this.#buf.buffer.byteLength;\n  }\n\n  /** Discards all but the first `n` unread bytes from the buffer but\n   * continues to use the same allocated storage. It throws if `n` is\n   * negative or greater than the length of the buffer. */\n  truncate(n: number): void {\n    if (n === 0) {\n      this.reset();\n      return;\n    }\n    if (n < 0 || n > this.length) {\n      throw Error(\"bytes.Buffer: truncation out of range\");\n    }\n    this.#reslice(this.#off + n);\n  }\n\n  reset(): void {\n    this.#reslice(0);\n    this.#off = 0;\n  }\n\n  #tryGrowByReslice = (n: number) => {\n    const l = this.#buf.byteLength;\n    if (n <= this.capacity - l) {\n      this.#reslice(l + n);\n      return l;\n    }\n    return -1;\n  };\n\n  #reslice = (len: number) => {\n    assert(len <= this.#buf.buffer.byteLength);\n    this.#buf = new Uint8Array(this.#buf.buffer, 0, len);\n  };\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Returns the number of bytes read. If the buffer has no data to\n   * return, the return is EOF (`null`). */\n  readSync(p: Uint8Array): number | null {\n    if (this.empty()) {\n      // Buffer is empty, reset to recover space.\n      this.reset();\n      if (p.byteLength === 0) {\n        // this edge case is tested in 'bufferReadEmptyAtEOF' test\n        return 0;\n      }\n      return null;\n    }\n    const nread = copyBytes(this.#buf.subarray(this.#off), p);\n    this.#off += nread;\n    return nread;\n  }\n\n  /** Reads the next `p.length` bytes from the buffer or until the buffer is\n   * drained. Resolves to the number of bytes read. If the buffer has no\n   * data to return, resolves to EOF (`null`).\n   *\n   * NOTE: This methods reads bytes synchronously; it's provided for\n   * compatibility with `Reader` interfaces.\n   */\n  read(p: Uint8Array): Promise<number | null> {\n    const rr = this.readSync(p);\n    return Promise.resolve(rr);\n  }\n\n  writeSync(p: Uint8Array): number {\n    const m = this.#grow(p.byteLength);\n    return copyBytes(p, this.#buf, m);\n  }\n\n  /** NOTE: This methods writes bytes synchronously; it's provided for\n   * compatibility with `Writer` interface. */\n  write(p: Uint8Array): Promise<number> {\n    const n = this.writeSync(p);\n    return Promise.resolve(n);\n  }\n\n  #grow = (n: number) => {\n    const m = this.length;\n    // If buffer is empty, reset to recover space.\n    if (m === 0 && this.#off !== 0) {\n      this.reset();\n    }\n    // Fast: Try to grow by means of a reslice.\n    const i = this.#tryGrowByReslice(n);\n    if (i >= 0) {\n      return i;\n    }\n    const c = this.capacity;\n    if (n <= Math.floor(c / 2) - m) {\n      // We can slide things down instead of allocating a new\n      // ArrayBuffer. We only need m+n <= c to slide, but\n      // we instead let capacity get twice as large so we\n      // don't spend all our time copying.\n      copyBytes(this.#buf.subarray(this.#off), this.#buf);\n    } else if (c + n > MAX_SIZE) {\n      throw new Error(\"The buffer cannot be grown beyond the maximum size.\");\n    } else {\n      // Not enough space anywhere, we need to allocate.\n      const buf = new Uint8Array(Math.min(2 * c + n, MAX_SIZE));\n      copyBytes(this.#buf.subarray(this.#off), buf);\n      this.#buf = buf;\n    }\n    // Restore this.#off and len(this.#buf).\n    this.#off = 0;\n    this.#reslice(Math.min(m + n, MAX_SIZE));\n    return m;\n  };\n\n  /** Grows the buffer's capacity, if necessary, to guarantee space for\n   * another `n` bytes. After `.grow(n)`, at least `n` bytes can be written to\n   * the buffer without another allocation. If `n` is negative, `.grow()` will\n   * throw. If the buffer can't grow it will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.Grow](https://golang.org/pkg/bytes/#Buffer.Grow). */\n  grow(n: number): void {\n    if (n < 0) {\n      throw Error(\"Buffer.grow: negative count\");\n    }\n    const m = this.#grow(n);\n    this.#reslice(m);\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It resolves to the number of bytes read.\n   * If the buffer becomes too large, `.readFrom()` will reject with an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  async readFrom(r: Deno.Reader): Promise<number> {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = await r.read(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n\n  /** Reads data from `r` until EOF (`null`) and appends it to the buffer,\n   * growing the buffer as needed. It returns the number of bytes read. If the\n   * buffer becomes too large, `.readFromSync()` will throw an error.\n   *\n   * Based on Go Lang's\n   * [Buffer.ReadFrom](https://golang.org/pkg/bytes/#Buffer.ReadFrom). */\n  readFromSync(r: Deno.ReaderSync): number {\n    let n = 0;\n    const tmp = new Uint8Array(MIN_READ);\n    while (true) {\n      const shouldGrow = this.capacity - this.length < MIN_READ;\n      // read into tmp buffer if there's not enough room\n      // otherwise read directly into the internal buffer\n      const buf = shouldGrow\n        ? tmp\n        : new Uint8Array(this.#buf.buffer, this.length);\n\n      const nread = r.readSync(buf);\n      if (nread === null) {\n        return n;\n      }\n\n      // write will grow if needed\n      if (shouldGrow) this.writeSync(buf.subarray(0, nread));\n      else this.#reslice(this.length + nread);\n\n      n += nread;\n    }\n  }\n}\n"],"names":[],"mappings":"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"}