RFCからCBORのデコーダーを作る

export class Decoder {
  /**
   * CBOR列からJSのデータ構造に変換する関数
   * @param cborInputString {string} cbor文字列
   * 6161
   * 01
   * @example
   * const result = decode("6161")
   * // a
   * @throws CBOR文字列ではないときに例外を投げる
   */
  static decode(cborInputString: string): any {
    const cbor = toCBOR(cborInputString);
    const { majorType } = cbor;
    switch (majorType) {
      case 0:
        // 正の数
        return PositiveNumberDecoder.decode(cbor);
      case 1:
        // 負の数
        return NegativeNumberDecoder.decode(cbor);
      case 2:
        // Byte
        return Byte.decode(cbor);
      case 3:
        // 文字列
        return StringDecoder.decode(cbor);
      case 4:
        // 配列
        return ArrayDecoder.decode(cbor);
      case 5:
        // オブジェクト
        return ObjectDecoder.decode(cbor);
      case 6:
        // tag
        return Tag.decode(cbor);
      case 7:
        return PrimitiveDecoder.decode(cbor);
      default:
        throw new Error("Invalid CBOR Input");
    }
  }
}

export class ArrayDecoder {
  /**
   * 配列であることが保証されたCBOR文字列から配列を作る関数.
   *
   * @param cbor CBOR文字列.
   * ex) 820163E38182 = 82(array(2)) 01(1) 
   63(text(3byte)) E38182(あ) = [12, "あ"]
   * @param dataItemHeader CBOR文字列の先頭1byte. 
   major typeと追加情報が格納されている.
   */
  static decode(cbor: BaseCborType): any[] {
    const result: any[] = [];
    const definedToken = detectCborTypeFromBaseCbor(cbor);

    if (cbor.type === "tiny") {
      throw new Error("配列はshort or long. ");
    }
    switch (definedToken.type) {
      case "short": {
        // additinal infoに長さが入っており、次のbyte以降にデータ
        if (definedToken.additionalInformation > 23) {
          throw new Error("not tiny");
        }

        if (definedToken.additionalInformation === 0) {
          return [];
        }
        let eating = null;
        for (;;) {
          const eatResult = Decoder.decode(eating || definedToken.variable);
          eating = eatResult.restCborString;
          result.push(eatResult.decodeResult);
          if (!eatResult.restCborString) {
            // これ以上tokenがないなら抜ける
            break;
          }
        }

        if (result.length !== definedToken.additionalInformation) {
          throw new Error("additional informationと配列の数があってない");
        }

        return result;
      }

      case "long": {
        let eating_long = null;
        for (;;) {
          const eatResult = Decoder.decode(
            eating_long || definedToken.variable
          );
          eating_long = eatResult.restCborString;
          result.push(eatResult.decodeResult);
          if (eatResult.restCborString === null) {
            break;
          }
        }
        return result;
      }
    }
    throw new Error("ありえない");
  }
}

import {
  separateTokenFromCBOR,
  BaseCborType,
  detectCborTypeFromBaseCbor,
} from "../helper";

/**
 * 正の数のdecoder
 */
export class PositiveNumberDecoder {
  /**
   * 正の数であることが保証されたCBOR文字列からnumberを作る関数.
   *
   * @param cbor CBOR文字列.
   * @param dataItemHeader CBOR文字列の先頭1byte. 
   major typeと追加情報が格納されている.
   * @returns 正の数
   */
  static decode(cbor: BaseCborType): number {
    const definedToken = detectCborTypeFromBaseCbor(cbor);
    if (definedToken.additionalInformation < 24) {
      return definedToken.additionalInformation;
    } else {
      const separatedCborObject = separateTokenFromCBOR(definedToken.raw);
      if (!separatedCborObject.rest) {
        throw new Error("読み込む対象が存在しない");
      }
      const hexValue = separatedCborObject.rest;
      return parseInt(hexValue, 16);
    }
  }
}

/**
 * 文字列のdecoder
 */
