123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
import {  TEXT_ENCODER_THRESHOLD,  utf8Count,  utf8EncodeJs,  utf8EncodeTE,} from "./utils/utf8.ts";import { ExtensionCodec, ExtensionCodecType } from "./ExtensionCodec.ts";import { setInt64, setUint64 } from "./utils/int.ts";import { ensureUint8Array } from "./utils/typedArrays.ts";import { ExtData } from "./ExtData.ts";
export const DEFAULT_MAX_DEPTH = 100;export const DEFAULT_INITIAL_BUFFER_SIZE = 2048;
export class Encoder<ContextType> {  private pos = 0;  private view;  private bytes;
  public constructor(    private readonly extensionCodec: ExtensionCodecType<ContextType> =      // deno-lint-ignore no-explicit-any      ExtensionCodec.defaultCodec as any,    // deno-lint-ignore no-explicit-any    private readonly context: ContextType = undefined as any,    private readonly maxDepth = DEFAULT_MAX_DEPTH,    private readonly initialBufferSize = DEFAULT_INITIAL_BUFFER_SIZE,    private readonly sortKeys = false,    private readonly forceFloat32 = false,    private readonly ignoreUndefined = false,  ) {    this.view = new DataView(new ArrayBuffer(this.initialBufferSize));    this.bytes = new Uint8Array(this.view.buffer);  }
  private getUint8Array(): Uint8Array {    return this.bytes.subarray(0, this.pos);  }
  private reinitializeState() {    this.pos = 0;  }
  public encode(object: unknown): Uint8Array {    this.reinitializeState();    this.doEncode(object, 1);    return this.getUint8Array();  }
  private doEncode(object: unknown, depth: number): void {    if (depth > this.maxDepth) {      throw new Error(`Too deep objects in depth ${depth}`);    }
    if (object == null) {      this.encodeNil();    } else if (typeof object === "boolean") {      this.encodeBoolean(object);    } else if (typeof object === "number") {      this.encodeNumber(object);    } else if (typeof object === "string") {      this.encodeString(object);    } else {      this.encodeObject(object, depth);    }  }
  private ensureBufferSizeToWrite(sizeToWrite: number) {    const requiredSize = this.pos + sizeToWrite;
    if (this.view.byteLength < requiredSize) {      this.resizeBuffer(requiredSize * 2);    }  }
  private resizeBuffer(newSize: number) {    const newBuffer = new ArrayBuffer(newSize);    const newBytes = new Uint8Array(newBuffer);    const newView = new DataView(newBuffer);
    newBytes.set(this.bytes);
    this.view = newView;    this.bytes = newBytes;  }
  private encodeNil() {    this.writeU8(0xc0);  }
  private encodeBoolean(object: boolean) {    if (object === false) {      this.writeU8(0xc2);    } else {      this.writeU8(0xc3);    }  }  private encodeNumber(object: number) {    if (Number.isSafeInteger(object)) {      if (object >= 0) {        if (object < 0x80) {          // positive fixint          this.writeU8(object);        } else if (object < 0x100) {          // uint 8          this.writeU8(0xcc);          this.writeU8(object);        } else if (object < 0x10000) {          // uint 16          this.writeU8(0xcd);          this.writeU16(object);        } else if (object < 0x100000000) {          // uint 32          this.writeU8(0xce);          this.writeU32(object);        } else {          // uint 64          this.writeU8(0xcf);          this.writeU64(object);        }      } else {        if (object >= -0x20) {          // nagative fixint          this.writeU8(0xe0 | (object + 0x20));        } else if (object >= -0x80) {          // int 8          this.writeU8(0xd0);          this.writeI8(object);        } else if (object >= -0x8000) {          // int 16          this.writeU8(0xd1);          this.writeI16(object);        } else if (object >= -0x80000000) {          // int 32          this.writeU8(0xd2);          this.writeI32(object);        } else {          // int 64          this.writeU8(0xd3);          this.writeI64(object);        }      }    } else {      // non-integer numbers      if (this.forceFloat32) {        // float 32        this.writeU8(0xca);        this.writeF32(object);      } else {        // float 64        this.writeU8(0xcb);        this.writeF64(object);      }    }  }
  private writeStringHeader(byteLength: number) {    if (byteLength < 32) {      // fixstr      this.writeU8(0xa0 + byteLength);    } else if (byteLength < 0x100) {      // str 8      this.writeU8(0xd9);      this.writeU8(byteLength);    } else if (byteLength < 0x10000) {      // str 16      this.writeU8(0xda);      this.writeU16(byteLength);    } else if (byteLength < 0x100000000) {      // str 32      this.writeU8(0xdb);      this.writeU32(byteLength);    } else {      throw new Error(`Too long string: ${byteLength} bytes in UTF-8`);    }  }
  private encodeString(object: string) {    const maxHeaderSize = 1 + 4;    const strLength = object.length;
    if (strLength > TEXT_ENCODER_THRESHOLD) {      const byteLength = utf8Count(object);      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);      this.writeStringHeader(byteLength);      utf8EncodeTE(object, this.bytes, this.pos);      this.pos += byteLength;    } else {      const byteLength = utf8Count(object);      this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);      this.writeStringHeader(byteLength);      utf8EncodeJs(object, this.bytes, this.pos);      this.pos += byteLength;    }  }
  private encodeObject(object: unknown, depth: number) {    // try to encode objects with custom codec first of non-primitives    const ext = this.extensionCodec.tryToEncode(object, this.context);    if (ext != null) {      this.encodeExtension(ext);    } else if (Array.isArray(object)) {      this.encodeArray(object, depth);    } else if (ArrayBuffer.isView(object)) {      this.encodeBinary(object);    } else if (typeof object === "object") {      this.encodeMap(object as Record<string, unknown>, depth);    } else {      // symbol, function and other special object come here unless extensionCodec handles them.      throw new Error(        `Unrecognized object: ${Object.prototype.toString.apply(object)}`,      );    }  }
  private encodeBinary(object: ArrayBufferView) {    const size = object.byteLength;    if (size < 0x100) {      // bin 8      this.writeU8(0xc4);      this.writeU8(size);    } else if (size < 0x10000) {      // bin 16      this.writeU8(0xc5);      this.writeU16(size);    } else if (size < 0x100000000) {      // bin 32      this.writeU8(0xc6);      this.writeU32(size);    } else {      throw new Error(`Too large binary: ${size}`);    }    const bytes = ensureUint8Array(object);    this.writeU8a(bytes);  }
  private encodeArray(object: Array<unknown>, depth: number) {    const size = object.length;    if (size < 16) {      // fixarray      this.writeU8(0x90 + size);    } else if (size < 0x10000) {      // array 16      this.writeU8(0xdc);      this.writeU16(size);    } else if (size < 0x100000000) {      // array 32      this.writeU8(0xdd);      this.writeU32(size);    } else {      throw new Error(`Too large array: ${size}`);    }    for (const item of object) {      this.doEncode(item, depth + 1);    }  }
  private countWithoutUndefined(    object: Record<string, unknown>,    keys: ReadonlyArray<string>,  ): number {    let count = 0;
    for (const key of keys) {      if (object[key] !== undefined) {        count++;      }    }
    return count;  }
  private encodeMap(object: Record<string, unknown>, depth: number) {    const keys = Object.keys(object);    if (this.sortKeys) {      keys.sort();    }
    const size = this.ignoreUndefined      ? this.countWithoutUndefined(object, keys)      : keys.length;
    if (size < 16) {      // fixmap      this.writeU8(0x80 + size);    } else if (size < 0x10000) {      // map 16      this.writeU8(0xde);      this.writeU16(size);    } else if (size < 0x100000000) {      // map 32      this.writeU8(0xdf);      this.writeU32(size);    } else {      throw new Error(`Too large map object: ${size}`);    }
    for (const key of keys) {      const value = object[key];
      if (!(this.ignoreUndefined && value === undefined)) {        this.encodeString(key);        this.doEncode(value, depth + 1);      }    }  }
  private encodeExtension(ext: ExtData) {    const size = ext.data.length;    if (size === 1) {      // fixext 1      this.writeU8(0xd4);    } else if (size === 2) {      // fixext 2      this.writeU8(0xd5);    } else if (size === 4) {      // fixext 4      this.writeU8(0xd6);    } else if (size === 8) {      // fixext 8      this.writeU8(0xd7);    } else if (size === 16) {      // fixext 16      this.writeU8(0xd8);    } else if (size < 0x100) {      // ext 8      this.writeU8(0xc7);      this.writeU8(size);    } else if (size < 0x10000) {      // ext 16      this.writeU8(0xc8);      this.writeU16(size);    } else if (size < 0x100000000) {      // ext 32      this.writeU8(0xc9);      this.writeU32(size);    } else {      throw new Error(`Too large extension object: ${size}`);    }    this.writeI8(ext.type);    this.writeU8a(ext.data);  }
  private writeU8(value: number) {    this.ensureBufferSizeToWrite(1);
    this.view.setUint8(this.pos, value);    this.pos++;  }
  private writeU8a(values: ArrayLike<number>) {    const size = values.length;    this.ensureBufferSizeToWrite(size);
    this.bytes.set(values, this.pos);    this.pos += size;  }
  private writeI8(value: number) {    this.ensureBufferSizeToWrite(1);
    this.view.setInt8(this.pos, value);    this.pos++;  }
  private writeU16(value: number) {    this.ensureBufferSizeToWrite(2);
    this.view.setUint16(this.pos, value);    this.pos += 2;  }
  private writeI16(value: number) {    this.ensureBufferSizeToWrite(2);
    this.view.setInt16(this.pos, value);    this.pos += 2;  }
  private writeU32(value: number) {    this.ensureBufferSizeToWrite(4);
    this.view.setUint32(this.pos, value);    this.pos += 4;  }
  private writeI32(value: number) {    this.ensureBufferSizeToWrite(4);
    this.view.setInt32(this.pos, value);    this.pos += 4;  }
  private writeF32(value: number) {    this.ensureBufferSizeToWrite(4);    this.view.setFloat32(this.pos, value);    this.pos += 4;  }
  private writeF64(value: number) {    this.ensureBufferSizeToWrite(8);    this.view.setFloat64(this.pos, value);    this.pos += 8;  }
  private writeU64(value: number) {    this.ensureBufferSizeToWrite(8);
    setUint64(this.view, this.pos, value);    this.pos += 8;  }
  private writeI64(value: number) {    this.ensureBufferSizeToWrite(8);
    setInt64(this.view, this.pos, value);    this.pos += 8;  }}