remove Handshake and EndOfEarlyData

Author: Srabutdotcom

deno.json

@@ -1,6 +1,6 @@
 {
   "name": "@tls/enum",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "exports": "./src/mod.ts",
   "publish": {
     "exclude": ["dist/"]

src/handshaketype.js

@@ -1,8 +1,8 @@
 // deno-lint-ignore-file no-slow-types
 // @ts-self-types="../type/handshaketype.d.ts"
 import { Enum } from "./enum.js";
-import { Struct, Uint24, Uint8 } from "./dep.ts";
-import { ContentType } from "./contentype.js"
+import { Uint8 } from "./dep.ts";
+
 
 /**
  * Represents TLS 1.3 Handshake message types as defined in RFC 8446 Section 4
@@ -101,51 +101,9 @@ export class HandshakeType extends Enum {
    /**return 8 */
    get bit() { return 8 }
    get length() { return 1 }
-
-   handshake(message) {
-      return Handshake.fromMessage(this, message)
-   }
-
    get Uint8() { return Uint8.fromValue(+this) }
    get byte() { return this.Uint8 }
 }
 
-export class Handshake extends Uint8Array {
-   msg_type
-   message
-   static fromMessage(msg_type, message) {
-      return new Handshake(msg_type, message)
-   }
-   static from(array) {
-      const copy = Uint8Array.from(array)
-      const msg_type = HandshakeType.fromValue(copy[0]);
-      const lengthOf = Uint24.from(copy.subarray(1)).value;
-      const message = copy.subarray(4, 4 + lengthOf)
-      return new Handshake(msg_type, message)
-   }
-   constructor(msg_type, message) {
-      const struct = new Struct(msg_type.Uint8, Uint24.fromValue(message.length), message)
-      super(struct)
-      this.msg_type = msg_type;
-      this.message = message
-      this.items = struct.items
-   }
-   get byte() { return Uint8Array.from(this) }
-   tlsInnerPlaintext(numZeros) {
-      return ContentType.APPLICATION_DATA.tlsInnerPlaintext(this, numZeros)
-   }
-}
-
-export class EndOfEarlyData extends Uint8Array {
-   static fromHandshake(array) {
-      const type = HandshakeType.fromValue(array.at(0));
-      if (type !== HandshakeType.END_OF_EARLY_DATA) return TypeError(`Expected ${HandshakeType.END_OF_EARLY_DATA.name}`)
-      return new EndOfEarlyData
-   }
-   constructor() {
-      super()
-   }
-   get handshake() { return HandshakeType.END_OF_EARLY_DATA.handshake(this) }
-}
 
 // npx -p typescript tsc ./src/handshaketype.js --declaration --allowJs --emitDeclarationOnly --lib ESNext --outDir ./dist

test/handshaketype_test.js

@@ -1,4 +1,4 @@
-import { HandshakeType, EndOfEarlyData } from "../src/handshaketype.js";
+import { HandshakeType } from "../src/handshaketype.js";
 
 console.log(HandshakeType.CLIENT_HELLO);
 console.log(HandshakeType.CLIENT_HELLO)
@@ -10,8 +10,6 @@ for (const e of codes) {
 }
 
 
-const eoData = new EndOfEarlyData;
-const eoDataHandshake = eoData.handshake;
 
 
 

type/handshaketype.d.ts

@@ -78,84 +78,10 @@ export declare class HandshakeType extends Enum {
    */
   get bit(): number;
 
-  /**
-   * Creates a `Handshake` object from this type and a message.
-   * @param message - The message associated with the handshake.
-   * @returns {Handshake}
-   */
-  handshake(message: Uint8Array): Handshake;
-
   /**
    * Returns the Uint8 representation of the handshake type.
    */
   get Uint8(): Uint8Array;
   get byte(): Uint8Array;
 }
 
-/**
- * Represents a TLS Handshake message.
- */
-export declare class Handshake extends Uint8Array {
-  /**
-   * The handshake message type.
-   */
-  readonly msg_type: HandshakeType;
-
-  /**
-   * The handshake message payload.
-   */
-  readonly message: Uint8Array;
-
-  /**
-   * Creates a `Handshake` object from a message type and payload.
-   * @param msg_type - The type of handshake message.
-   * @param message - The handshake message payload.
-   * @returns {Handshake}
-   */
-  static fromMessage(msg_type: HandshakeType, message: Uint8Array): Handshake;
-
-  /**
-   * Parses a `Handshake` object from a `Uint8Array`.
-   * @param array - The array containing the handshake message data.
-   * @returns {Handshake} The parsed Handshake object.
-   */
-  static from(array: Uint8Array): Handshake;
-
-  /**
-   * Creates a new `Handshake` object.
-   * @param msg_type - The handshake type.
-   * @param message - The handshake message payload.
-   */
-  constructor(msg_type: HandshakeType, message: Uint8Array);
-  /** return Uint8Array */
-  get byte(): Uint8Array
-
-  /**
-   * Generates TLS inner plaintext by processing the current context with specified padding.
-   * 
-   * @param {number} numZeros - The number of zero bytes to use as padding in the TLS inner plaintext.
-   * @returns {Uint8Array} The formatted TLS inner plaintext data.
-   */
-  tlsInnerPlaintext(numZeros: number): Uint8Array;
-}
-
-declare class EndOfEarlyData extends Uint8Array {
-  /**
-   * Creates an `EndOfEarlyData` instance from a handshake array.
-   * @param array - The array containing handshake data.
-   * @returns An `EndOfEarlyData` instance if the type matches,
-   * otherwise throws a `TypeError` with the expected type.
-   */
-  static fromHandshake(array: Uint8Array): EndOfEarlyData | TypeError;
-
-  /**
-   * Constructs an empty `EndOfEarlyData` instance.
-   */
-  constructor();
-
-  /**
-   * Processes and retrieves handshake information for the `EndOfEarlyData` instance.
-   * @returns The result of the handshake process.
-   */
-  get handshake(): Handshake;
-}