export class StringDecoder {
  /**
   * 文字列であることが保証されたCBOR文字列から文字列を作る関数.
   *
   * @param cbor CBOR文字列. 
   utf-8形式でそのまま連結されている。マルチバイト文字もそのままくっついている.
   * ex) aあ => 6461E38182 (64(string2文字)
    61(a) E38182(あ))
   * @param dataItemHeader CBOR文字列の先頭1byte. major typeと追加情報が格納されている.
   */
  static decode(cbor: BaseCborType): string {
    const definedToken = detectCborTypeFromBaseCbor(cbor);
    switch (definedToken.type) {
      case "short": {
        const cborTokenArray = this.cborValueToArray(definedToken.variable);
        const URI = this.cborTokenArrayToURI(cborTokenArray);
        const decoded = decodeURIComponent(URI);
        const decodedByteLength = encodeURIComponent(decoded).replace(
          /%../g,
          "x"
        ).length;
        if (decodedByteLength !== definedToken.additionalInformation) {
          throw new Error("長さあってない");
        }
        return decoded;
      }
      case "long": {
        const cborTokenArray = this.cborValueToArray(definedToken.variable);
        const URI = this.cborTokenArrayToURI(cborTokenArray);
        const decoded = decodeURIComponent(URI);
        const decodedByteLength = encodeURIComponent(decoded).replace(
          /%../g,
          "x"
        ).length;
        if (decodedByteLength !== definedToken.payloadLength) {
          throw new Error("長さあってない");
        }
        return decoded;
      }
    }
    throw new Error("un reach");
  }
  /**
   * cbor文字列のvalue部分を配列に分割する関数.
   * @param cborValue
   * 入力文字列. E38182E38182E38182 などのように 
   0xE3 0x81 0x82 0xE3 0x81 0x82 と16進数表記の文字列が渡される
   *
   */
  private static cborValueToArray(cborValue: string): string[] {
    const res = [];
    let trimed = null;
    for (;;) {
      trimed = separateTokenFromCBOR(
        trimed ? trimed.rest || cborValue : cborValue
      );
      res.push(trimed.token);
      if (!trimed.rest) {
        break;
      }
    }
    return res;
  }

  /**
   * 16進数文字列の配列をURIに変換する関数
   * @param hexStringArray 16進数文字列の配列
   * ex) ["e3", "81", 82]
   */
  private static cborTokenArrayToURI(hexStringArray: string[]): string {
    const uri =
      "%" +
      hexStringArray.reduce((acc, value) => {
        return acc + "%" + value;
      });
    return uri;
  }
}

/**
 * 1byte(0-255)をdataItemHeaderに分解する。
 * @param input castすると16進数で表現できる文字列
 * @returns DataItemHeader
 */
export const hexToDateitemHeader = (input: number): DataItemHeader => {
  if (input < 0 || input > 255) {
    throw new Error("un expected input");
  }
  const majorType = (input >> 5) as MAJOR_TYPE_IDENTIFIER_TYPE;
  const additionalInformation = input & 0b00011111;
  if (!majorTypeIdentifiers.includes(majorType)) {
    throw new Error("unexpected major type");
  }
  return { majorType, additionalInformation };
};

const p = new Promise((resolve, reject) => {
  c.on("data", (val) => {
    console.log("data val", val);
    v = Decoder.nullcheck(val);
    c.close();
  });
  c.once("end", () => {
    switch (v) {
      case NOT_FOUND:
      default:
        console.log("dend");
        return resolve(v);
    }
  });
});
c.end(input, encod);
return p;

console.log(Decoder.decodeFirstSync("17"));
Decoder.decodeFirstSync("17").then((decoded) => console.log(decoded));

_transform(fresh, encoding, cb) {
    this.bs.write(fresh);

    while (this.bs.length >= this.__needed) {
      let ret;
      const chunk =
        this.__needed === null ? undefined : this.bs.read(this.__needed);

      try {
        ret = this.__parser.next(chunk);
      } catch (e) {
        return cb(e);
      }

      if (this.__needed) {
        this.__fresh = false;
      }

      if (!ret.done) {
        this.__needed = ret.value || 0;
      } else {
        this.push(ret.value);
        this.__restart();
      }
    }

    return cb();
  }

*_parse() {
    let parent = null;
    let depth = 0;
    let val = null;
    while (true) {
      const octet = (yield 1)[0];
      const mt = octet >> 5;
      const ai = octet & 0x1f;
      switch (ai) {
        case NUMBYTES.ONE:
          this.emit("more-bytes", mt, 1, parent_major, parent_length);
          val = (yield 1)[0];
          break;
        case NUMBYTES.TWO:
        case NUMBYTES.FOUR:
        case NUMBYTES.EIGHT:
          const numbytes = 1 << (ai - 24);
          this.emit("more-bytes", mt, numbytes, parent_major, parent_length);
          const buf = yield numbytes;
          val = mt === MT.SIMPLE_FLOAT ? buf : utils.parseCBORint(ai, buf);
          break;
        case 28:
        case 29:
        case 30:
          this.running = false;
          throw new Error("Additional info not implemented: " + ai);
        case NUMBYTES.INDEFINITE:
          switch (mt) {
            case MT.POS_INT:
            case MT.NEG_INT:
            case MT.TAG:
              throw new Error(`Invalid indefinite encoding for MT ${mt}`);
          }
          val = -1;
          break;
        default:
          val = ai;
      }
      ...
    }
  }

const parser = c._parse();
let state = parser.next();
while (!state.done) {
  const b = s.read(state.value);
  if (b == null || b.length !== state.value) {
    throw new Error("Insufficient data");
  }
  state = parser.next(b);
}