amf-ts 1.0.0

package/dist/amf.js

@@ -0,0 +1,1024 @@
+class d {
+  /**
+   * 创建一个强制类型值
+   *
+   * @param value - 实际要编码的值
+   * @param type - 强制使用的 AMF 类型
+   */
+  constructor(e, t) {
+    this.value = e, this.type = t;
+  }
+}
+class y {
+  /**
+   * 创建一个 AMF3 对象特征
+   *
+   * @param name - 对象的类名
+   * @param dynamic - 是否为动态对象
+   * @param externalizable - 是否可外部化
+   */
+  constructor(e, t, r) {
+    this.name = e, this.dynamic = t, this.externalizable = r, this.staticFields = [];
+  }
+}
+class u {
+  /**
+   * 创建一个可序列化对象
+   *
+   * @param serializableName - 对象的类名（可选）
+   * @param dynamic - 是否为动态对象（可选，默认 true）
+   */
+  constructor(e, t) {
+    this.__class = e, this.__dynamic = t;
+  }
+}
+class E extends u {
+  /**
+   * 创建一个可外部化对象
+   *
+   * @param externalizableName - 对象的类名
+   */
+  constructor(e) {
+    super(e);
+  }
+  /**
+   * 将对象写入编码器
+   *
+   * 子类必须覆盖此方法来实现自定义的序列化逻辑。
+   * 写入的数据必须能够被对应的 read() 静态方法正确读取。
+   *
+   * @param encoder - AMF 编码器实例
+   * @throws 如果子类没有实现此方法
+   */
+  write(e) {
+    throw new Error(`可外部化对象 ${this.__class} 没有定义 write 方法！`);
+  }
+  /**
+   * 从解码器读取并创建对象实例
+   *
+   * 子类必须定义一个同名的静态方法来实现自定义的反序列化逻辑。
+   * 此方法应该读取 write() 方法写入的数据并返回新的对象实例。
+   *
+   * 注意：这是一个静态方法，子类需要像这样定义：
+   * static read(decoder: AMFDecoder): YourClass { ... }
+   *
+   * @param decoder - AMF 解码器实例
+   * @returns 反序列化后的对象实例
+   * @throws 如果子类没有实现此方法
+   */
+  static read(e) {
+    throw new Error("可外部化对象没有定义 read 方法！");
+  }
+}
+class s {
+  /**
+   * 创建一个新的 AMF 类型
+   *
+   * @param id - 类型的数字标识符
+   * @param name - 类型的名称
+   * @param referencable - 是否可引用，默认为 false
+   */
+  constructor(e, t, r = !1) {
+    this.encode = () => {
+      throw new Error(`没有为类型 ${this.name} 定义编码器`);
+    }, this.decode = () => {
+      throw new Error(`没有为类型 ${this.name} 定义解码器`);
+    }, this.id = e, this.name = t, this.referencable = r;
+  }
+}
+const h = {
+  /**
+   * 根据 JavaScript 值推断对应的 AMF0 类型
+   *
+   * @param value - 要推断类型的值
+   * @returns 对应的 AMF0 类型
+   * @throws 如果无法推断类型则抛出错误
+   */
+  infer(i) {
+    const e = typeof i;
+    if (i === null)
+      return h.NULL;
+    if (e === "undefined")
+      return h.UNDEFINED;
+    if (i instanceof d)
+      return i.type;
+    if (e === "number")
+      return h.NUMBER;
+    if (e === "boolean")
+      return h.BOOLEAN;
+    if (e === "string" && i.length >= 65535)
+      return h.LONG_STRING;
+    if (e === "string")
+      return h.STRING;
+    if (Object.prototype.toString.call(i) === "[object Date]")
+      return h.DATE;
+    if (i instanceof Array)
+      return h.STRICT_ARRAY;
+    if (i instanceof u)
+      return !i.__class || i.__class === "" ? h.OBJECT : h.TYPED_OBJECT;
+    if (e === "object")
+      return h.ECMA_ARRAY;
+    throw new Error(`无法推断值的 AMF0 类型: ${JSON.stringify(i)}`);
+  },
+  /**
+   * 根据类型 ID 获取对应的 AMF0 类型
+   *
+   * @param id - 类型的数字标识符
+   * @returns 对应的 AMF0 类型
+   * @throws 如果找不到对应的类型则抛出错误
+   */
+  fromId(i) {
+    for (const e of Object.keys(h)) {
+      const t = h[e];
+      if (t instanceof s && t.id === i)
+        return t;
+    }
+    throw new Error(`没有 ID 为 ${i} 的 AMF0 类型`);
+  },
+  /** 数字类型 (0x00) - 64位双精度浮点数 */
+  NUMBER: new s(0, "NUMBER"),
+  /** 布尔类型 (0x01) */
+  BOOLEAN: new s(1, "BOOLEAN"),
+  /** 字符串类型 (0x02) - 最大 65535 字节 */
+  STRING: new s(2, "STRING"),
+  /** 对象类型 (0x03) - 匿名对象 */
+  OBJECT: new s(3, "OBJECT", !0),
+  /** MovieClip 类型 (0x04) - Flash 专用，通常不使用 */
+  MOVIECLIP: new s(4, "MOVIECLIP"),
+  /** 空值类型 (0x05) */
+  NULL: new s(5, "NULL"),
+  /** 未定义类型 (0x06) */
+  UNDEFINED: new s(6, "UNDEFINED"),
+  /** 引用类型 (0x07) - 引用之前序列化的对象 */
+  REFERENCE: new s(7, "REFERENCE"),
+  /** ECMA 数组类型 (0x08) - 关联数组/对象 */
+  ECMA_ARRAY: new s(8, "ECMA_ARRAY", !0),
+  /** 对象结束标记 (0x09) */
+  OBJECT_END: new s(9, "OBJECT_END"),
+  /** 严格数组类型 (0x0A) - 数字索引数组 */
+  STRICT_ARRAY: new s(10, "STRICT_ARRAY", !0),
+  /** 日期类型 (0x0B) */
+  DATE: new s(11, "DATE"),
+  /** 长字符串类型 (0x0C) - 超过 65535 字节的字符串 */
+  LONG_STRING: new s(12, "LONG_STRING"),
+  /** 不支持的类型 (0x0D) */
+  UNSUPPORTED: new s(13, "UNSUPPORTED"),
+  /** XML 类型 (0x0F) */
+  XML: new s(15, "XML"),
+  /** 类型化对象 (0x10) - 有类名的对象 */
+  TYPED_OBJECT: new s(16, "TYPED_OBJECT", !0),
+  /** AMF3 对象标记 (0x11) - 表示后续数据使用 AMF3 格式 */
+  AMF3_OBJECT: new s(17, "AMF3_OBJECT")
+}, a = {
+  /**
+   * 根据 JavaScript 值推断对应的 AMF3 类型
+   *
+   * @param value - 要推断类型的值
+   * @returns 对应的 AMF3 类型
+   * @throws 如果无法推断类型则抛出错误
+   */
+  infer(i) {
+    const e = typeof i;
+    if (i === null)
+      return a.NULL;
+    if (e === "undefined")
+      return a.UNDEFINED;
+    if (i instanceof d)
+      return i.type;
+    if (e === "boolean" && !i)
+      return a.FALSE;
+    if (e === "boolean")
+      return a.TRUE;
+    if (e === "string")
+      return a.STRING;
+    if (e === "number" && isFinite(i) && i % 1 === 0 && i < 536870911 && i > -268435456)
+      return a.INTEGER;
+    if (e === "number")
+      return a.DOUBLE;
+    if (Object.prototype.toString.call(i) === "[object Date]")
+      return a.DATE;
+    if (i instanceof Uint8Array)
+      return a.BYTE_ARRAY;
+    if (i instanceof Array)
+      return a.ARRAY;
+    if (i instanceof u || i instanceof E)
+      return a.OBJECT;
+    if (e === "object")
+      return a.ARRAY;
+    throw new Error(`无法推断值的 AMF3 类型: ${JSON.stringify(i)}`);
+  },
+  /**
+   * 根据类型 ID 获取对应的 AMF3 类型
+   *
+   * @param id - 类型的数字标识符
+   * @returns 对应的 AMF3 类型
+   * @throws 如果找不到对应的类型则抛出错误
+   */
+  fromId(i) {
+    for (const e of Object.keys(a)) {
+      const t = a[e];
+      if (t instanceof s && t.id === i)
+        return t;
+    }
+    throw new Error(`没有 ID 为 ${i} 的 AMF3 类型`);
+  },
+  /** 未定义类型 (0x00) */
+  UNDEFINED: new s(0, "UNDEFINED"),
+  /** 空值类型 (0x01) */
+  NULL: new s(1, "NULL"),
+  /** 布尔假值 (0x02) */
+  FALSE: new s(2, "FALSE"),
+  /** 布尔真值 (0x03) */
+  TRUE: new s(3, "TRUE"),
+  /** 整数类型 (0x04) - 29位有符号整数 */
+  INTEGER: new s(4, "INTEGER"),
+  /** 双精度浮点数类型 (0x05) */
+  DOUBLE: new s(5, "DOUBLE"),
+  /** 字符串类型 (0x06) */
+  STRING: new s(6, "STRING", !0),
+  /** XML 文档类型 (0x07) */
+  XML_DOC: new s(7, "XML_DOC", !0),
+  /** 日期类型 (0x08) */
+  DATE: new s(8, "DATE", !0),
+  /** 数组类型 (0x09) */
+  ARRAY: new s(9, "ARRAY", !0),
+  /** 对象类型 (0x0A) */
+  OBJECT: new s(10, "OBJECT", !0),
+  /** XML 类型 (0x0B) */
+  XML: new s(11, "XML", !0),
+  /** 字节数组类型 (0x0C) */
+  BYTE_ARRAY: new s(12, "BYTE_ARRAY", !0),
+  /** 整数向量类型 (0x0D) */
+  VECTOR_INT: new s(13, "VECTOR_INT", !0),
+  /** 无符号整数向量类型 (0x0E) */
+  VECTOR_UINT: new s(14, "VECTOR_UINT", !0),
+  /** 双精度浮点数向量类型 (0x0F) */
+  VECTOR_DOUBLE: new s(15, "VECTOR_DOUBLE", !0),
+  /** 对象向量类型 (0x10) */
+  VECTOR_OBJECT: new s(16, "VECTOR_OBJECT", !0),
+  /** 字典类型 (0x11) */
+  DICTIONARY: new s(17, "DICTIONARY", !0)
+};
+class b {
+  /**
+   * 创建一个新的读取器
+   *
+   * @param data - 要读取的二进制数据
+   */
+  constructor(e) {
+    this.data = e, this.view = new DataView(e.buffer, e.byteOffset, e.byteLength), this.position = 0;
+  }
+  /**
+   * 获取当前读取位置
+   *
+   * @returns 当前位置（字节偏移量）
+   */
+  getPosition() {
+    return this.position;
+  }
+  /**
+   * 设置读取位置
+   *
+   * @param pos - 新的位置
+   */
+  setPosition(e) {
+    this.position = e;
+  }
+  /**
+   * 获取剩余可读字节数
+   *
+   * @returns 剩余字节数
+   */
+  getBytesAvailable() {
+    return this.data.length - this.position;
+  }
+  /**
+   * 检查是否还有足够的字节可读
+   *
+   * @param length - 需要的字节数
+   * @throws 如果剩余字节不足
+   */
+  checkAvailable(e) {
+    if (this.position + e > this.data.length)
+      throw new Error(`没有足够的 ${e} 字节可读，当前位置: ${this.position}，总长度: ${this.data.length}`);
+  }
+  /**
+   * 读取一个或多个字节
+   *
+   * @param length - 要读取的字节数，默认为 1
+   * @param alwaysReturnArray - 即使只读取一个字节也返回 Uint8Array
+   * @returns 如果 length 为 1 且 alwaysReturnArray 为 false，返回单个数字；否则返回 Uint8Array
+   */
+  readByte(e = 1, t = !1) {
+    if (this.checkAvailable(e), e === 1 && !t)
+      return this.data[this.position++];
+    const r = this.data.slice(this.position, this.position + e);
+    return this.position += e, r;
+  }
+  /**
+   * 读取一个无符号 8 位整数
+   *
+   * @returns 0-255 范围内的整数
+   */
+  readUInt8() {
+    return this.checkAvailable(1), this.data[this.position++];
+  }
+  /**
+   * 读取一个有符号 8 位整数
+   *
+   * @returns -128 到 127 范围内的整数
+   */
+  readInt8() {
+    const e = this.readUInt8();
+    return e > 127 ? e - 256 : e;
+  }
+  /**
+   * 读取一个大端序无符号 16 位整数
+   *
+   * @returns 0-65535 范围内的整数
+   */
+  readUInt16BE() {
+    this.checkAvailable(2);
+    const e = this.view.getUint16(this.position, !1);
+    return this.position += 2, e;
+  }
+  /**
+   * 读取一个大端序有符号 16 位整数
+   *
+   * @returns -32768 到 32767 范围内的整数
+   */
+  readInt16BE() {
+    this.checkAvailable(2);
+    const e = this.view.getInt16(this.position, !1);
+    return this.position += 2, e;
+  }
+  /**
+   * 读取一个大端序无符号 32 位整数
+   *
+   * @returns 0-4294967295 范围内的整数
+   */
+  readUInt32BE() {
+    this.checkAvailable(4);
+    const e = this.view.getUint32(this.position, !1);
+    return this.position += 4, e;
+  }
+  /**
+   * 读取一个大端序有符号 32 位整数
+   *
+   * @returns -2147483648 到 2147483647 范围内的整数
+   */
+  readInt32BE() {
+    this.checkAvailable(4);
+    const e = this.view.getInt32(this.position, !1);
+    return this.position += 4, e;
+  }
+  /**
+   * 读取一个大端序 64 位双精度浮点数
+   *
+   * @returns 双精度浮点数
+   */
+  readDoubleBE() {
+    this.checkAvailable(8);
+    const e = this.view.getFloat64(this.position, !1);
+    return this.position += 8, e;
+  }
+  /**
+   * 读取一个 AMF0 格式的字符串
+   *
+   * AMF0 字符串格式：2字节长度 + UTF-8 编码的字符串数据
+   *
+   * @returns 解码后的字符串
+   */
+  readString() {
+    const e = this.readUInt16BE();
+    return e === 0 ? "" : this.readUTF8String(e);
+  }
+  /**
+   * 读取指定长度的 UTF-8 字符串
+   *
+   * @param length - 字符串的字节长度
+   * @returns 解码后的字符串
+   */
+  readUTF8String(e) {
+    this.checkAvailable(e);
+    const t = this.data.slice(this.position, this.position + e);
+    return this.position += e, new TextDecoder("utf-8").decode(t);
+  }
+  /**
+   * 读取 AMF3 的变长整数（Int29）
+   *
+   * AMF3 使用一种可变长度编码来表示 29 位有符号整数
+   * 每个字节的最高位表示是否还有更多字节：
+   * - 0xxxxxxx: 单字节，值 0-127
+   * - 1xxxxxxx 0xxxxxxx: 双字节
+   * - 1xxxxxxx 1xxxxxxx 0xxxxxxx: 三字节
+   * - 1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx: 四字节（最后一个字节使用全部 8 位）
+   *
+   * @returns 29 位有符号整数，范围 -268435456 到 536870911
+   */
+  readInt29() {
+    let e = 0, t = this.readUInt8();
+    return t < 128 ? t : (e = (t & 127) << 7, t = this.readUInt8(), t < 128 ? e |= t : (e = (e | t & 127) << 7, t = this.readUInt8(), t < 128 ? e |= t : (e = (e | t & 127) << 8, e |= this.readUInt8())), -(e & 1 << 28) | e);
+  }
+  /**
+   * 读取 AMF3 头部信息
+   *
+   * AMF3 中很多类型使用一个头部来区分是定义还是引用：
+   * - 最低位为 0: 这是一个引用，高位存储引用索引
+   * - 最低位为 1: 这是一个定义，高位存储数据长度或其他信息
+   *
+   * @returns AMF 头部信息对象
+   */
+  readAMFHeader() {
+    const e = this.readInt29(), t = (e & 1) !== 0, r = e >> 1;
+    return {
+      isDef: t,
+      value: r
+    };
+  }
+}
+const w = class w extends b {
+  /**
+   * 注册外部化类型
+   */
+  static register(e, t) {
+    this.amf3Externalizables[e] = t;
+  }
+  constructor(e) {
+    super(e), this.amf3StringReferences = [], this.amf3ObjectReferences = [], this.amf3TraitReferences = [];
+  }
+  /**
+   * 解码一个 AMF3 值
+   */
+  decode() {
+    const e = this.readUInt8();
+    return this.readByTypeId(e);
+  }
+  /**
+   * 按 AMF3 类型对象解码（兼容接口）
+   */
+  deserialize(e) {
+    return e instanceof s ? this.readByTypeId(e.id) : this.readByTypeId(e);
+  }
+  /**
+   * 按类型 ID 分发解码
+   */
+  readByTypeId(e) {
+    switch (e) {
+      case 0:
+        return;
+      case 1:
+        return null;
+      case 2:
+        return !1;
+      case 3:
+        return !0;
+      case 4:
+        return this.readInt29();
+      case 5:
+        return this.readDoubleBE();
+      case 6:
+        return this.readAMF3String();
+      case 8:
+        return this.readAMF3Date();
+      case 9:
+        return this.readAMF3Array();
+      case 10:
+        return this.readAMF3Object();
+      case 12:
+        return this.readAMF3ByteArray();
+      case 13:
+        return this.readAMF3VectorInt();
+      case 14:
+        return this.readAMF3VectorUInt();
+      case 15:
+        return this.readAMF3VectorDouble();
+      case 16:
+        return this.readAMF3VectorObject();
+      case 17:
+        return this.readAMF3Dictionary();
+      default:
+        throw new Error("当前 AMF3 解码器暂不支持类型 ID: " + e);
+    }
+  }
+  /**
+   * 读取 AMF3 字符串
+   * 
+   * todo 字符串过长时可能有bug?  当前读长读，用的是u29的方式
+   */
+  readAMF3String() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const r = this.amf3StringReferences[e.value];
+      if (typeof r != "string")
+        throw new Error("无效的 AMF3 字符串引用");
+      return r;
+    }
+    if (e.value === 0)
+      return "";
+    const t = this.readUTF8String(e.value);
+    return this.amf3StringReferences.push(t), t;
+  }
+  /**
+   * 读取 AMF3 日期
+   */
+  readAMF3Date() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const r = this.amf3ObjectReferences[e.value];
+      if (!(r instanceof Date))
+        throw new Error("无效的 AMF3 日期引用");
+      return r;
+    }
+    const t = new Date(this.readDoubleBE());
+    return this.amf3ObjectReferences.push(t), t;
+  }
+  /**
+   * 读取 AMF3 数组
+   */
+  readAMF3Array() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const c = this.amf3ObjectReferences[e.value];
+      if (!c)
+        throw new Error("无效的 AMF3 数组引用");
+      return c;
+    }
+    const t = {};
+    this.amf3ObjectReferences.push(t);
+    const r = this.amf3ObjectReferences.length - 1;
+    for (; ; ) {
+      const c = this.readAMF3String();
+      if (c === "")
+        break;
+      t[c] = this.decode();
+    }
+    if (Object.keys(t).length > 0)
+      return t;
+    const n = [];
+    this.amf3ObjectReferences[r] = n;
+    for (let c = 0; c < e.value; c++)
+      n.push(this.decode());
+    return n;
+  }
+  /**
+   * 读取 AMF3 对象 Trait
+   */
+  readAMF3ObjectTrait(e) {
+    if (!(e & 1)) {
+      const f = this.amf3TraitReferences[e >> 1];
+      if (!f)
+        throw new Error("无效的 AMF3 Trait 引用");
+      return f;
+    }
+    const t = this.readAMF3String(), r = (e >> 1 & 1) === 1, n = (e >> 2 & 1) === 1, c = e >> 3, o = new y(t, n, r);
+    for (let f = 0; f < c; f++)
+      o.staticFields.push(this.readAMF3String());
+    return this.amf3TraitReferences.push(o), o;
+  }
+  /**
+   * 读取 AMF3 对象
+   */
+  readAMF3Object() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const n = this.amf3ObjectReferences[e.value];
+      if (!n)
+        throw new Error("无效的 AMF3 对象引用");
+      return n;
+    }
+    const t = this.readAMF3ObjectTrait(e.value);
+    if (t.externalizable) {
+      if (t.name === "flex.messaging.io.ArrayCollection") {
+        const o = this.decode();
+        return this.amf3ObjectReferences.push(o), o;
+      }
+      const n = w.amf3Externalizables[t.name];
+      if (!n)
+        throw new Error("未注册 AMF3 外部化类型: " + t.name);
+      const c = n.read(this);
+      return this.amf3ObjectReferences.push(c), c;
+    }
+    const r = new u(t.name || void 0);
+    this.amf3ObjectReferences.push(r);
+    for (let n = 0; n < t.staticFields.length; n++) {
+      const c = t.staticFields[n];
+      r[c] = this.decode();
+    }
+    if (t.dynamic)
+      for (; ; ) {
+        const n = this.readAMF3String();
+        if (n === "")
+          break;
+        r[n] = this.decode();
+      }
+    return r;
+  }
+  /**
+   * 读取 AMF3 ByteArray
+   */
+  readAMF3ByteArray() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const r = this.amf3ObjectReferences[e.value];
+      if (!(r instanceof Uint8Array))
+        throw new Error("无效的 AMF3 ByteArray 引用");
+      return r;
+    }
+    const t = this.readByte(e.value, !0);
+    return this.amf3ObjectReferences.push(t), t;
+  }
+  /**
+   * 向量解码通用逻辑
+   */
+  readAMF3Vector(e) {
+    const t = this.readAMFHeader();
+    if (!t.isDef) {
+      const n = this.amf3ObjectReferences[t.value];
+      if (!n)
+        throw new Error("无效的 AMF3 向量引用");
+      return n;
+    }
+    this.readUInt8();
+    const r = [];
+    this.amf3ObjectReferences.push(r);
+    for (let n = 0; n < t.value; n++)
+      r.push(e.call(this));
+    return r;
+  }
+  /**
+   * 读取 VECTOR_INT
+   */
+  readAMF3VectorInt() {
+    return this.readAMF3Vector(function() {
+      return this.readInt32BE();
+    });
+  }
+  /**
+   * 读取 VECTOR_UINT
+   */
+  readAMF3VectorUInt() {
+    return this.readAMF3Vector(function() {
+      return this.readUInt32BE();
+    });
+  }
+  /**
+   * 读取 VECTOR_DOUBLE
+   */
+  readAMF3VectorDouble() {
+    return this.readAMF3Vector(function() {
+      return this.readDoubleBE();
+    });
+  }
+  /**
+   * 读取 VECTOR_OBJECT
+   */
+  readAMF3VectorObject() {
+    return this.readAMF3Vector(function() {
+      return this.decode();
+    });
+  }
+  /**
+   * 读取 DICTIONARY
+   */
+  readAMF3Dictionary() {
+    const e = this.readAMFHeader();
+    if (!e.isDef) {
+      const r = this.amf3ObjectReferences[e.value];
+      if (!r)
+        throw new Error("无效的 AMF3 字典引用");
+      return r;
+    }
+    this.readUInt8();
+    const t = {};
+    this.amf3ObjectReferences.push(t);
+    for (let r = 0; r < e.value; r++) {
+      const n = this.decode();
+      t[JSON.stringify(n)] = this.decode();
+    }
+    return t;
+  }
+};
+w.amf3Externalizables = {};
+let A = w;
+class I {
+  /**
+   * 创建一个新的写入器
+   */
+  constructor() {
+    this.chunks = [], this.totalLength = 0;
+  }
+  /**
+   * 获取当前已写入的字节数
+   *
+   * @returns 已写入的总字节数
+   */
+  getLength() {
+    return this.totalLength;
+  }
+  /**
+   * 获取写入的所有数据
+   *
+   * 将所有写入的数据块合并为一个 Uint8Array
+   *
+   * @returns 包含所有写入数据的 Uint8Array
+   */
+  getBuffer() {
+    const e = new Uint8Array(this.totalLength);
+    let t = 0;
+    for (const r of this.chunks)
+      e.set(r, t), t += r.length;
+    return e;
+  }
+  /**
+   * 清空写入器，重置到初始状态
+   */
+  clear() {
+    this.chunks = [], this.totalLength = 0;
+  }
+  /**
+   * 写入数据到缓冲区
+   *
+   * 支持多种数据类型：
+   * - 数字（0-255）：作为单个字节写入
+   * - 数字数组：每个元素作为一个字节写入
+   * - Uint8Array：直接写入
+   * - 字符串：作为 UTF-8 编码写入
+   *
+   * @param value - 要写入的值
+   * @throws 如果值的类型不支持
+   */
+  write(e) {
+    if (typeof e == "number") {
+      const t = new Uint8Array([e & 255]);
+      this.chunks.push(t), this.totalLength += 1;
+    } else if (Array.isArray(e)) {
+      const t = new Uint8Array(e.map((r) => r & 255));
+      this.chunks.push(t), this.totalLength += t.length;
+    } else if (e instanceof Uint8Array)
+      this.chunks.push(e), this.totalLength += e.length;
+    else if (typeof e == "string") {
+      const r = new TextEncoder().encode(e);
+      this.chunks.push(r), this.totalLength += r.length;
+    } else
+      throw new Error(`不知道如何写入: ${JSON.stringify(e)}`);
+  }
+  /**
+   * 写入单个字节
+   *
+   * @param value - 0-255 范围内的整数
+   */
+  writeByte(e) {
+    this.write(e & 255);
+  }
+  /**
+   * 写入字节数组
+   *
+   * @param bytes - 字节数组或 Uint8Array
+   */
+  writeBytes(e) {
+    this.write(e);
+  }
+  /**
+   * 写入一个大端序无符号 16 位整数
+   *
+   * @param value - 0-65535 范围内的整数
+   */
+  writeUInt16BE(e) {
+    const t = new Uint8Array(2);
+    new DataView(t.buffer).setUint16(0, e, !1), this.write(t);
+  }
+  /**
+   * 写入一个大端序有符号 16 位整数
+   *
+   * @param value - -32768 到 32767 范围内的整数
+   */
+  writeInt16BE(e) {
+    const t = new Uint8Array(2);
+    new DataView(t.buffer).setInt16(0, e, !1), this.write(t);
+  }
+  /**
+   * 写入一个大端序无符号 32 位整数
+   *
+   * @param value - 0-4294967295 范围内的整数
+   */
+  writeUInt32BE(e) {
+    const t = new Uint8Array(4);
+    new DataView(t.buffer).setUint32(0, e, !1), this.write(t);
+  }
+  /**
+   * 写入一个大端序有符号 32 位整数
+   *
+   * @param value - -2147483648 到 2147483647 范围内的整数
+   */
+  writeInt32BE(e) {
+    const t = new Uint8Array(4);
+    new DataView(t.buffer).setInt32(0, e, !1), this.write(t);
+  }
+  /**
+   * 写入一个大端序 64 位双精度浮点数
+   *
+   * @param value - 双精度浮点数
+   */
+  writeDoubleBE(e) {
+    const t = new Uint8Array(8);
+    new DataView(t.buffer).setFloat64(0, e, !1), this.write(t);
+  }
+  /**
+   * 写入一个 AMF0 格式的字符串
+   *
+   * AMF0 字符串格式：2字节长度（大端序）+ UTF-8 编码的字符串数据
+   *
+   * @param value - 要写入的字符串
+   */
+  writeString(e) {
+    const r = new TextEncoder().encode(e);
+    this.writeUInt16BE(r.length), this.write(r);
+  }
+  /**
+   * 写入 AMF3 的变长整数（Int29）
+   *
+   * AMF3 使用一种可变长度编码来表示 29 位有符号整数
+   * 每个字节的最高位表示是否还有更多字节：
+   * - 值 0-127: 单字节 (0xxxxxxx)
+   * - 值 128-16383: 双字节 (1xxxxxxx 0xxxxxxx)
+   * - 值 16384-2097151: 三字节 (1xxxxxxx 1xxxxxxx 0xxxxxxx)
+   * - 值 2097152-536870911: 四字节 (1xxxxxxx 1xxxxxxx 1xxxxxxx xxxxxxxx)
+   *
+   * @param value - 29 位有符号整数，范围 -268435456 到 536870911
+   * @throws 如果值超出范围
+   */
+  writeInt29(e) {
+    if (e > 536870911 || e < -268435456)
+      throw new RangeError(`Int29 值超出范围: ${e}`);
+    e &= 536870911, e < 128 ? this.write(e) : e < 16384 ? this.write([
+      e >> 7 & 127 | 128,
+      e & 127
+    ]) : e < 2097152 ? this.write([
+      e >> 14 & 127 | 128,
+      e >> 7 & 127 | 128,
+      e & 127
+    ]) : this.write([
+      e >> 22 & 127 | 128,
+      e >> 14 & 127 | 128,
+      e >> 7 & 127 | 128,
+      e & 255
+    ]);
+  }
+}
+function R(i) {
+  return (typeof i.getSerializableFields == "function" ? i.getSerializableFields() : Object.keys(i)).filter(function(r) {
+    return r.indexOf("__") !== 0;
+  });
+}
+class O extends I {
+  constructor() {
+    super(), this.amf3ObjectReferences = [], this.amf3StringReferences = [];
+  }
+  /**
+   * 编码一个 AMF3 值（会写入类型标记）
+   */
+  writeObject(e) {
+    this.encodeValue(e);
+  }
+  /**
+   * 兼容旧接口，含义与 writeObject 相同
+   */
+  encode(e) {
+    this.encodeValue(e);
+  }
+  /**
+   * 编码值主体（无类型标记）
+   */
+  serialize(e) {
+    const t = this.inferType(e);
+    this.writeByType(e instanceof d ? e.value : e, t);
+  }
+  /**
+   * 推断值的 AMF3 类型
+   */
+  inferType(e) {
+    return a.infer(e);
+  }
+  /**
+   * 编码一个完整值（含类型标记与引用处理）
+   */
+  encodeValue(e) {
+    const t = this.inferType(e), r = e instanceof d ? e.value : e;
+    if (t.referencable && r !== "") {
+      let n = -1;
+      if (t === a.STRING ? n = this.amf3StringReferences.indexOf(r) : n = this.amf3ObjectReferences.indexOf(r), n !== -1) {
+        this.writeByte(t.id), this.writeInt29(n << 1);
+        return;
+      }
+      t === a.STRING ? this.amf3StringReferences.push(r) : this.amf3ObjectReferences.push(r);
+    }
+    this.writeByte(t.id), this.writeByType(r, t);
+  }
+  /**
+   * 按类型写入值主体（不包含类型标记）
+   */
+  writeByType(e, t) {
+    switch (t.id) {
+      case 0:
+      case 1:
+      case 2:
+      case 3:
+        return;
+      case 4:
+        this.writeInt29(e);
+        return;
+      case 5:
+        this.writeDoubleBE(e);
+        return;
+      case 6:
+        this.writeInlineString(e);
+        return;
+      case 8:
+        this.writeInt29(1), this.writeDoubleBE(e.getTime());
+        return;
+      case 9:
+        this.writeArray(e);
+        return;
+      case 10:
+        this.writeObjectValue(e);
+        return;
+      case 12:
+        this.writeByteArray(e);
+        return;
+      default:
+        throw new Error("当前 AMF3 编码器暂不支持该类型: " + t.name);
+    }
+  }
+  /**
+   * 写入 AMF3 内联字符串（无类型标记）
+   *
+   * 说明：
+   * 这里保持与原 lib 行为一致，不在“无类型字符串”分支中做字符串引用表复用。
+   */
+  writeInlineString(e) {
+    const t = new TextEncoder().encode(e);
+    this.writeInt29(t.length << 1 | 1), this.write(t);
+  }
+  /**
+   * 写入 AMF3 数组（密集数组或关联数组）
+   */
+  writeArray(e) {
+    if (Array.isArray(e)) {
+      this.writeInt29(e.length << 1 | 1), this.writeInlineString("");
+      for (let r = 0; r < e.length; r++)
+        this.encodeValue(e[r]);
+      return;
+    }
+    this.writeInt29(1);
+    const t = Object.keys(e);
+    for (let r = 0; r < t.length; r++) {
+      const n = t[r];
+      n.indexOf("__") !== 0 && (this.writeInlineString(n), this.encodeValue(e[n]));
+    }
+    this.writeInlineString("");
+  }
+  /**
+   * 写入 AMF3 对象
+   */
+  writeObjectValue(e) {
+    if (e.__dynamic !== !1 && !e.__class) {
+      this.writeInt29(11), this.writeInt29(1);
+      const o = Object.keys(e);
+      for (let f = 0; f < o.length; f++) {
+        const l = o[f];
+        l.indexOf("__") !== 0 && (this.writeInlineString(l), this.encodeValue(e[l]));
+      }
+      this.writeInlineString("");
+      return;
+    }
+    const r = e instanceof E, n = r ? [] : R(e);
+    let c = n.length << 4;
+    if (c |= (r ? 1 : 0) << 2, c = c | 2 | 1, this.writeInt29(c), this.writeInlineString(e.__class || ""), r) {
+      e.write(this);
+      return;
+    }
+    for (let o = 0; o < n.length; o++)
+      this.writeInlineString(n[o]);
+    for (let o = 0; o < n.length; o++)
+      this.encodeValue(e[n[o]]);
+  }
+  /**
+   * 写入 AMF3 ByteArray
+   */
+  writeByteArray(e) {
+    this.writeInt29(e.length << 1 | 1), this.write(e);
+  }
+}
+export {
+  h as AMF0,
+  a as AMF3,
+  A as AMFDecoder,
+  O as AMFEncoder,
+  y as AMFTrait,
+  s as AMFType,
+  E as Externalizable,
+  d as ForcedTypeValue,
+  u as Serializable
+};
+//# sourceMappingURL=amf.js.map