mirror of
https://github.com/tvytlx/ai-agent-deep-dive.git
synced 2026-04-07 17:44:48 +08:00
Add extracted source directory and README navigation
This commit is contained in:
Shawn Bot
182
extracted-source/node_modules/@smithy/eventstream-serde-universal/dist-cjs/index.js
generated
vendored
Normal file
182
extracted-source/node_modules/@smithy/eventstream-serde-universal/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,182 @@
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
|
||||
// src/index.ts
|
||||
var src_exports = {};
|
||||
__export(src_exports, {
|
||||
EventStreamMarshaller: () => EventStreamMarshaller,
|
||||
eventStreamSerdeProvider: () => eventStreamSerdeProvider
|
||||
});
|
||||
module.exports = __toCommonJS(src_exports);
|
||||
|
||||
// src/EventStreamMarshaller.ts
|
||||
var import_eventstream_codec = require("@smithy/eventstream-codec");
|
||||
|
||||
// src/getChunkedStream.ts
|
||||
function getChunkedStream(source) {
|
||||
let currentMessageTotalLength = 0;
|
||||
let currentMessagePendingLength = 0;
|
||||
let currentMessage = null;
|
||||
let messageLengthBuffer = null;
|
||||
const allocateMessage = /* @__PURE__ */ __name((size) => {
|
||||
if (typeof size !== "number") {
|
||||
throw new Error("Attempted to allocate an event message where size was not a number: " + size);
|
||||
}
|
||||
currentMessageTotalLength = size;
|
||||
currentMessagePendingLength = 4;
|
||||
currentMessage = new Uint8Array(size);
|
||||
const currentMessageView = new DataView(currentMessage.buffer);
|
||||
currentMessageView.setUint32(0, size, false);
|
||||
}, "allocateMessage");
|
||||
const iterator = /* @__PURE__ */ __name(async function* () {
|
||||
const sourceIterator = source[Symbol.asyncIterator]();
|
||||
while (true) {
|
||||
const { value, done } = await sourceIterator.next();
|
||||
if (done) {
|
||||
if (!currentMessageTotalLength) {
|
||||
return;
|
||||
} else if (currentMessageTotalLength === currentMessagePendingLength) {
|
||||
yield currentMessage;
|
||||
} else {
|
||||
throw new Error("Truncated event message received.");
|
||||
}
|
||||
return;
|
||||
}
|
||||
const chunkLength = value.length;
|
||||
let currentOffset = 0;
|
||||
while (currentOffset < chunkLength) {
|
||||
if (!currentMessage) {
|
||||
const bytesRemaining = chunkLength - currentOffset;
|
||||
if (!messageLengthBuffer) {
|
||||
messageLengthBuffer = new Uint8Array(4);
|
||||
}
|
||||
const numBytesForTotal = Math.min(
|
||||
4 - currentMessagePendingLength,
|
||||
// remaining bytes to fill the messageLengthBuffer
|
||||
bytesRemaining
|
||||
// bytes left in chunk
|
||||
);
|
||||
messageLengthBuffer.set(
|
||||
// @ts-ignore error TS2532: Object is possibly 'undefined' for value
|
||||
value.slice(currentOffset, currentOffset + numBytesForTotal),
|
||||
currentMessagePendingLength
|
||||
);
|
||||
currentMessagePendingLength += numBytesForTotal;
|
||||
currentOffset += numBytesForTotal;
|
||||
if (currentMessagePendingLength < 4) {
|
||||
break;
|
||||
}
|
||||
allocateMessage(new DataView(messageLengthBuffer.buffer).getUint32(0, false));
|
||||
messageLengthBuffer = null;
|
||||
}
|
||||
const numBytesToWrite = Math.min(
|
||||
currentMessageTotalLength - currentMessagePendingLength,
|
||||
// number of bytes left to complete message
|
||||
chunkLength - currentOffset
|
||||
// number of bytes left in the original chunk
|
||||
);
|
||||
currentMessage.set(
|
||||
// @ts-ignore error TS2532: Object is possibly 'undefined' for value
|
||||
value.slice(currentOffset, currentOffset + numBytesToWrite),
|
||||
currentMessagePendingLength
|
||||
);
|
||||
currentMessagePendingLength += numBytesToWrite;
|
||||
currentOffset += numBytesToWrite;
|
||||
if (currentMessageTotalLength && currentMessageTotalLength === currentMessagePendingLength) {
|
||||
yield currentMessage;
|
||||
currentMessage = null;
|
||||
currentMessageTotalLength = 0;
|
||||
currentMessagePendingLength = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
}, "iterator");
|
||||
return {
|
||||
[Symbol.asyncIterator]: iterator
|
||||
};
|
||||
}
|
||||
__name(getChunkedStream, "getChunkedStream");
|
||||
|
||||
// src/getUnmarshalledStream.ts
|
||||
function getMessageUnmarshaller(deserializer, toUtf8) {
|
||||
return async function(message) {
|
||||
const { value: messageType } = message.headers[":message-type"];
|
||||
if (messageType === "error") {
|
||||
const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
|
||||
unmodeledError.name = message.headers[":error-code"].value;
|
||||
throw unmodeledError;
|
||||
} else if (messageType === "exception") {
|
||||
const code = message.headers[":exception-type"].value;
|
||||
const exception = { [code]: message };
|
||||
const deserializedException = await deserializer(exception);
|
||||
if (deserializedException.$unknown) {
|
||||
const error = new Error(toUtf8(message.body));
|
||||
error.name = code;
|
||||
throw error;
|
||||
}
|
||||
throw deserializedException[code];
|
||||
} else if (messageType === "event") {
|
||||
const event = {
|
||||
[message.headers[":event-type"].value]: message
|
||||
};
|
||||
const deserialized = await deserializer(event);
|
||||
if (deserialized.$unknown)
|
||||
return;
|
||||
return deserialized;
|
||||
} else {
|
||||
throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
|
||||
}
|
||||
};
|
||||
}
|
||||
__name(getMessageUnmarshaller, "getMessageUnmarshaller");
|
||||
|
||||
// src/EventStreamMarshaller.ts
|
||||
var _EventStreamMarshaller = class _EventStreamMarshaller {
|
||||
constructor({ utf8Encoder, utf8Decoder }) {
|
||||
this.eventStreamCodec = new import_eventstream_codec.EventStreamCodec(utf8Encoder, utf8Decoder);
|
||||
this.utfEncoder = utf8Encoder;
|
||||
}
|
||||
deserialize(body, deserializer) {
|
||||
const inputStream = getChunkedStream(body);
|
||||
return new import_eventstream_codec.SmithyMessageDecoderStream({
|
||||
messageStream: new import_eventstream_codec.MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
|
||||
// @ts-expect-error Type 'T' is not assignable to type 'Record<string, any>'
|
||||
deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
|
||||
});
|
||||
}
|
||||
serialize(inputStream, serializer) {
|
||||
return new import_eventstream_codec.MessageEncoderStream({
|
||||
messageStream: new import_eventstream_codec.SmithyMessageEncoderStream({ inputStream, serializer }),
|
||||
encoder: this.eventStreamCodec,
|
||||
includeEndFrame: true
|
||||
});
|
||||
}
|
||||
};
|
||||
__name(_EventStreamMarshaller, "EventStreamMarshaller");
|
||||
var EventStreamMarshaller = _EventStreamMarshaller;
|
||||
|
||||
// src/provider.ts
|
||||
var eventStreamSerdeProvider = /* @__PURE__ */ __name((options) => new EventStreamMarshaller(options), "eventStreamSerdeProvider");
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
|
||||
0 && (module.exports = {
|
||||
EventStreamMarshaller,
|
||||
eventStreamSerdeProvider
|
||||
});
|
||||
|
||||
468
extracted-source/node_modules/@smithy/eventstream-serde-universal/node_modules/@smithy/eventstream-codec/dist-cjs/index.js
generated
vendored
Normal file
468
extracted-source/node_modules/@smithy/eventstream-serde-universal/node_modules/@smithy/eventstream-codec/dist-cjs/index.js
generated
vendored
Normal file
@@ -0,0 +1,468 @@
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
|
||||
// src/index.ts
|
||||
var src_exports = {};
|
||||
__export(src_exports, {
|
||||
EventStreamCodec: () => EventStreamCodec,
|
||||
HeaderMarshaller: () => HeaderMarshaller,
|
||||
Int64: () => Int64,
|
||||
MessageDecoderStream: () => MessageDecoderStream,
|
||||
MessageEncoderStream: () => MessageEncoderStream,
|
||||
SmithyMessageDecoderStream: () => SmithyMessageDecoderStream,
|
||||
SmithyMessageEncoderStream: () => SmithyMessageEncoderStream
|
||||
});
|
||||
module.exports = __toCommonJS(src_exports);
|
||||
|
||||
// src/EventStreamCodec.ts
|
||||
var import_crc322 = require("@aws-crypto/crc32");
|
||||
|
||||
// src/HeaderMarshaller.ts
|
||||
|
||||
|
||||
// src/Int64.ts
|
||||
var import_util_hex_encoding = require("@smithy/util-hex-encoding");
|
||||
var _Int64 = class _Int64 {
|
||||
constructor(bytes) {
|
||||
this.bytes = bytes;
|
||||
if (bytes.byteLength !== 8) {
|
||||
throw new Error("Int64 buffers must be exactly 8 bytes");
|
||||
}
|
||||
}
|
||||
static fromNumber(number) {
|
||||
if (number > 9223372036854776e3 || number < -9223372036854776e3) {
|
||||
throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
|
||||
}
|
||||
const bytes = new Uint8Array(8);
|
||||
for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) {
|
||||
bytes[i] = remaining;
|
||||
}
|
||||
if (number < 0) {
|
||||
negate(bytes);
|
||||
}
|
||||
return new _Int64(bytes);
|
||||
}
|
||||
/**
|
||||
* Called implicitly by infix arithmetic operators.
|
||||
*/
|
||||
valueOf() {
|
||||
const bytes = this.bytes.slice(0);
|
||||
const negative = bytes[0] & 128;
|
||||
if (negative) {
|
||||
negate(bytes);
|
||||
}
|
||||
return parseInt((0, import_util_hex_encoding.toHex)(bytes), 16) * (negative ? -1 : 1);
|
||||
}
|
||||
toString() {
|
||||
return String(this.valueOf());
|
||||
}
|
||||
};
|
||||
__name(_Int64, "Int64");
|
||||
var Int64 = _Int64;
|
||||
function negate(bytes) {
|
||||
for (let i = 0; i < 8; i++) {
|
||||
bytes[i] ^= 255;
|
||||
}
|
||||
for (let i = 7; i > -1; i--) {
|
||||
bytes[i]++;
|
||||
if (bytes[i] !== 0)
|
||||
break;
|
||||
}
|
||||
}
|
||||
__name(negate, "negate");
|
||||
|
||||
// src/HeaderMarshaller.ts
|
||||
var _HeaderMarshaller = class _HeaderMarshaller {
|
||||
constructor(toUtf8, fromUtf8) {
|
||||
this.toUtf8 = toUtf8;
|
||||
this.fromUtf8 = fromUtf8;
|
||||
}
|
||||
format(headers) {
|
||||
const chunks = [];
|
||||
for (const headerName of Object.keys(headers)) {
|
||||
const bytes = this.fromUtf8(headerName);
|
||||
chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
|
||||
}
|
||||
const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
|
||||
let position = 0;
|
||||
for (const chunk of chunks) {
|
||||
out.set(chunk, position);
|
||||
position += chunk.byteLength;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
formatHeaderValue(header) {
|
||||
switch (header.type) {
|
||||
case "boolean":
|
||||
return Uint8Array.from([header.value ? 0 /* boolTrue */ : 1 /* boolFalse */]);
|
||||
case "byte":
|
||||
return Uint8Array.from([2 /* byte */, header.value]);
|
||||
case "short":
|
||||
const shortView = new DataView(new ArrayBuffer(3));
|
||||
shortView.setUint8(0, 3 /* short */);
|
||||
shortView.setInt16(1, header.value, false);
|
||||
return new Uint8Array(shortView.buffer);
|
||||
case "integer":
|
||||
const intView = new DataView(new ArrayBuffer(5));
|
||||
intView.setUint8(0, 4 /* integer */);
|
||||
intView.setInt32(1, header.value, false);
|
||||
return new Uint8Array(intView.buffer);
|
||||
case "long":
|
||||
const longBytes = new Uint8Array(9);
|
||||
longBytes[0] = 5 /* long */;
|
||||
longBytes.set(header.value.bytes, 1);
|
||||
return longBytes;
|
||||
case "binary":
|
||||
const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
|
||||
binView.setUint8(0, 6 /* byteArray */);
|
||||
binView.setUint16(1, header.value.byteLength, false);
|
||||
const binBytes = new Uint8Array(binView.buffer);
|
||||
binBytes.set(header.value, 3);
|
||||
return binBytes;
|
||||
case "string":
|
||||
const utf8Bytes = this.fromUtf8(header.value);
|
||||
const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
|
||||
strView.setUint8(0, 7 /* string */);
|
||||
strView.setUint16(1, utf8Bytes.byteLength, false);
|
||||
const strBytes = new Uint8Array(strView.buffer);
|
||||
strBytes.set(utf8Bytes, 3);
|
||||
return strBytes;
|
||||
case "timestamp":
|
||||
const tsBytes = new Uint8Array(9);
|
||||
tsBytes[0] = 8 /* timestamp */;
|
||||
tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
|
||||
return tsBytes;
|
||||
case "uuid":
|
||||
if (!UUID_PATTERN.test(header.value)) {
|
||||
throw new Error(`Invalid UUID received: ${header.value}`);
|
||||
}
|
||||
const uuidBytes = new Uint8Array(17);
|
||||
uuidBytes[0] = 9 /* uuid */;
|
||||
uuidBytes.set((0, import_util_hex_encoding.fromHex)(header.value.replace(/\-/g, "")), 1);
|
||||
return uuidBytes;
|
||||
}
|
||||
}
|
||||
parse(headers) {
|
||||
const out = {};
|
||||
let position = 0;
|
||||
while (position < headers.byteLength) {
|
||||
const nameLength = headers.getUint8(position++);
|
||||
const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
|
||||
position += nameLength;
|
||||
switch (headers.getUint8(position++)) {
|
||||
case 0 /* boolTrue */:
|
||||
out[name] = {
|
||||
type: BOOLEAN_TAG,
|
||||
value: true
|
||||
};
|
||||
break;
|
||||
case 1 /* boolFalse */:
|
||||
out[name] = {
|
||||
type: BOOLEAN_TAG,
|
||||
value: false
|
||||
};
|
||||
break;
|
||||
case 2 /* byte */:
|
||||
out[name] = {
|
||||
type: BYTE_TAG,
|
||||
value: headers.getInt8(position++)
|
||||
};
|
||||
break;
|
||||
case 3 /* short */:
|
||||
out[name] = {
|
||||
type: SHORT_TAG,
|
||||
value: headers.getInt16(position, false)
|
||||
};
|
||||
position += 2;
|
||||
break;
|
||||
case 4 /* integer */:
|
||||
out[name] = {
|
||||
type: INT_TAG,
|
||||
value: headers.getInt32(position, false)
|
||||
};
|
||||
position += 4;
|
||||
break;
|
||||
case 5 /* long */:
|
||||
out[name] = {
|
||||
type: LONG_TAG,
|
||||
value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8))
|
||||
};
|
||||
position += 8;
|
||||
break;
|
||||
case 6 /* byteArray */:
|
||||
const binaryLength = headers.getUint16(position, false);
|
||||
position += 2;
|
||||
out[name] = {
|
||||
type: BINARY_TAG,
|
||||
value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength)
|
||||
};
|
||||
position += binaryLength;
|
||||
break;
|
||||
case 7 /* string */:
|
||||
const stringLength = headers.getUint16(position, false);
|
||||
position += 2;
|
||||
out[name] = {
|
||||
type: STRING_TAG,
|
||||
value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength))
|
||||
};
|
||||
position += stringLength;
|
||||
break;
|
||||
case 8 /* timestamp */:
|
||||
out[name] = {
|
||||
type: TIMESTAMP_TAG,
|
||||
value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf())
|
||||
};
|
||||
position += 8;
|
||||
break;
|
||||
case 9 /* uuid */:
|
||||
const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
|
||||
position += 16;
|
||||
out[name] = {
|
||||
type: UUID_TAG,
|
||||
value: `${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(0, 4))}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(4, 6))}-${(0, import_util_hex_encoding.toHex)(
|
||||
uuidBytes.subarray(6, 8)
|
||||
)}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(8, 10))}-${(0, import_util_hex_encoding.toHex)(uuidBytes.subarray(10))}`
|
||||
};
|
||||
break;
|
||||
default:
|
||||
throw new Error(`Unrecognized header type tag`);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
};
|
||||
__name(_HeaderMarshaller, "HeaderMarshaller");
|
||||
var HeaderMarshaller = _HeaderMarshaller;
|
||||
var BOOLEAN_TAG = "boolean";
|
||||
var BYTE_TAG = "byte";
|
||||
var SHORT_TAG = "short";
|
||||
var INT_TAG = "integer";
|
||||
var LONG_TAG = "long";
|
||||
var BINARY_TAG = "binary";
|
||||
var STRING_TAG = "string";
|
||||
var TIMESTAMP_TAG = "timestamp";
|
||||
var UUID_TAG = "uuid";
|
||||
var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
|
||||
|
||||
// src/splitMessage.ts
|
||||
var import_crc32 = require("@aws-crypto/crc32");
|
||||
var PRELUDE_MEMBER_LENGTH = 4;
|
||||
var PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
|
||||
var CHECKSUM_LENGTH = 4;
|
||||
var MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
|
||||
function splitMessage({ byteLength, byteOffset, buffer }) {
|
||||
if (byteLength < MINIMUM_MESSAGE_LENGTH) {
|
||||
throw new Error("Provided message too short to accommodate event stream message overhead");
|
||||
}
|
||||
const view = new DataView(buffer, byteOffset, byteLength);
|
||||
const messageLength = view.getUint32(0, false);
|
||||
if (byteLength !== messageLength) {
|
||||
throw new Error("Reported message length does not match received message length");
|
||||
}
|
||||
const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
|
||||
const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
|
||||
const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
|
||||
const checksummer = new import_crc32.Crc32().update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
|
||||
if (expectedPreludeChecksum !== checksummer.digest()) {
|
||||
throw new Error(
|
||||
`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digest()})`
|
||||
);
|
||||
}
|
||||
checksummer.update(
|
||||
new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH))
|
||||
);
|
||||
if (expectedMessageChecksum !== checksummer.digest()) {
|
||||
throw new Error(
|
||||
`The message checksum (${checksummer.digest()}) did not match the expected value of ${expectedMessageChecksum}`
|
||||
);
|
||||
}
|
||||
return {
|
||||
headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
|
||||
body: new Uint8Array(
|
||||
buffer,
|
||||
byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength,
|
||||
messageLength - headerLength - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH)
|
||||
)
|
||||
};
|
||||
}
|
||||
__name(splitMessage, "splitMessage");
|
||||
|
||||
// src/EventStreamCodec.ts
|
||||
var _EventStreamCodec = class _EventStreamCodec {
|
||||
constructor(toUtf8, fromUtf8) {
|
||||
this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
|
||||
this.messageBuffer = [];
|
||||
this.isEndOfStream = false;
|
||||
}
|
||||
feed(message) {
|
||||
this.messageBuffer.push(this.decode(message));
|
||||
}
|
||||
endOfStream() {
|
||||
this.isEndOfStream = true;
|
||||
}
|
||||
getMessage() {
|
||||
const message = this.messageBuffer.pop();
|
||||
const isEndOfStream = this.isEndOfStream;
|
||||
return {
|
||||
getMessage() {
|
||||
return message;
|
||||
},
|
||||
isEndOfStream() {
|
||||
return isEndOfStream;
|
||||
}
|
||||
};
|
||||
}
|
||||
getAvailableMessages() {
|
||||
const messages = this.messageBuffer;
|
||||
this.messageBuffer = [];
|
||||
const isEndOfStream = this.isEndOfStream;
|
||||
return {
|
||||
getMessages() {
|
||||
return messages;
|
||||
},
|
||||
isEndOfStream() {
|
||||
return isEndOfStream;
|
||||
}
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Convert a structured JavaScript object with tagged headers into a binary
|
||||
* event stream message.
|
||||
*/
|
||||
encode({ headers: rawHeaders, body }) {
|
||||
const headers = this.headerMarshaller.format(rawHeaders);
|
||||
const length = headers.byteLength + body.byteLength + 16;
|
||||
const out = new Uint8Array(length);
|
||||
const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
|
||||
const checksum = new import_crc322.Crc32();
|
||||
view.setUint32(0, length, false);
|
||||
view.setUint32(4, headers.byteLength, false);
|
||||
view.setUint32(8, checksum.update(out.subarray(0, 8)).digest(), false);
|
||||
out.set(headers, 12);
|
||||
out.set(body, headers.byteLength + 12);
|
||||
view.setUint32(length - 4, checksum.update(out.subarray(8, length - 4)).digest(), false);
|
||||
return out;
|
||||
}
|
||||
/**
|
||||
* Convert a binary event stream message into a JavaScript object with an
|
||||
* opaque, binary body and tagged, parsed headers.
|
||||
*/
|
||||
decode(message) {
|
||||
const { headers, body } = splitMessage(message);
|
||||
return { headers: this.headerMarshaller.parse(headers), body };
|
||||
}
|
||||
/**
|
||||
* Convert a structured JavaScript object with tagged headers into a binary
|
||||
* event stream message header.
|
||||
*/
|
||||
formatHeaders(rawHeaders) {
|
||||
return this.headerMarshaller.format(rawHeaders);
|
||||
}
|
||||
};
|
||||
__name(_EventStreamCodec, "EventStreamCodec");
|
||||
var EventStreamCodec = _EventStreamCodec;
|
||||
|
||||
// src/MessageDecoderStream.ts
|
||||
var _MessageDecoderStream = class _MessageDecoderStream {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const bytes of this.options.inputStream) {
|
||||
const decoded = this.options.decoder.decode(bytes);
|
||||
yield decoded;
|
||||
}
|
||||
}
|
||||
};
|
||||
__name(_MessageDecoderStream, "MessageDecoderStream");
|
||||
var MessageDecoderStream = _MessageDecoderStream;
|
||||
|
||||
// src/MessageEncoderStream.ts
|
||||
var _MessageEncoderStream = class _MessageEncoderStream {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const msg of this.options.messageStream) {
|
||||
const encoded = this.options.encoder.encode(msg);
|
||||
yield encoded;
|
||||
}
|
||||
if (this.options.includeEndFrame) {
|
||||
yield new Uint8Array(0);
|
||||
}
|
||||
}
|
||||
};
|
||||
__name(_MessageEncoderStream, "MessageEncoderStream");
|
||||
var MessageEncoderStream = _MessageEncoderStream;
|
||||
|
||||
// src/SmithyMessageDecoderStream.ts
|
||||
var _SmithyMessageDecoderStream = class _SmithyMessageDecoderStream {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const message of this.options.messageStream) {
|
||||
const deserialized = await this.options.deserializer(message);
|
||||
if (deserialized === void 0)
|
||||
continue;
|
||||
yield deserialized;
|
||||
}
|
||||
}
|
||||
};
|
||||
__name(_SmithyMessageDecoderStream, "SmithyMessageDecoderStream");
|
||||
var SmithyMessageDecoderStream = _SmithyMessageDecoderStream;
|
||||
|
||||
// src/SmithyMessageEncoderStream.ts
|
||||
var _SmithyMessageEncoderStream = class _SmithyMessageEncoderStream {
|
||||
constructor(options) {
|
||||
this.options = options;
|
||||
}
|
||||
[Symbol.asyncIterator]() {
|
||||
return this.asyncIterator();
|
||||
}
|
||||
async *asyncIterator() {
|
||||
for await (const chunk of this.options.inputStream) {
|
||||
const payloadBuf = this.options.serializer(chunk);
|
||||
yield payloadBuf;
|
||||
}
|
||||
}
|
||||
};
|
||||
__name(_SmithyMessageEncoderStream, "SmithyMessageEncoderStream");
|
||||
var SmithyMessageEncoderStream = _SmithyMessageEncoderStream;
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
|
||||
0 && (module.exports = {
|
||||
EventStreamCodec,
|
||||
HeaderMarshaller,
|
||||
Int64,
|
||||
MessageDecoderStream,
|
||||
MessageEncoderStream,
|
||||
SmithyMessageDecoderStream,
|
||||
SmithyMessageEncoderStream
|
||||
});
|
||||
|
||||
@@ -0,0 +1,31 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AwsCrc32 = void 0;
|
||||
var tslib_1 = require("tslib");
|
||||
var util_1 = require("@aws-crypto/util");
|
||||
var index_1 = require("./index");
|
||||
var AwsCrc32 = /** @class */ (function () {
|
||||
function AwsCrc32() {
|
||||
this.crc32 = new index_1.Crc32();
|
||||
}
|
||||
AwsCrc32.prototype.update = function (toHash) {
|
||||
if ((0, util_1.isEmptyData)(toHash))
|
||||
return;
|
||||
this.crc32.update((0, util_1.convertToBuffer)(toHash));
|
||||
};
|
||||
AwsCrc32.prototype.digest = function () {
|
||||
return tslib_1.__awaiter(this, void 0, void 0, function () {
|
||||
return tslib_1.__generator(this, function (_a) {
|
||||
return [2 /*return*/, (0, util_1.numToUint8)(this.crc32.digest())];
|
||||
});
|
||||
});
|
||||
};
|
||||
AwsCrc32.prototype.reset = function () {
|
||||
this.crc32 = new index_1.Crc32();
|
||||
};
|
||||
return AwsCrc32;
|
||||
}());
|
||||
exports.AwsCrc32 = AwsCrc32;
|
||||
//# sourceMappingURL=aws_crc32.js.map
|
||||
@@ -0,0 +1,108 @@
|
||||
"use strict";
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.AwsCrc32 = exports.Crc32 = exports.crc32 = void 0;
|
||||
var tslib_1 = require("tslib");
|
||||
var util_1 = require("@aws-crypto/util");
|
||||
function crc32(data) {
|
||||
return new Crc32().update(data).digest();
|
||||
}
|
||||
exports.crc32 = crc32;
|
||||
var Crc32 = /** @class */ (function () {
|
||||
function Crc32() {
|
||||
this.checksum = 0xffffffff;
|
||||
}
|
||||
Crc32.prototype.update = function (data) {
|
||||
var e_1, _a;
|
||||
try {
|
||||
for (var data_1 = tslib_1.__values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) {
|
||||
var byte = data_1_1.value;
|
||||
this.checksum =
|
||||
(this.checksum >>> 8) ^ lookupTable[(this.checksum ^ byte) & 0xff];
|
||||
}
|
||||
}
|
||||
catch (e_1_1) { e_1 = { error: e_1_1 }; }
|
||||
finally {
|
||||
try {
|
||||
if (data_1_1 && !data_1_1.done && (_a = data_1.return)) _a.call(data_1);
|
||||
}
|
||||
finally { if (e_1) throw e_1.error; }
|
||||
}
|
||||
return this;
|
||||
};
|
||||
Crc32.prototype.digest = function () {
|
||||
return (this.checksum ^ 0xffffffff) >>> 0;
|
||||
};
|
||||
return Crc32;
|
||||
}());
|
||||
exports.Crc32 = Crc32;
|
||||
// prettier-ignore
|
||||
var a_lookUpTable = [
|
||||
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA,
|
||||
0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
|
||||
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988,
|
||||
0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
|
||||
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE,
|
||||
0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
|
||||
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC,
|
||||
0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
|
||||
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172,
|
||||
0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
|
||||
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940,
|
||||
0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
|
||||
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116,
|
||||
0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
|
||||
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924,
|
||||
0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
|
||||
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A,
|
||||
0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
|
||||
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818,
|
||||
0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
|
||||
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E,
|
||||
0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
|
||||
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C,
|
||||
0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
|
||||
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2,
|
||||
0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
|
||||
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0,
|
||||
0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
|
||||
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086,
|
||||
0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
|
||||
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4,
|
||||
0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
|
||||
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A,
|
||||
0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
|
||||
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8,
|
||||
0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
|
||||
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE,
|
||||
0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
|
||||
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC,
|
||||
0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
|
||||
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252,
|
||||
0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
|
||||
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60,
|
||||
0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
|
||||
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236,
|
||||
0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
|
||||
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04,
|
||||
0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
|
||||
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A,
|
||||
0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
|
||||
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38,
|
||||
0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
|
||||
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E,
|
||||
0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
|
||||
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C,
|
||||
0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
|
||||
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2,
|
||||
0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
|
||||
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0,
|
||||
0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
|
||||
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6,
|
||||
0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
|
||||
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94,
|
||||
0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D,
|
||||
];
|
||||
var lookupTable = (0, util_1.uint32ArrayFrom)(a_lookUpTable);
|
||||
var aws_crc32_1 = require("./aws_crc32");
|
||||
Object.defineProperty(exports, "AwsCrc32", { enumerable: true, get: function () { return aws_crc32_1.AwsCrc32; } });
|
||||
//# sourceMappingURL=index.js.map
|
||||
@@ -0,0 +1,24 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.convertToBuffer = void 0;
|
||||
var util_utf8_browser_1 = require("@aws-sdk/util-utf8-browser");
|
||||
// Quick polyfill
|
||||
var fromUtf8 = typeof Buffer !== "undefined" && Buffer.from
|
||||
? function (input) { return Buffer.from(input, "utf8"); }
|
||||
: util_utf8_browser_1.fromUtf8;
|
||||
function convertToBuffer(data) {
|
||||
// Already a Uint8, do nothing
|
||||
if (data instanceof Uint8Array)
|
||||
return data;
|
||||
if (typeof data === "string") {
|
||||
return fromUtf8(data);
|
||||
}
|
||||
if (ArrayBuffer.isView(data)) {
|
||||
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
|
||||
}
|
||||
return new Uint8Array(data);
|
||||
}
|
||||
exports.convertToBuffer = convertToBuffer;
|
||||
//# sourceMappingURL=convertToBuffer.js.map
|
||||
@@ -0,0 +1,14 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.uint32ArrayFrom = exports.numToUint8 = exports.isEmptyData = exports.convertToBuffer = void 0;
|
||||
var convertToBuffer_1 = require("./convertToBuffer");
|
||||
Object.defineProperty(exports, "convertToBuffer", { enumerable: true, get: function () { return convertToBuffer_1.convertToBuffer; } });
|
||||
var isEmptyData_1 = require("./isEmptyData");
|
||||
Object.defineProperty(exports, "isEmptyData", { enumerable: true, get: function () { return isEmptyData_1.isEmptyData; } });
|
||||
var numToUint8_1 = require("./numToUint8");
|
||||
Object.defineProperty(exports, "numToUint8", { enumerable: true, get: function () { return numToUint8_1.numToUint8; } });
|
||||
var uint32ArrayFrom_1 = require("./uint32ArrayFrom");
|
||||
Object.defineProperty(exports, "uint32ArrayFrom", { enumerable: true, get: function () { return uint32ArrayFrom_1.uint32ArrayFrom; } });
|
||||
//# sourceMappingURL=index.js.map
|
||||
@@ -0,0 +1,13 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.isEmptyData = void 0;
|
||||
function isEmptyData(data) {
|
||||
if (typeof data === "string") {
|
||||
return data.length === 0;
|
||||
}
|
||||
return data.byteLength === 0;
|
||||
}
|
||||
exports.isEmptyData = isEmptyData;
|
||||
//# sourceMappingURL=isEmptyData.js.map
|
||||
@@ -0,0 +1,15 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.numToUint8 = void 0;
|
||||
function numToUint8(num) {
|
||||
return new Uint8Array([
|
||||
(num & 0xff000000) >> 24,
|
||||
(num & 0x00ff0000) >> 16,
|
||||
(num & 0x0000ff00) >> 8,
|
||||
num & 0x000000ff,
|
||||
]);
|
||||
}
|
||||
exports.numToUint8 = numToUint8;
|
||||
//# sourceMappingURL=numToUint8.js.map
|
||||
@@ -0,0 +1,20 @@
|
||||
"use strict";
|
||||
// Copyright Amazon.com Inc. or its affiliates. All Rights Reserved.
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
exports.uint32ArrayFrom = void 0;
|
||||
// IE 11 does not support Array.from, so we do it manually
|
||||
function uint32ArrayFrom(a_lookUpTable) {
|
||||
if (!Uint32Array.from) {
|
||||
var return_array = new Uint32Array(a_lookUpTable.length);
|
||||
var a_index = 0;
|
||||
while (a_index < a_lookUpTable.length) {
|
||||
return_array[a_index] = a_lookUpTable[a_index];
|
||||
a_index += 1;
|
||||
}
|
||||
return return_array;
|
||||
}
|
||||
return Uint32Array.from(a_lookUpTable);
|
||||
}
|
||||
exports.uint32ArrayFrom = uint32ArrayFrom;
|
||||
//# sourceMappingURL=uint32ArrayFrom.js.map
|
||||
@@ -0,0 +1,284 @@
|
||||
/*! *****************************************************************************
|
||||
Copyright (c) Microsoft Corporation.
|
||||
|
||||
Permission to use, copy, modify, and/or distribute this software for any
|
||||
purpose with or without fee is hereby granted.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
|
||||
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
|
||||
AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
|
||||
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
|
||||
LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
|
||||
OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
|
||||
PERFORMANCE OF THIS SOFTWARE.
|
||||
***************************************************************************** */
|
||||
|
||||
/* global global, define, System, Reflect, Promise */
|
||||
var __extends;
|
||||
var __assign;
|
||||
var __rest;
|
||||
var __decorate;
|
||||
var __param;
|
||||
var __metadata;
|
||||
var __awaiter;
|
||||
var __generator;
|
||||
var __exportStar;
|
||||
var __values;
|
||||
var __read;
|
||||
var __spread;
|
||||
var __spreadArrays;
|
||||
var __await;
|
||||
var __asyncGenerator;
|
||||
var __asyncDelegator;
|
||||
var __asyncValues;
|
||||
var __makeTemplateObject;
|
||||
var __importStar;
|
||||
var __importDefault;
|
||||
var __classPrivateFieldGet;
|
||||
var __classPrivateFieldSet;
|
||||
var __createBinding;
|
||||
(function (factory) {
|
||||
var root = typeof global === "object" ? global : typeof self === "object" ? self : typeof this === "object" ? this : {};
|
||||
if (typeof define === "function" && define.amd) {
|
||||
define("tslib", ["exports"], function (exports) { factory(createExporter(root, createExporter(exports))); });
|
||||
}
|
||||
else if (typeof module === "object" && typeof module.exports === "object") {
|
||||
factory(createExporter(root, createExporter(module.exports)));
|
||||
}
|
||||
else {
|
||||
factory(createExporter(root));
|
||||
}
|
||||
function createExporter(exports, previous) {
|
||||
if (exports !== root) {
|
||||
if (typeof Object.create === "function") {
|
||||
Object.defineProperty(exports, "__esModule", { value: true });
|
||||
}
|
||||
else {
|
||||
exports.__esModule = true;
|
||||
}
|
||||
}
|
||||
return function (id, v) { return exports[id] = previous ? previous(id, v) : v; };
|
||||
}
|
||||
})
|
||||
(function (exporter) {
|
||||
var extendStatics = Object.setPrototypeOf ||
|
||||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
|
||||
function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
|
||||
|
||||
__extends = function (d, b) {
|
||||
extendStatics(d, b);
|
||||
function __() { this.constructor = d; }
|
||||
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
|
||||
};
|
||||
|
||||
__assign = Object.assign || function (t) {
|
||||
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
||||
s = arguments[i];
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
|
||||
__rest = function (s, e) {
|
||||
var t = {};
|
||||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
|
||||
t[p] = s[p];
|
||||
if (s != null && typeof Object.getOwnPropertySymbols === "function")
|
||||
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
|
||||
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
|
||||
t[p[i]] = s[p[i]];
|
||||
}
|
||||
return t;
|
||||
};
|
||||
|
||||
__decorate = function (decorators, target, key, desc) {
|
||||
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
|
||||
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
|
||||
else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
|
||||
return c > 3 && r && Object.defineProperty(target, key, r), r;
|
||||
};
|
||||
|
||||
__param = function (paramIndex, decorator) {
|
||||
return function (target, key) { decorator(target, key, paramIndex); }
|
||||
};
|
||||
|
||||
__metadata = function (metadataKey, metadataValue) {
|
||||
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
|
||||
};
|
||||
|
||||
__awaiter = function (thisArg, _arguments, P, generator) {
|
||||
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
|
||||
return new (P || (P = Promise))(function (resolve, reject) {
|
||||
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
|
||||
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
|
||||
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
|
||||
step((generator = generator.apply(thisArg, _arguments || [])).next());
|
||||
});
|
||||
};
|
||||
|
||||
__generator = function (thisArg, body) {
|
||||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
|
||||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
|
||||
function verb(n) { return function (v) { return step([n, v]); }; }
|
||||
function step(op) {
|
||||
if (f) throw new TypeError("Generator is already executing.");
|
||||
while (_) try {
|
||||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
|
||||
if (y = 0, t) op = [op[0] & 2, t.value];
|
||||
switch (op[0]) {
|
||||
case 0: case 1: t = op; break;
|
||||
case 4: _.label++; return { value: op[1], done: false };
|
||||
case 5: _.label++; y = op[1]; op = [0]; continue;
|
||||
case 7: op = _.ops.pop(); _.trys.pop(); continue;
|
||||
default:
|
||||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
|
||||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
|
||||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
|
||||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
|
||||
if (t[2]) _.ops.pop();
|
||||
_.trys.pop(); continue;
|
||||
}
|
||||
op = body.call(thisArg, _);
|
||||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
|
||||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
|
||||
}
|
||||
};
|
||||
|
||||
__createBinding = function(o, m, k, k2) {
|
||||
if (k2 === undefined) k2 = k;
|
||||
o[k2] = m[k];
|
||||
};
|
||||
|
||||
__exportStar = function (m, exports) {
|
||||
for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) exports[p] = m[p];
|
||||
};
|
||||
|
||||
__values = function (o) {
|
||||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
|
||||
if (m) return m.call(o);
|
||||
if (o && typeof o.length === "number") return {
|
||||
next: function () {
|
||||
if (o && i >= o.length) o = void 0;
|
||||
return { value: o && o[i++], done: !o };
|
||||
}
|
||||
};
|
||||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
|
||||
};
|
||||
|
||||
__read = function (o, n) {
|
||||
var m = typeof Symbol === "function" && o[Symbol.iterator];
|
||||
if (!m) return o;
|
||||
var i = m.call(o), r, ar = [], e;
|
||||
try {
|
||||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
|
||||
}
|
||||
catch (error) { e = { error: error }; }
|
||||
finally {
|
||||
try {
|
||||
if (r && !r.done && (m = i["return"])) m.call(i);
|
||||
}
|
||||
finally { if (e) throw e.error; }
|
||||
}
|
||||
return ar;
|
||||
};
|
||||
|
||||
__spread = function () {
|
||||
for (var ar = [], i = 0; i < arguments.length; i++)
|
||||
ar = ar.concat(__read(arguments[i]));
|
||||
return ar;
|
||||
};
|
||||
|
||||
__spreadArrays = function () {
|
||||
for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
|
||||
for (var r = Array(s), k = 0, i = 0; i < il; i++)
|
||||
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
|
||||
r[k] = a[j];
|
||||
return r;
|
||||
};
|
||||
|
||||
__await = function (v) {
|
||||
return this instanceof __await ? (this.v = v, this) : new __await(v);
|
||||
};
|
||||
|
||||
__asyncGenerator = function (thisArg, _arguments, generator) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var g = generator.apply(thisArg, _arguments || []), i, q = [];
|
||||
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
|
||||
function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
|
||||
function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
|
||||
function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
|
||||
function fulfill(value) { resume("next", value); }
|
||||
function reject(value) { resume("throw", value); }
|
||||
function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
|
||||
};
|
||||
|
||||
__asyncDelegator = function (o) {
|
||||
var i, p;
|
||||
return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
|
||||
function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
|
||||
};
|
||||
|
||||
__asyncValues = function (o) {
|
||||
if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
|
||||
var m = o[Symbol.asyncIterator], i;
|
||||
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
|
||||
function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
|
||||
function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
|
||||
};
|
||||
|
||||
__makeTemplateObject = function (cooked, raw) {
|
||||
if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
|
||||
return cooked;
|
||||
};
|
||||
|
||||
__importStar = function (mod) {
|
||||
if (mod && mod.__esModule) return mod;
|
||||
var result = {};
|
||||
if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
|
||||
result["default"] = mod;
|
||||
return result;
|
||||
};
|
||||
|
||||
__importDefault = function (mod) {
|
||||
return (mod && mod.__esModule) ? mod : { "default": mod };
|
||||
};
|
||||
|
||||
__classPrivateFieldGet = function (receiver, privateMap) {
|
||||
if (!privateMap.has(receiver)) {
|
||||
throw new TypeError("attempted to get private field on non-instance");
|
||||
}
|
||||
return privateMap.get(receiver);
|
||||
};
|
||||
|
||||
__classPrivateFieldSet = function (receiver, privateMap, value) {
|
||||
if (!privateMap.has(receiver)) {
|
||||
throw new TypeError("attempted to set private field on non-instance");
|
||||
}
|
||||
privateMap.set(receiver, value);
|
||||
return value;
|
||||
};
|
||||
|
||||
exporter("__extends", __extends);
|
||||
exporter("__assign", __assign);
|
||||
exporter("__rest", __rest);
|
||||
exporter("__decorate", __decorate);
|
||||
exporter("__param", __param);
|
||||
exporter("__metadata", __metadata);
|
||||
exporter("__awaiter", __awaiter);
|
||||
exporter("__generator", __generator);
|
||||
exporter("__exportStar", __exportStar);
|
||||
exporter("__createBinding", __createBinding);
|
||||
exporter("__values", __values);
|
||||
exporter("__read", __read);
|
||||
exporter("__spread", __spread);
|
||||
exporter("__spreadArrays", __spreadArrays);
|
||||
exporter("__await", __await);
|
||||
exporter("__asyncGenerator", __asyncGenerator);
|
||||
exporter("__asyncDelegator", __asyncDelegator);
|
||||
exporter("__asyncValues", __asyncValues);
|
||||
exporter("__makeTemplateObject", __makeTemplateObject);
|
||||
exporter("__importStar", __importStar);
|
||||
exporter("__importDefault", __importDefault);
|
||||
exporter("__classPrivateFieldGet", __classPrivateFieldGet);
|
||||
exporter("__classPrivateFieldSet", __classPrivateFieldSet);
|
||||
});
|
||||
@@ -0,0 +1,67 @@
|
||||
var __defProp = Object.defineProperty;
|
||||
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
||||
var __getOwnPropNames = Object.getOwnPropertyNames;
|
||||
var __hasOwnProp = Object.prototype.hasOwnProperty;
|
||||
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
|
||||
var __export = (target, all) => {
|
||||
for (var name in all)
|
||||
__defProp(target, name, { get: all[name], enumerable: true });
|
||||
};
|
||||
var __copyProps = (to, from, except, desc) => {
|
||||
if (from && typeof from === "object" || typeof from === "function") {
|
||||
for (let key of __getOwnPropNames(from))
|
||||
if (!__hasOwnProp.call(to, key) && key !== except)
|
||||
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
|
||||
}
|
||||
return to;
|
||||
};
|
||||
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
||||
|
||||
// src/index.ts
|
||||
var src_exports = {};
|
||||
__export(src_exports, {
|
||||
fromHex: () => fromHex,
|
||||
toHex: () => toHex
|
||||
});
|
||||
module.exports = __toCommonJS(src_exports);
|
||||
var SHORT_TO_HEX = {};
|
||||
var HEX_TO_SHORT = {};
|
||||
for (let i = 0; i < 256; i++) {
|
||||
let encodedByte = i.toString(16).toLowerCase();
|
||||
if (encodedByte.length === 1) {
|
||||
encodedByte = `0${encodedByte}`;
|
||||
}
|
||||
SHORT_TO_HEX[i] = encodedByte;
|
||||
HEX_TO_SHORT[encodedByte] = i;
|
||||
}
|
||||
function fromHex(encoded) {
|
||||
if (encoded.length % 2 !== 0) {
|
||||
throw new Error("Hex encoded strings must have an even number length");
|
||||
}
|
||||
const out = new Uint8Array(encoded.length / 2);
|
||||
for (let i = 0; i < encoded.length; i += 2) {
|
||||
const encodedByte = encoded.slice(i, i + 2).toLowerCase();
|
||||
if (encodedByte in HEX_TO_SHORT) {
|
||||
out[i / 2] = HEX_TO_SHORT[encodedByte];
|
||||
} else {
|
||||
throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
__name(fromHex, "fromHex");
|
||||
function toHex(bytes) {
|
||||
let out = "";
|
||||
for (let i = 0; i < bytes.byteLength; i++) {
|
||||
out += SHORT_TO_HEX[bytes[i]];
|
||||
}
|
||||
return out;
|
||||
}
|
||||
__name(toHex, "toHex");
|
||||
// Annotate the CommonJS export names for ESM import in node:
|
||||
|
||||
0 && (module.exports = {
|
||||
fromHex,
|
||||
toHex
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user