@helios-lang/effect 0.1.0

package/dist/Cbor.js

@@ -0,0 +1,1171 @@
+import { Data, Effect, Either } from "effect";
+import * as BigEndian from "./internal/BigEndian.js";
+import * as Bytes from "./internal/Bytes.js";
+import * as Float from "./internal/Float.js";
+import * as Utf8 from "./internal/Utf8.js";
+const FALSE_BYTE = 244; // m = 7, n = 20
+const TRUE_BYTE = 245; // m = 7, n = 21
+export class DecodeError extends Data.TaggedError("Cbor.DecodeError") {
+    constructor(_stream, message) {
+        super({ message: message });
+    }
+}
+/**
+ * Decodes a CBOR encoded `boolean`.
+ * Throws an error if the next element in bytes isn't a `boolean`.
+ * @param bytes
+ * @returns
+ */
+export const decodeBool = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const b = yield* stream.shiftOne();
+    if (b == TRUE_BYTE) {
+        return true;
+    }
+    else if (b == FALSE_BYTE) {
+        return false;
+    }
+    else {
+        return yield* new DecodeError(stream, "unexpected non-boolean cbor object");
+    }
+});
+/**
+ * Encodes a `boolean` into its CBOR representation.
+ * @param b
+ * @returns
+ */
+export function encodeBool(b) {
+    if (b) {
+        return [TRUE_BYTE];
+    }
+    else {
+        return [FALSE_BYTE];
+    }
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isBool = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == FALSE_BYTE || head == TRUE_BYTE));
+/**
+ * Unwraps a CBOR encoded list of bytes
+ * @param bytes
+ * cborbytes, mutated to form remaining
+ * @returns byteArray
+ */
+export const decodeBytes = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (yield* isIndefBytes(bytes)) {
+        yield* stream.shiftOne();
+        // multiple chunks
+        let res = [];
+        while ((yield* stream.peekOne()) != 255) {
+            const [, n] = yield* decodeDefHead(stream);
+            if (n > 64n) {
+                return yield* new DecodeError(stream, "Bytearray chunk too large");
+            }
+            res = res.concat(yield* stream.shiftMany(Number(n)));
+        }
+        if ((yield* stream.shiftOne()) != 255) {
+            throw new Error("invalid indef bytes termination byte");
+        }
+        return res;
+    }
+    else {
+        const [m, n] = yield* decodeDefHead(stream);
+        if (m != 2) {
+            return yield* new DecodeError(stream, "Invalid def bytes");
+        }
+        return yield* stream.shiftMany(Number(n));
+    }
+});
+/**
+ * Wraps a list of bytes using CBOR. Optionally splits the bytes into chunks.
+ * @example
+ * bytesToHex(Cbor.encodeBytes("4d01000033222220051200120011")) == "4e4d01000033222220051200120011"
+ * @param bytes
+ * @param splitIntoChunks
+ * @returns
+ * cbor bytes
+ */
+export function encodeBytes(bytes, splitIntoChunks = false) {
+    bytes = Bytes.toArray(bytes).slice();
+    if (bytes.length <= 64 || !splitIntoChunks) {
+        const head = encodeDefHead(2, BigInt(bytes.length));
+        return head.concat(bytes);
+    }
+    else {
+        let res = encodeIndefHead(2);
+        while (bytes.length > 0) {
+            const chunk = bytes.splice(0, 64);
+            res = res.concat(encodeDefHead(2, BigInt(chunk.length))).concat(chunk);
+        }
+        res.push(255);
+        return res;
+    }
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isBytes = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 2));
+/**
+ * @param bytes
+ * @returns
+ */
+export const isDefBytes = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const m = yield* peekMajorType(stream);
+    return m == 2 && (yield* stream.peekOne()) != 2 * 32 + 31;
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const isIndefBytes = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == 2 * 32 + 31));
+/**
+ * The homogenous field type case is used by the uplc ConstrData (undetermined number of UplcData items)
+ * @template Decoders
+ * Note: the conditional tuple check loses the tupleness if we just check against array, hence first we check against a tuple, and then an array (needed for the empty case)
+ * @param fieldDecoder
+ * Array for heterogenous item types, single function for homogenous item types
+ * @returns
+ */
+export const decodeConstr = (fieldDecoder) => (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const tag = yield* decodeConstrTag(stream);
+    const res = yield* decodeList((itemStream, i) => Effect.gen(function* () {
+        if (Array.isArray(fieldDecoder)) {
+            const decoder = fieldDecoder[i];
+            if (decoder === undefined) {
+                return yield* new DecodeError(stream, `expected ${fieldDecoder.length} fields, got more than ${i}`);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return yield* decoder(itemStream);
+        }
+        else {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return yield* fieldDecoder(itemStream);
+        }
+    }))(stream);
+    if (Array.isArray(fieldDecoder)) {
+        if (res.length < fieldDecoder.length) {
+            return yield* new DecodeError(stream, `expected ${fieldDecoder.length} fields, only got ${res.length}`);
+        }
+    }
+    return [tag, res];
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeConstrLazy = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const tag = yield* decodeConstrTag(stream);
+    const decodeField = yield* decodeListLazy(bytes);
+    return [tag, decodeField];
+});
+/**
+ * @param bytes
+ * @returns
+ */
+const decodeConstrTag = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    // constr
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m != 6) {
+        return yield* new DecodeError(stream, "Unexpected constr tag head");
+    }
+    if (n < 102n) {
+        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+    }
+    else if (n == 102n) {
+        const [mCheck, nCheck] = yield* decodeDefHead(stream);
+        if (mCheck != 4 || nCheck != 2n) {
+            return yield* new DecodeError(stream, "Unexpected constr tag nested head");
+        }
+        return Number(yield* decodeInt(stream));
+    }
+    else if (n < 121n) {
+        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+    }
+    else if (n <= 127n) {
+        return Number(n - 121n);
+    }
+    else if (n < 1280n) {
+        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+    }
+    else if (n <= 1400n) {
+        return Number(n - 1280n + 7n);
+    }
+    else {
+        return yield* new DecodeError(stream, `unexpected encoded constr tag ${n}`);
+    }
+});
+/**
+ * Note: internally the indef list format is used if the number of fields is > 0, if the number of fields is 0 the def list format is used
+ *   see [well-typed/cborg/serialise/src/Codec/Serialise/Class.hs](https://github.com/well-typed/cborg/blob/4bdc818a1f0b35f38bc118a87944630043b58384/serialise/src/Codec/Serialise/Class.hs#L181).
+ * @param tag
+ * @param fields
+ * @returns
+ */
+export function encodeConstr(tag, fields) {
+    return encodeConstrTag(tag).concat(encodeList(fields));
+}
+/**
+ * Encode a constructor tag of a ConstrData type
+ * @param tag
+ * @returns
+ * @throws
+ * If the tag is negative or not a whole number
+ */
+function encodeConstrTag(tag) {
+    if (tag < 0 || tag % 1.0 != 0.0) {
+        throw new Error("invalid tag");
+    }
+    else if (tag >= 0 && tag <= 6) {
+        return encodeDefHead(6, 121n + BigInt(tag));
+    }
+    else if (tag >= 7 && tag <= 127) {
+        return encodeDefHead(6, 1280n + BigInt(tag - 7));
+    }
+    else {
+        return encodeDefHead(6, 102n)
+            .concat(encodeDefHead(4, 2n))
+            .concat(encodeInt(BigInt(tag)));
+    }
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isConstr = (bytes) => decodeDefHead(Bytes.makeStream(bytes).copy()).pipe(Effect.map(([m, n]) => {
+    if (m == 6) {
+        return (n == 102n || (n >= 121n && n <= 127n) || (n >= 1280n && n <= 1400n));
+    }
+    else {
+        return false;
+    }
+}), Effect.catchTag("Cbor.DecodeError", () => {
+    return Effect.succeed(false);
+}));
+const FLOAT16_HEAD = 249;
+const FLOAT32_HEAD = 250;
+const FLOAT64_HEAD = 251;
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeFloat = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const head = yield* stream.shiftOne();
+    switch (head) {
+        case FLOAT16_HEAD:
+            return yield* Either.mapLeft(Float.decodeFloat16(yield* stream.shiftMany(2)), (e) => new DecodeError(stream, `failed to decode float16 (${e.message})`));
+        case FLOAT32_HEAD:
+            return yield* Either.mapLeft(Float.decodeFloat32(yield* stream.shiftMany(4)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
+        case FLOAT64_HEAD:
+            return yield* Either.mapLeft(Float.decodeFloat64(yield* stream.shiftMany(8)), (e) => new DecodeError(stream, `faild to decode float64 (${e.message})`));
+        default:
+            return yield* new DecodeError(stream, "invalid float header");
+    }
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeFloat16 = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const head = yield* stream.shiftOne();
+    if (head != FLOAT16_HEAD) {
+        return yield* new DecodeError(stream, "invalid Float16 header");
+    }
+    return yield* Either.mapLeft(Float.decodeFloat16(yield* stream.shiftMany(2)), (e) => new DecodeError(stream, `failed to decode float16 (${e.message})`));
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeFloat32 = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const head = yield* stream.shiftOne();
+    if (head != FLOAT32_HEAD) {
+        return yield* new DecodeError(stream, "invalid Float32 header");
+    }
+    return yield* Either.mapLeft(Float.decodeFloat32(yield* stream.shiftMany(4)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeFloat64 = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const head = yield* stream.shiftOne();
+    if (head != FLOAT64_HEAD) {
+        return yield* new DecodeError(stream, "invalid Float64 header");
+    }
+    return yield* Either.mapLeft(Float.decodeFloat64(yield* stream.shiftMany(8)), (e) => new DecodeError(stream, `failed to decode float32 (${e.message})`));
+});
+/**
+ * @param f
+ * @returns
+ */
+export function encodeFloat16(f) {
+    return [FLOAT16_HEAD].concat(Float.encodeFloat16(f));
+}
+/**
+ * @param f
+ * @returns
+ */
+export function encodeFloat32(f) {
+    return [FLOAT32_HEAD].concat(Float.encodeFloat32(f));
+}
+/**
+ * @param f
+ * @returns
+ */
+export function encodeFloat64(f) {
+    return [FLOAT64_HEAD].concat(Float.encodeFloat64(f));
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isFloat = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == FLOAT16_HEAD || head == FLOAT32_HEAD || head == FLOAT64_HEAD));
+/**
+ * @param bytes
+ * @returns
+ */
+export const isFloat16 = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == FLOAT16_HEAD));
+/**
+ * @param bytes
+ * @returns
+ */
+export const isFloat32 = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == FLOAT32_HEAD));
+/**
+ * @param bytes
+ * @returns
+ */
+export const isFloat64 = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == FLOAT64_HEAD));
+/**
+ * @param b0
+ * @returns
+ */
+function decodeFirstHeadByte(b0) {
+    const m = Math.trunc(b0 / 32);
+    const n0 = b0 % 32;
+    return [m, n0];
+}
+/**
+ * @param bytes
+ * @returns
+ * [majorType, n]
+ */
+export const decodeDefHead = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (stream.isAtEnd()) {
+        return yield* new DecodeError(stream, "Empty CBOR head");
+    }
+    const first = yield* stream.shiftOne();
+    const [m, n0] = decodeFirstHeadByte(first);
+    if (n0 <= 23) {
+        return [m, BigInt(n0)];
+    }
+    else if (n0 == 24) {
+        const l = yield* decodeIntInternal(stream, 1);
+        return [m, l];
+    }
+    else if (n0 == 25) {
+        if (m == 7) {
+            return yield* new DecodeError(stream, "Unexpected float16 (hint: decode float16 by calling decodeFloat16 directly)");
+        }
+        const n = yield* decodeIntInternal(stream, 2);
+        return [m, n];
+    }
+    else if (n0 == 26) {
+        if (m == 7) {
+            return yield* new DecodeError(stream, "Unexpected float32 (hint: decode float32 by calling decodeFloat32 directly)");
+        }
+        return [m, yield* decodeIntInternal(stream, 4)];
+    }
+    else if (n0 == 27) {
+        if (m == 7) {
+            return yield* new DecodeError(stream, "Unexpected float64 (hint: decode float64 by calling decodeFloat64 directly)");
+        }
+        return [m, yield* decodeIntInternal(stream, 8)];
+    }
+    else if ((m == 2 || m == 3 || m == 4 || m == 5 || m == 7) && n0 == 31) {
+        // head value 31 is used an indefinite length marker for 2,3,4,5,7 (never for 0,1,6)
+        return yield* new DecodeError(stream, `Unexpected header m=${m} n0=${n0} (expected def instead of indef)`);
+    }
+    else {
+        return yield* new DecodeError(stream, "Bad CBOR header");
+    }
+});
+/**
+ * @param m major type
+ * @param n size parameter
+ * @returns uint8 bytes
+ * @throws
+ * If n is out of range (i.e. very very large)
+ */
+export function encodeDefHead(m, n) {
+    if (n <= 23n) {
+        return [32 * m + Number(n)];
+    }
+    else if (n >= 24n && n <= 255n) {
+        return [32 * m + 24, Number(n)];
+    }
+    else if (n >= 256n && n <= 256n * 256n - 1n) {
+        return [
+            32 * m + 25,
+            Number((BigInt(n) / 256n) % 256n),
+            Number(BigInt(n) % 256n)
+        ];
+    }
+    else if (n >= 256n * 256n && n <= 256n * 256n * 256n * 256n - 1n) {
+        const e4 = BigEndian.encode(n);
+        while (e4.length < 4) {
+            e4.unshift(0);
+        }
+        return [32 * m + 26].concat(e4);
+    }
+    else if (n >= 256n * 256n * 256n * 256n &&
+        n <= 256n * 256n * 256n * 256n * 256n * 256n * 256n * 256n - 1n) {
+        const e8 = BigEndian.encode(n);
+        while (e8.length < 8) {
+            e8.unshift(0);
+        }
+        return [32 * m + 27].concat(e8);
+    }
+    else {
+        throw new Error("n out of range");
+    }
+}
+/**
+ * @param m
+ * @returns
+ */
+export function encodeIndefHead(m) {
+    return [32 * m + 31];
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const peekMajorType = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => Math.trunc(head / 32)));
+/**
+ * @param bytes
+ * @returns
+ */
+export const peekMajorAndSimpleMinorType = (bytes) => Bytes.makeStream(bytes).peekOne().pipe(Effect.map(decodeFirstHeadByte));
+/**
+ * Decodes a CBOR encoded bigint integer.
+ * @param bytes
+ * @returns
+ */
+export const decodeInt = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m == 0) {
+        return n;
+    }
+    else if (m == 1) {
+        return -n - 1n;
+    }
+    else if (m == 6) {
+        if (n == 2n) {
+            return yield* decodeIntInternal(stream);
+        }
+        else if (n == 3n) {
+            return -(yield* decodeIntInternal(stream)) - 1n;
+        }
+        else {
+            return yield* new DecodeError(stream, `Unexpected tag m:${m}`);
+        }
+    }
+    else {
+        return yield* new DecodeError(stream, `Unexpected tag m:${m}`);
+    }
+});
+const decodeIntInternal = (stream, nBytes = undefined) => {
+    return (nBytes === undefined ? decodeBytes(stream) : stream.shiftMany(nBytes)).pipe(Effect.map(BigEndian.decode), Effect.flatMap((result) => {
+        if (result._tag == "Left") {
+            return Effect.fail(new DecodeError(stream, `failed to decode BigEndian int (${result.left.message})`));
+        }
+        else {
+            return Effect.succeed(result.right);
+        }
+    }));
+};
+/**
+ * Encodes a bigint integer using CBOR.
+ * @param n
+ * @returns
+ */
+export function encodeInt(n) {
+    if (typeof n == "number") {
+        return encodeInt(BigInt(n));
+    }
+    else if (n >= 0n && n <= (2n << 63n) - 1n) {
+        return encodeDefHead(0, n);
+    }
+    else if (n >= 2n << 63n) {
+        return encodeDefHead(6, 2).concat(encodeBytes(BigEndian.encode(n)));
+    }
+    else if (n <= -1n && n >= -(2n << 63n)) {
+        return encodeDefHead(1, -n - 1n);
+    }
+    else {
+        return encodeDefHead(6, 3).concat(encodeBytes(BigEndian.encode(-n - 1n)));
+    }
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isInt = (bytes) => peekMajorAndSimpleMinorType(bytes).pipe(Effect.map(([m, n0]) => {
+    if (m == 0 || m == 1) {
+        return true;
+    }
+    else if (m == 6) {
+        return n0 == 2 || n0 == 3;
+    }
+    else {
+        return false;
+    }
+}));
+/**
+ * Decodes a CBOR encoded list.
+ * A decoder function is called with the bytes of every contained item (nothing is returning directly).
+ * @template T
+ * @param itemDecoder
+ * @returns
+ */
+export const decodeList = (itemDecoder) => (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const res = [];
+    if (yield* isIndefList(stream)) {
+        yield* stream.shiftOne();
+        let i = 0;
+        while ((yield* stream.peekOne()) != 255) {
+            res.push(yield* itemDecoder(stream, i));
+            i++;
+        }
+        const last = yield* stream.shiftOne();
+        if (last != 255) {
+            return yield* new DecodeError(stream, "Invalid def list head byte");
+        }
+    }
+    else {
+        const [m, n] = yield* decodeDefHead(stream);
+        if (m != 4) {
+            return yield* new DecodeError(stream, "invalid def list head byte");
+        }
+        for (let i = 0; i < Number(n); i++) {
+            res.push(yield* itemDecoder(stream, i));
+        }
+    }
+    return res;
+});
+/**
+ * @param bytes
+ * @returns
+ *
+ *
+ */
+export const decodeListLazy = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    let i = 0;
+    let done = false;
+    let checkDone;
+    if (yield* isIndefList(stream)) {
+        yield* stream.shiftOne();
+        checkDone = () => Effect.gen(function* () {
+            if ((yield* stream.peekOne()) == 255) {
+                yield* stream.shiftOne();
+                done = true;
+            }
+        });
+    }
+    else {
+        const [m, n] = yield* decodeDefHead(stream);
+        if (m != 4) {
+            return yield* new DecodeError(stream, "Unexpected header major type");
+        }
+        checkDone = () => {
+            if (i >= n) {
+                done = true;
+            }
+            return Effect.void;
+        };
+    }
+    yield* checkDone();
+    const decodeItem = (itemDecoder) => Effect.gen(function* () {
+        if (done) {
+            return yield* new DecodeError(stream, "end-of-list");
+        }
+        const res = yield* itemDecoder(stream, i);
+        i++;
+        yield* checkDone();
+        return res;
+    });
+    return decodeItem;
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeListLazyOption = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    let i = 0;
+    let done = false;
+    let checkDone;
+    if (yield* isIndefList(stream)) {
+        yield* stream.shiftOne();
+        checkDone = () => Effect.gen(function* () {
+            if ((yield* stream.peekOne()) == 255) {
+                yield* stream.shiftOne();
+                done = true;
+            }
+        });
+    }
+    else {
+        const [m, n] = yield* decodeDefHead(stream);
+        if (m != 4) {
+            return yield* new DecodeError(stream, "Unexpected major type for list");
+        }
+        checkDone = () => {
+            if (i >= n) {
+                done = true;
+            }
+            return Effect.void;
+        };
+    }
+    yield* checkDone();
+    const decodeItem = (itemDecoder) => Effect.gen(function* () {
+        if (done) {
+            return undefined;
+        }
+        const res = yield* itemDecoder(stream, i);
+        i++;
+        yield* checkDone();
+        return res;
+    });
+    return decodeItem;
+});
+/**
+ * This follows the serialization format that the Haskell input-output-hk/plutus UPLC evaluator (i.e. empty lists use `encodeDefList`, non-empty lists use `encodeIndefList`).
+ * See [well-typed/cborg/serialise/src/Codec/Serialise/Class.hs](https://github.com/well-typed/cborg/blob/4bdc818a1f0b35f38bc118a87944630043b58384/serialise/src/Codec/Serialise/Class.hs#L181).
+ * @param items already encoded
+ * @returns
+ */
+export function encodeList(items) {
+    return items.length > 0 ? encodeIndefList(items) : encodeDefList(items);
+}
+/**
+ * @returns
+ */
+function encodeIndefListStart() {
+    return encodeIndefHead(4);
+}
+/**
+ * @param list
+ * @returns
+ */
+function encodeListInternal(list) {
+    /**
+     * @type {number[]}
+     */
+    let res = [];
+    for (const item of list) {
+        res = res.concat(item);
+    }
+    return res;
+}
+const INDEF_LIST_END = [255];
+/**
+ * Encodes a list of CBOR encodeable items using CBOR indefinite length encoding.
+ * @param list Each item is either already serialized.
+ * @returns
+ */
+export function encodeIndefList(list) {
+    return encodeIndefListStart()
+        .concat(encodeListInternal(list))
+        .concat(INDEF_LIST_END);
+}
+/**
+ * @param n
+ * @returns
+ */
+function encodeDefListStart(n) {
+    return encodeDefHead(4, n);
+}
+/**
+ * Encodes a list of CBOR encodeable items using CBOR definite length encoding
+ * (i.e. header bytes of the element represent the length of the list).
+ * @param items Each item is already serialized
+ * @returns
+ */
+export function encodeDefList(items) {
+    return encodeDefListStart(BigInt(items.length)).concat(encodeListInternal(items));
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isList = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 4));
+/**
+ * @param bytes
+ * @returns
+ */
+export const isDefList = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    return ((yield* peekMajorType(stream)) == 4 &&
+        (yield* stream.peekOne()) != 4 * 32 + 31);
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export const isIndefList = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == 4 * 32 + 31));
+/**
+ * Decodes a CBOR encoded map.
+ * Calls a decoder function for each key-value pair (nothing is returned directly).
+ *
+ * The decoder function is responsible for separating the key from the value,
+ * which are simply stored as consecutive CBOR elements.
+ * @param keyDecoder
+ * @param valueDecoder
+ * @returns
+ */
+export const decodeMap = (keyDecoder, valueDecoder) => (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (yield* isIndefMap(stream)) {
+        yield* stream.shiftOne();
+        return yield* decodeIndefMap(stream, keyDecoder, valueDecoder);
+    }
+    else {
+        const [m, n] = yield* decodeDefHead(stream);
+        if (m != 5) {
+            return yield* new DecodeError(stream, "invalid def map");
+        }
+        return yield* decodeDefMap(stream, Number(n), keyDecoder, valueDecoder);
+    }
+});
+/**
+ * Internal use only, header already decoded
+ * @param stream
+ * @param n
+ * @param keyDecoder
+ * @param valueDecoder
+ * @returns
+ */
+const decodeDefMap = (stream, n, keyDecoder, valueDecoder) => Effect.gen(function* () {
+    const res = [];
+    for (let i = 0; i < n; i++) {
+        res.push([yield* keyDecoder(stream), yield* valueDecoder(stream)]);
+    }
+    return res;
+});
+/**
+ * Used internally, head already decoded
+ * @template TKey
+ * @template TValue
+ * @param stream
+ * @param keyDecoder
+ * @param valueDecoder
+ * @returns
+ */
+const decodeIndefMap = (stream, keyDecoder, valueDecoder) => Effect.gen(function* () {
+    const res = [];
+    while ((yield* stream.peekOne()) != 255) {
+        res.push([yield* keyDecoder(stream), yield* valueDecoder(stream)]);
+    }
+    yield* stream.shiftOne();
+    return res;
+});
+/**
+ * Unlike lists, the default serialization format for maps seems to always be the defined format
+ * @param pairs already encoded
+ * @returns
+ */
+export function encodeMap(pairs) {
+    return encodeDefMap(pairs);
+}
+/**
+ * Encodes a list of key-value pairs.
+ * @param pairs
+ * Each key and each value is an already encoded list of CBOR bytes.
+ * @returns
+ */
+export function encodeDefMap(pairs) {
+    return encodeDefHead(5, BigInt(pairs.length)).concat(encodeMapInternal(pairs));
+}
+/**
+ * Encodes a list of key-value pairs using the length undefined format.
+ * @param pairs
+ * Each key and each value is an already encoded list of CBOR bytes.
+ * @returns
+ */
+export function encodeIndefMap(pairs) {
+    return encodeIndefHead(5).concat(encodeMapInternal(pairs)).concat([255]);
+}
+/**
+ * @param pairs already encoded
+ * @returns
+ */
+function encodeMapInternal(pairs) {
+    let res = [];
+    for (const pair of pairs) {
+        const key = pair[0];
+        const value = pair[1];
+        res = res.concat(key);
+        res = res.concat(value);
+    }
+    return res;
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isMap = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 5));
+/**
+ * @param bytes
+ * @returns
+ */
+const isIndefMap = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == 5 * 32 + 31));
+const NULL_BYTE = 246; // m = 7, n = 22
+/**
+ * Checks if next element in `bytes` is a `null`.
+ * Throws an error if it isn't.
+ * @param bytes
+ * @returns
+ */
+export const decodeNull = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const b = yield* stream.shiftOne();
+    if (b != NULL_BYTE) {
+        return yield* new DecodeError(stream, "not null");
+    }
+    return null;
+});
+/**
+ * Encode `null` into its CBOR representation.
+ * @param _null ignored
+ * @returns
+ */
+export function encodeNull(_null = null) {
+    return [NULL_BYTE];
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isNull = (bytes) => Bytes.makeStream(bytes)
+    .peekOne()
+    .pipe(Effect.map((head) => head == NULL_BYTE));
+/**
+ * Decodes a CBOR encoded object with integer keys.
+ * For each field a decoder is called which takes the field index and the field bytes as arguments.
+ * @template Decoders
+ * @param fieldDecoders
+ * @returns
+ */
+export const decodeObjectIKey = (fieldDecoders) => (bytes) => {
+    const stream = Bytes.makeStream(bytes);
+    const res = {};
+    return decodeMap(() => Effect.succeed(null), (pairStream) => Effect.gen(function* () {
+        const key = Number(yield* decodeInt(pairStream));
+        const decoder = fieldDecoders[key];
+        if (decoder === undefined) {
+            return yield* new DecodeError(pairStream, `unhandled object field ${key}`);
+        }
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
+        res[key] = yield* decoder(pairStream);
+        return Effect.void;
+    }))(stream).pipe(Effect.map(() => {
+        return res;
+    }));
+};
+/**
+ * Decodes a CBOR encoded object with string keys.
+ * For each field a decoder is called which takes the field index and the field bytes as arguments.
+ * @template Decoders
+ * @param fieldDecoders
+ * @returns
+ */
+export const decodeObjectSKey = (fieldDecoders) => (bytes) => {
+    const stream = Bytes.makeStream(bytes);
+    const res = {};
+    return decodeMap(() => Effect.succeed(null), (pairStream) => Effect.gen(function* () {
+        const key = yield* decodeString(pairStream);
+        const decoder = fieldDecoders[key];
+        if (decoder === undefined) {
+            return yield* new DecodeError(pairStream, `unhandled object field ${key}`);
+        }
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-assignment */
+        res[key] = yield* decoder(pairStream);
+        return Effect.void;
+    }))(stream).pipe(Effect.map(() => {
+        return res;
+    }));
+};
+/**
+ * Encodes an object with optional fields using integer keys.
+ * @param object
+ * A `Map` with integer keys representing the field indices.
+ * @returns
+ */
+export function encodeObjectIKey(object) {
+    const entries = object instanceof Map
+        ? Array.from(object.entries()).map((pair) => [
+            encodeInt(pair[0]),
+            pair[1]
+        ])
+        : Object.entries(object).map((pair) => [
+            encodeInt(parseInt(pair[0])),
+            pair[1]
+        ]);
+    return encodeDefMap(entries);
+}
+/**
+ * Encodes an object with optional fields using string keys.
+ * @param object
+ * A `Map` with string keys representing the field indices.
+ * @returns
+ */
+export function encodeObjectSKey(object) {
+    const entries = object instanceof Map
+        ? Array.from(object.entries()).map((pair) => [
+            encodeString(pair[0]),
+            pair[1]
+        ])
+        : Object.entries(object).map((pair) => [encodeString(pair[0]), pair[1]]);
+    return encodeDefMap(entries);
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isObject = (bytes) => isMap(bytes);
+const SET_TAG = 258n;
+/**
+ * Like a list, but with an optional 258 tag
+ * See: https://github.com/Emurgo/cardano-serialization-lib/releases/tag/13.0.0
+ * @template T
+ * @param itemDecoder
+ * @returns
+ */
+export const decodeSet = (itemDecoder) => (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (yield* isTag(stream)) {
+        const tag = yield* decodeTag(stream);
+        if (tag != SET_TAG) {
+            return yield* new DecodeError(stream, `expected tag ${SET_TAG} for set, got tag ${tag}`);
+        }
+    }
+    return yield* decodeList(itemDecoder)(stream);
+});
+/**
+ * A tagged def list (tag 258n)
+ * @param items
+ * @returns
+ */
+export function encodeSet(items) {
+    return encodeTag(SET_TAG).concat(encodeDefList(items));
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isSet = (bytes) => peekTag(bytes).pipe(Effect.map((t) => t == SET_TAG));
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeString = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (yield* isDefList(stream)) {
+        let result = "";
+        yield* decodeList((itemBytes) => decodeStringInternal(itemBytes).pipe(Effect.tap((s) => {
+            result += s;
+        })))(stream);
+        return result;
+    }
+    else {
+        return yield* decodeStringInternal(stream);
+    }
+});
+/**
+ * @param bytes
+ * @returns
+ */
+const decodeStringInternal = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m !== 3) {
+        return yield* new DecodeError(stream, "unexpected");
+    }
+    return yield* Utf8.decode(yield* stream.shiftMany(Number(n))).pipe(Effect.mapError((e) => new DecodeError(stream, `invalid utf8 (${e.message})`)));
+});
+/**
+ * Encodes a Utf8 string into Cbor bytes.
+ * Strings can be split into lists with chunks of up to 64 bytes
+ * to play nice with Cardano tx metadata constraints.
+ * @param str
+ * @param split
+ * @returns
+ */
+export function encodeString(str, split = false) {
+    const bytes = Bytes.toArray(Utf8.encode(str));
+    if (split && bytes.length > 64) {
+        const chunks = [];
+        let i = 0;
+        while (i < bytes.length) {
+            // We encode the largest chunk up to 64 bytes
+            // that is valid UTF-8
+            let maxChunkLength = 64;
+            let chunk;
+            while (true) {
+                chunk = bytes.slice(i, i + maxChunkLength);
+                if (Utf8.isValid(chunk)) {
+                    break;
+                }
+                maxChunkLength--;
+            }
+            chunks.push(encodeDefHead(3, BigInt(chunk.length)).concat(chunk));
+            i += chunk.length;
+        }
+        return encodeDefList(chunks);
+    }
+    else {
+        return encodeDefHead(3, BigInt(bytes.length)).concat(bytes);
+    }
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isString = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 3));
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeTag = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    const [m, n] = yield* decodeDefHead(stream);
+    if (m != 6) {
+        return yield* new DecodeError(stream, "unexpected major type for tag");
+    }
+    return n;
+});
+/**
+ * Unrelated to constructor
+ * @param tag
+ * @returns
+ */
+export function encodeTag(tag) {
+    if (typeof tag == "number") {
+        return encodeTag(BigInt(tag));
+    }
+    else if (tag < 0) {
+        throw new Error("can't encode negative tag");
+    }
+    return encodeDefHead(6, tag);
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export const isTag = (bytes) => peekMajorType(bytes).pipe(Effect.map((m) => m == 6));
+/**
+ * @param bytes
+ * @returns
+ */
+export const peekTag = (bytes) => decodeTag(Bytes.makeStream(bytes).copy()).pipe(Effect.catchTag("Cbor.DecodeError", () => Effect.succeed(undefined)));
+/**
+ * @param bytes
+ * @returns
+ */
+export const decodeTagged = (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    if (yield* isList(stream)) {
+        const decodeItem = yield* decodeListLazy(stream);
+        const tag = Number(yield* decodeItem(decodeInt));
+        return [tag, decodeItem];
+    }
+    else {
+        return yield* decodeConstrLazy(stream);
+    }
+});
+/**
+ * @template Decoders
+ * @template OptionalDecoders
+ * @param itemDecoders
+ * @param optionalDecoders
+ * Defaults to empty tuple
+ * @returns
+ */
+export const decodeTuple = (itemDecoders, optionalDecoders = []) => (bytes) => Effect.gen(function* () {
+    const stream = Bytes.makeStream(bytes);
+    /**
+     * decodeList is the right decoder, but has the wrong type interface
+     * Cast the result to `any` to avoid type errors
+     */
+    const res = yield* decodeList((itemStream, i) => Effect.gen(function* () {
+        let decoder = itemDecoders[i];
+        if (decoder === undefined) {
+            decoder = optionalDecoders[i - itemDecoders.length];
+            if (decoder === undefined) {
+                return yield* new DecodeError(itemStream, `expected at most ${itemDecoders.length + optionalDecoders.length} items, got more than ${i}`);
+            }
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return yield* decoder(itemStream);
+    }))(stream);
+    if (res.length < itemDecoders.length) {
+        return yield* new DecodeError(stream, `expected at least ${itemDecoders.length} items, only got ${res.length}`);
+    }
+    return res;
+});
+/**
+ * @param bytes
+ * @returns
+ */
+export function decodeTupleLazy(bytes) {
+    return decodeListLazy(bytes);
+}
+/**
+ * @param tuple
+ * @returns
+ */
+export function encodeTuple(tuple) {
+    return encodeDefList(tuple);
+}
+/**
+ * @param bytes
+ * @returns
+ */
+export function isTuple(bytes) {
+    return isList(bytes);
+}
+//# sourceMappingURL=Cbor.js.map