@kubb/agent 4.29.1 → 4.31.0

package/.output/server/node_modules/@msgpack/msgpack/dist/Encoder.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Encoder = exports.DEFAULT_INITIAL_BUFFER_SIZE = exports.DEFAULT_MAX_DEPTH = void 0;
+const utf8_1 = require("./utils/utf8");
+const ExtensionCodec_1 = require("./ExtensionCodec");
+const int_1 = require("./utils/int");
+const typedArrays_1 = require("./utils/typedArrays");
+exports.DEFAULT_MAX_DEPTH = 100;
+exports.DEFAULT_INITIAL_BUFFER_SIZE = 2048;
+class Encoder {
+    constructor(extensionCodec = ExtensionCodec_1.ExtensionCodec.defaultCodec, context = undefined, maxDepth = exports.DEFAULT_MAX_DEPTH, initialBufferSize = exports.DEFAULT_INITIAL_BUFFER_SIZE, sortKeys = false, forceFloat32 = false, ignoreUndefined = false, forceIntegerToFloat = false) {
+        this.extensionCodec = extensionCodec;
+        this.context = context;
+        this.maxDepth = maxDepth;
+        this.initialBufferSize = initialBufferSize;
+        this.sortKeys = sortKeys;
+        this.forceFloat32 = forceFloat32;
+        this.ignoreUndefined = ignoreUndefined;
+        this.forceIntegerToFloat = forceIntegerToFloat;
+        this.pos = 0;
+        this.view = new DataView(new ArrayBuffer(this.initialBufferSize));
+        this.bytes = new Uint8Array(this.view.buffer);
+    }
+    reinitializeState() {
+        this.pos = 0;
+    }
+    /**
+     * This is almost equivalent to {@link Encoder#encode}, but it returns an reference of the encoder's internal buffer and thus much faster than {@link Encoder#encode}.
+     *
+     * @returns Encodes the object and returns a shared reference the encoder's internal buffer.
+     */
+    encodeSharedRef(object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.subarray(0, this.pos);
+    }
+    /**
+     * @returns Encodes the object and returns a copy of the encoder's internal buffer.
+     */
+    encode(object) {
+        this.reinitializeState();
+        this.doEncode(object, 1);
+        return this.bytes.slice(0, this.pos);
+    }
+    doEncode(object, depth) {
+        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);
+        }
+    }
+    ensureBufferSizeToWrite(sizeToWrite) {
+        const requiredSize = this.pos + sizeToWrite;
+        if (this.view.byteLength < requiredSize) {
+            this.resizeBuffer(requiredSize * 2);
+        }
+    }
+    resizeBuffer(newSize) {
+        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;
+    }
+    encodeNil() {
+        this.writeU8(0xc0);
+    }
+    encodeBoolean(object) {
+        if (object === false) {
+            this.writeU8(0xc2);
+        }
+        else {
+            this.writeU8(0xc3);
+        }
+    }
+    encodeNumber(object) {
+        if (Number.isSafeInteger(object) && !this.forceIntegerToFloat) {
+            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) {
+                    // negative 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);
+            }
+        }
+    }
+    writeStringHeader(byteLength) {
+        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`);
+        }
+    }
+    encodeString(object) {
+        const maxHeaderSize = 1 + 4;
+        const strLength = object.length;
+        if (strLength > utf8_1.TEXT_ENCODER_THRESHOLD) {
+            const byteLength = (0, utf8_1.utf8Count)(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            (0, utf8_1.utf8EncodeTE)(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+        else {
+            const byteLength = (0, utf8_1.utf8Count)(object);
+            this.ensureBufferSizeToWrite(maxHeaderSize + byteLength);
+            this.writeStringHeader(byteLength);
+            (0, utf8_1.utf8EncodeJs)(object, this.bytes, this.pos);
+            this.pos += byteLength;
+        }
+    }
+    encodeObject(object, depth) {
+        // 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, depth);
+        }
+        else {
+            // symbol, function and other special object come here unless extensionCodec handles them.
+            throw new Error(`Unrecognized object: ${Object.prototype.toString.apply(object)}`);
+        }
+    }
+    encodeBinary(object) {
+        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 = (0, typedArrays_1.ensureUint8Array)(object);
+        this.writeU8a(bytes);
+    }
+    encodeArray(object, depth) {
+        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);
+        }
+    }
+    countWithoutUndefined(object, keys) {
+        let count = 0;
+        for (const key of keys) {
+            if (object[key] !== undefined) {
+                count++;
+            }
+        }
+        return count;
+    }
+    encodeMap(object, depth) {
+        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);
+            }
+        }
+    }
+    encodeExtension(ext) {
+        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);
+    }
+    writeU8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setUint8(this.pos, value);
+        this.pos++;
+    }
+    writeU8a(values) {
+        const size = values.length;
+        this.ensureBufferSizeToWrite(size);
+        this.bytes.set(values, this.pos);
+        this.pos += size;
+    }
+    writeI8(value) {
+        this.ensureBufferSizeToWrite(1);
+        this.view.setInt8(this.pos, value);
+        this.pos++;
+    }
+    writeU16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setUint16(this.pos, value);
+        this.pos += 2;
+    }
+    writeI16(value) {
+        this.ensureBufferSizeToWrite(2);
+        this.view.setInt16(this.pos, value);
+        this.pos += 2;
+    }
+    writeU32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setUint32(this.pos, value);
+        this.pos += 4;
+    }
+    writeI32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setInt32(this.pos, value);
+        this.pos += 4;
+    }
+    writeF32(value) {
+        this.ensureBufferSizeToWrite(4);
+        this.view.setFloat32(this.pos, value);
+        this.pos += 4;
+    }
+    writeF64(value) {
+        this.ensureBufferSizeToWrite(8);
+        this.view.setFloat64(this.pos, value);
+        this.pos += 8;
+    }
+    writeU64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_1.setUint64)(this.view, this.pos, value);
+        this.pos += 8;
+    }
+    writeI64(value) {
+        this.ensureBufferSizeToWrite(8);
+        (0, int_1.setInt64)(this.view, this.pos, value);
+        this.pos += 8;
+    }
+}
+exports.Encoder = Encoder;
+//# sourceMappingURL=Encoder.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/ExtData.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtData = void 0;
+/**
+ * ExtData is used to handle Extension Types that are not registered to ExtensionCodec.
+ */
+class ExtData {
+    constructor(type, data) {
+        this.type = type;
+        this.data = data;
+    }
+}
+exports.ExtData = ExtData;
+//# sourceMappingURL=ExtData.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/ExtensionCodec.js

@@ -0,0 +1,72 @@
+"use strict";
+// ExtensionCodec to handle MessagePack extensions
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtensionCodec = void 0;
+const ExtData_1 = require("./ExtData");
+const timestamp_1 = require("./timestamp");
+class ExtensionCodec {
+    constructor() {
+        // built-in extensions
+        this.builtInEncoders = [];
+        this.builtInDecoders = [];
+        // custom extensions
+        this.encoders = [];
+        this.decoders = [];
+        this.register(timestamp_1.timestampExtension);
+    }
+    register({ type, encode, decode, }) {
+        if (type >= 0) {
+            // custom extensions
+            this.encoders[type] = encode;
+            this.decoders[type] = decode;
+        }
+        else {
+            // built-in extensions
+            const index = 1 + type;
+            this.builtInEncoders[index] = encode;
+            this.builtInDecoders[index] = decode;
+        }
+    }
+    tryToEncode(object, context) {
+        // built-in extensions
+        for (let i = 0; i < this.builtInEncoders.length; i++) {
+            const encodeExt = this.builtInEncoders[i];
+            if (encodeExt != null) {
+                const data = encodeExt(object, context);
+                if (data != null) {
+                    const type = -1 - i;
+                    return new ExtData_1.ExtData(type, data);
+                }
+            }
+        }
+        // custom extensions
+        for (let i = 0; i < this.encoders.length; i++) {
+            const encodeExt = this.encoders[i];
+            if (encodeExt != null) {
+                const data = encodeExt(object, context);
+                if (data != null) {
+                    const type = i;
+                    return new ExtData_1.ExtData(type, data);
+                }
+            }
+        }
+        if (object instanceof ExtData_1.ExtData) {
+            // to keep ExtData as is
+            return object;
+        }
+        return null;
+    }
+    decode(data, type, context) {
+        const decodeExt = type < 0 ? this.builtInDecoders[-1 - type] : this.decoders[type];
+        if (decodeExt) {
+            return decodeExt(data, type, context);
+        }
+        else {
+            // decode() does not fail, returns ExtData instead.
+            return new ExtData_1.ExtData(type, data);
+        }
+    }
+}
+exports.ExtensionCodec = ExtensionCodec;
+ExtensionCodec.defaultCodec = new ExtensionCodec();
+//# sourceMappingURL=ExtensionCodec.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/decode.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeMulti = exports.decode = exports.defaultDecodeOptions = void 0;
+const Decoder_1 = require("./Decoder");
+exports.defaultDecodeOptions = {};
+/**
+ * It decodes a single MessagePack object in a buffer.
+ *
+ * This is a synchronous decoding function.
+ * See other variants for asynchronous decoding: {@link decodeAsync()}, {@link decodeStream()}, or {@link decodeArrayStream()}.
+ *
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decode(buffer, options = exports.defaultDecodeOptions) {
+    const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decode(buffer);
+}
+exports.decode = decode;
+/**
+ * It decodes multiple MessagePack objects in a buffer.
+ * This is corresponding to {@link decodeMultiStream()}.
+ *
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decodeMulti(buffer, options = exports.defaultDecodeOptions) {
+    const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decodeMulti(buffer);
+}
+exports.decodeMulti = decodeMulti;
+//# sourceMappingURL=decode.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/decodeAsync.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeStream = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = void 0;
+const Decoder_1 = require("./Decoder");
+const stream_1 = require("./utils/stream");
+const decode_1 = require("./decode");
+/**
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+async function decodeAsync(streamLike, options = decode_1.defaultDecodeOptions) {
+    const stream = (0, stream_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decodeAsync(stream);
+}
+exports.decodeAsync = decodeAsync;
+/**
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decodeArrayStream(streamLike, options = decode_1.defaultDecodeOptions) {
+    const stream = (0, stream_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decodeArrayStream(stream);
+}
+exports.decodeArrayStream = decodeArrayStream;
+/**
+ * @throws {@link RangeError} if the buffer is incomplete, including the case where the buffer is empty.
+ * @throws {@link DecodeError} if the buffer contains invalid data.
+ */
+function decodeMultiStream(streamLike, options = decode_1.defaultDecodeOptions) {
+    const stream = (0, stream_1.ensureAsyncIterable)(streamLike);
+    const decoder = new Decoder_1.Decoder(options.extensionCodec, options.context, options.maxStrLength, options.maxBinLength, options.maxArrayLength, options.maxMapLength, options.maxExtLength);
+    return decoder.decodeStream(stream);
+}
+exports.decodeMultiStream = decodeMultiStream;
+/**
+ * @deprecated Use {@link decodeMultiStream()} instead.
+ */
+function decodeStream(streamLike, options = decode_1.defaultDecodeOptions) {
+    return decodeMultiStream(streamLike, options);
+}
+exports.decodeStream = decodeStream;
+//# sourceMappingURL=decodeAsync.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/encode.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encode = void 0;
+const Encoder_1 = require("./Encoder");
+const defaultEncodeOptions = {};
+/**
+ * It encodes `value` in the MessagePack format and
+ * returns a byte buffer.
+ *
+ * The returned buffer is a slice of a larger `ArrayBuffer`, so you have to use its `#byteOffset` and `#byteLength` in order to convert it to another typed arrays including NodeJS `Buffer`.
+ */
+function encode(value, options = defaultEncodeOptions) {
+    const encoder = new Encoder_1.Encoder(options.extensionCodec, options.context, options.maxDepth, options.initialBufferSize, options.sortKeys, options.forceFloat32, options.ignoreUndefined, options.forceIntegerToFloat);
+    return encoder.encodeSharedRef(value);
+}
+exports.encode = encode;
+//# sourceMappingURL=encode.js.map

package/.output/server/node_modules/@msgpack/msgpack/dist/index.js

@@ -0,0 +1,34 @@
+"use strict";
+// Main Functions:
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeTimestampExtension = exports.encodeTimestampExtension = exports.decodeTimestampToTimeSpec = exports.encodeTimeSpecToTimestamp = exports.encodeDateToTimeSpec = exports.EXT_TIMESTAMP = exports.ExtData = exports.ExtensionCodec = exports.Encoder = exports.DataViewIndexOutOfBoundsError = exports.DecodeError = exports.Decoder = exports.decodeStream = exports.decodeMultiStream = exports.decodeArrayStream = exports.decodeAsync = exports.decodeMulti = exports.decode = exports.encode = void 0;
+const encode_1 = require("./encode");
+Object.defineProperty(exports, "encode", { enumerable: true, get: function () { return encode_1.encode; } });
+const decode_1 = require("./decode");
+Object.defineProperty(exports, "decode", { enumerable: true, get: function () { return decode_1.decode; } });
+Object.defineProperty(exports, "decodeMulti", { enumerable: true, get: function () { return decode_1.decodeMulti; } });
+const decodeAsync_1 = require("./decodeAsync");
+Object.defineProperty(exports, "decodeAsync", { enumerable: true, get: function () { return decodeAsync_1.decodeAsync; } });
+Object.defineProperty(exports, "decodeArrayStream", { enumerable: true, get: function () { return decodeAsync_1.decodeArrayStream; } });
+Object.defineProperty(exports, "decodeMultiStream", { enumerable: true, get: function () { return decodeAsync_1.decodeMultiStream; } });
+Object.defineProperty(exports, "decodeStream", { enumerable: true, get: function () { return decodeAsync_1.decodeStream; } });
+const Decoder_1 = require("./Decoder");
+Object.defineProperty(exports, "Decoder", { enumerable: true, get: function () { return Decoder_1.Decoder; } });
+Object.defineProperty(exports, "DataViewIndexOutOfBoundsError", { enumerable: true, get: function () { return Decoder_1.DataViewIndexOutOfBoundsError; } });
+const DecodeError_1 = require("./DecodeError");
+Object.defineProperty(exports, "DecodeError", { enumerable: true, get: function () { return DecodeError_1.DecodeError; } });
+const Encoder_1 = require("./Encoder");
+Object.defineProperty(exports, "Encoder", { enumerable: true, get: function () { return Encoder_1.Encoder; } });
+// Utilitiies for Extension Types:
+const ExtensionCodec_1 = require("./ExtensionCodec");
+Object.defineProperty(exports, "ExtensionCodec", { enumerable: true, get: function () { return ExtensionCodec_1.ExtensionCodec; } });
+const ExtData_1 = require("./ExtData");
+Object.defineProperty(exports, "ExtData", { enumerable: true, get: function () { return ExtData_1.ExtData; } });
+const timestamp_1 = require("./timestamp");
+Object.defineProperty(exports, "EXT_TIMESTAMP", { enumerable: true, get: function () { return timestamp_1.EXT_TIMESTAMP; } });
+Object.defineProperty(exports, "encodeDateToTimeSpec", { enumerable: true, get: function () { return timestamp_1.encodeDateToTimeSpec; } });
+Object.defineProperty(exports, "encodeTimeSpecToTimestamp", { enumerable: true, get: function () { return timestamp_1.encodeTimeSpecToTimestamp; } });
+Object.defineProperty(exports, "decodeTimestampToTimeSpec", { enumerable: true, get: function () { return timestamp_1.decodeTimestampToTimeSpec; } });
+Object.defineProperty(exports, "encodeTimestampExtension", { enumerable: true, get: function () { return timestamp_1.encodeTimestampExtension; } });
+Object.defineProperty(exports, "decodeTimestampExtension", { enumerable: true, get: function () { return timestamp_1.decodeTimestampExtension; } });
+//# sourceMappingURL=index.js.map