DMleadgen
46d973904b
Next.js website for Rocky Mountain Vending company featuring: - Product catalog with Stripe integration - Service areas and parts pages - Admin dashboard with Clerk authentication - SEO optimized pages with JSON-LD structured data Co-authored-by: Cursor <cursoragent@cursor.com>
1073 lines
38 KiB
Text
1073 lines
38 KiB
Text
'use strict';
|
|
|
|
var serde = require('@smithy/core/serde');
|
|
var utilUtf8 = require('@smithy/util-utf8');
|
|
var protocols = require('@smithy/core/protocols');
|
|
var protocolHttp = require('@smithy/protocol-http');
|
|
var utilBodyLengthBrowser = require('@smithy/util-body-length-browser');
|
|
var schema = require('@smithy/core/schema');
|
|
var utilMiddleware = require('@smithy/util-middleware');
|
|
var utilBase64 = require('@smithy/util-base64');
|
|
|
|
const majorUint64 = 0;
|
|
const majorNegativeInt64 = 1;
|
|
const majorUnstructuredByteString = 2;
|
|
const majorUtf8String = 3;
|
|
const majorList = 4;
|
|
const majorMap = 5;
|
|
const majorTag = 6;
|
|
const majorSpecial = 7;
|
|
const specialFalse = 20;
|
|
const specialTrue = 21;
|
|
const specialNull = 22;
|
|
const specialUndefined = 23;
|
|
const extendedOneByte = 24;
|
|
const extendedFloat16 = 25;
|
|
const extendedFloat32 = 26;
|
|
const extendedFloat64 = 27;
|
|
const minorIndefinite = 31;
|
|
function alloc(size) {
|
|
return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
|
|
}
|
|
const tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
|
|
function tag(data) {
|
|
data[tagSymbol] = true;
|
|
return data;
|
|
}
|
|
|
|
const USE_TEXT_DECODER = typeof TextDecoder !== "undefined";
|
|
const USE_BUFFER$1 = typeof Buffer !== "undefined";
|
|
let payload = alloc(0);
|
|
let dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
|
|
const textDecoder = USE_TEXT_DECODER ? new TextDecoder() : null;
|
|
let _offset = 0;
|
|
function setPayload(bytes) {
|
|
payload = bytes;
|
|
dataView$1 = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
|
|
}
|
|
function decode(at, to) {
|
|
if (at >= to) {
|
|
throw new Error("unexpected end of (decode) payload.");
|
|
}
|
|
const major = (payload[at] & 0b1110_0000) >> 5;
|
|
const minor = payload[at] & 0b0001_1111;
|
|
switch (major) {
|
|
case majorUint64:
|
|
case majorNegativeInt64:
|
|
case majorTag:
|
|
let unsignedInt;
|
|
let offset;
|
|
if (minor < 24) {
|
|
unsignedInt = minor;
|
|
offset = 1;
|
|
}
|
|
else {
|
|
switch (minor) {
|
|
case extendedOneByte:
|
|
case extendedFloat16:
|
|
case extendedFloat32:
|
|
case extendedFloat64:
|
|
const countLength = minorValueToArgumentLength[minor];
|
|
const countOffset = (countLength + 1);
|
|
offset = countOffset;
|
|
if (to - at < countOffset) {
|
|
throw new Error(`countLength ${countLength} greater than remaining buf len.`);
|
|
}
|
|
const countIndex = at + 1;
|
|
if (countLength === 1) {
|
|
unsignedInt = payload[countIndex];
|
|
}
|
|
else if (countLength === 2) {
|
|
unsignedInt = dataView$1.getUint16(countIndex);
|
|
}
|
|
else if (countLength === 4) {
|
|
unsignedInt = dataView$1.getUint32(countIndex);
|
|
}
|
|
else {
|
|
unsignedInt = dataView$1.getBigUint64(countIndex);
|
|
}
|
|
break;
|
|
default:
|
|
throw new Error(`unexpected minor value ${minor}.`);
|
|
}
|
|
}
|
|
if (major === majorUint64) {
|
|
_offset = offset;
|
|
return castBigInt(unsignedInt);
|
|
}
|
|
else if (major === majorNegativeInt64) {
|
|
let negativeInt;
|
|
if (typeof unsignedInt === "bigint") {
|
|
negativeInt = BigInt(-1) - unsignedInt;
|
|
}
|
|
else {
|
|
negativeInt = -1 - unsignedInt;
|
|
}
|
|
_offset = offset;
|
|
return castBigInt(negativeInt);
|
|
}
|
|
else {
|
|
if (minor === 2 || minor === 3) {
|
|
const length = decodeCount(at + offset, to);
|
|
let b = BigInt(0);
|
|
const start = at + offset + _offset;
|
|
for (let i = start; i < start + length; ++i) {
|
|
b = (b << BigInt(8)) | BigInt(payload[i]);
|
|
}
|
|
_offset = offset + _offset + length;
|
|
return minor === 3 ? -b - BigInt(1) : b;
|
|
}
|
|
else if (minor === 4) {
|
|
const decimalFraction = decode(at + offset, to);
|
|
const [exponent, mantissa] = decimalFraction;
|
|
const normalizer = mantissa < 0 ? -1 : 1;
|
|
const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + String(BigInt(normalizer) * BigInt(mantissa));
|
|
let numericString;
|
|
const sign = mantissa < 0 ? "-" : "";
|
|
numericString =
|
|
exponent === 0
|
|
? mantissaStr
|
|
: mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
|
|
numericString = numericString.replace(/^0+/g, "");
|
|
if (numericString === "") {
|
|
numericString = "0";
|
|
}
|
|
if (numericString[0] === ".") {
|
|
numericString = "0" + numericString;
|
|
}
|
|
numericString = sign + numericString;
|
|
_offset = offset + _offset;
|
|
return serde.nv(numericString);
|
|
}
|
|
else {
|
|
const value = decode(at + offset, to);
|
|
const valueOffset = _offset;
|
|
_offset = offset + valueOffset;
|
|
return tag({ tag: castBigInt(unsignedInt), value });
|
|
}
|
|
}
|
|
case majorUtf8String:
|
|
case majorMap:
|
|
case majorList:
|
|
case majorUnstructuredByteString:
|
|
if (minor === minorIndefinite) {
|
|
switch (major) {
|
|
case majorUtf8String:
|
|
return decodeUtf8StringIndefinite(at, to);
|
|
case majorMap:
|
|
return decodeMapIndefinite(at, to);
|
|
case majorList:
|
|
return decodeListIndefinite(at, to);
|
|
case majorUnstructuredByteString:
|
|
return decodeUnstructuredByteStringIndefinite(at, to);
|
|
}
|
|
}
|
|
else {
|
|
switch (major) {
|
|
case majorUtf8String:
|
|
return decodeUtf8String(at, to);
|
|
case majorMap:
|
|
return decodeMap(at, to);
|
|
case majorList:
|
|
return decodeList(at, to);
|
|
case majorUnstructuredByteString:
|
|
return decodeUnstructuredByteString(at, to);
|
|
}
|
|
}
|
|
default:
|
|
return decodeSpecial(at, to);
|
|
}
|
|
}
|
|
function bytesToUtf8(bytes, at, to) {
|
|
if (USE_BUFFER$1 && bytes.constructor?.name === "Buffer") {
|
|
return bytes.toString("utf-8", at, to);
|
|
}
|
|
if (textDecoder) {
|
|
return textDecoder.decode(bytes.subarray(at, to));
|
|
}
|
|
return utilUtf8.toUtf8(bytes.subarray(at, to));
|
|
}
|
|
function demote(bigInteger) {
|
|
const num = Number(bigInteger);
|
|
if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
|
|
console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
|
|
}
|
|
return num;
|
|
}
|
|
const minorValueToArgumentLength = {
|
|
[extendedOneByte]: 1,
|
|
[extendedFloat16]: 2,
|
|
[extendedFloat32]: 4,
|
|
[extendedFloat64]: 8,
|
|
};
|
|
function bytesToFloat16(a, b) {
|
|
const sign = a >> 7;
|
|
const exponent = (a & 0b0111_1100) >> 2;
|
|
const fraction = ((a & 0b0000_0011) << 8) | b;
|
|
const scalar = sign === 0 ? 1 : -1;
|
|
let exponentComponent;
|
|
let summation;
|
|
if (exponent === 0b00000) {
|
|
if (fraction === 0b00000_00000) {
|
|
return 0;
|
|
}
|
|
else {
|
|
exponentComponent = Math.pow(2, 1 - 15);
|
|
summation = 0;
|
|
}
|
|
}
|
|
else if (exponent === 0b11111) {
|
|
if (fraction === 0b00000_00000) {
|
|
return scalar * Infinity;
|
|
}
|
|
else {
|
|
return NaN;
|
|
}
|
|
}
|
|
else {
|
|
exponentComponent = Math.pow(2, exponent - 15);
|
|
summation = 1;
|
|
}
|
|
summation += fraction / 1024;
|
|
return scalar * (exponentComponent * summation);
|
|
}
|
|
function decodeCount(at, to) {
|
|
const minor = payload[at] & 0b0001_1111;
|
|
if (minor < 24) {
|
|
_offset = 1;
|
|
return minor;
|
|
}
|
|
if (minor === extendedOneByte ||
|
|
minor === extendedFloat16 ||
|
|
minor === extendedFloat32 ||
|
|
minor === extendedFloat64) {
|
|
const countLength = minorValueToArgumentLength[minor];
|
|
_offset = (countLength + 1);
|
|
if (to - at < _offset) {
|
|
throw new Error(`countLength ${countLength} greater than remaining buf len.`);
|
|
}
|
|
const countIndex = at + 1;
|
|
if (countLength === 1) {
|
|
return payload[countIndex];
|
|
}
|
|
else if (countLength === 2) {
|
|
return dataView$1.getUint16(countIndex);
|
|
}
|
|
else if (countLength === 4) {
|
|
return dataView$1.getUint32(countIndex);
|
|
}
|
|
return demote(dataView$1.getBigUint64(countIndex));
|
|
}
|
|
throw new Error(`unexpected minor value ${minor}.`);
|
|
}
|
|
function decodeUtf8String(at, to) {
|
|
const length = decodeCount(at, to);
|
|
const offset = _offset;
|
|
at += offset;
|
|
if (to - at < length) {
|
|
throw new Error(`string len ${length} greater than remaining buf len.`);
|
|
}
|
|
const value = bytesToUtf8(payload, at, at + length);
|
|
_offset = offset + length;
|
|
return value;
|
|
}
|
|
function decodeUtf8StringIndefinite(at, to) {
|
|
at += 1;
|
|
const vector = [];
|
|
for (const base = at; at < to;) {
|
|
if (payload[at] === 0b1111_1111) {
|
|
const data = alloc(vector.length);
|
|
data.set(vector, 0);
|
|
_offset = at - base + 2;
|
|
return bytesToUtf8(data, 0, data.length);
|
|
}
|
|
const major = (payload[at] & 0b1110_0000) >> 5;
|
|
const minor = payload[at] & 0b0001_1111;
|
|
if (major !== majorUtf8String) {
|
|
throw new Error(`unexpected major type ${major} in indefinite string.`);
|
|
}
|
|
if (minor === minorIndefinite) {
|
|
throw new Error("nested indefinite string.");
|
|
}
|
|
const bytes = decodeUnstructuredByteString(at, to);
|
|
const length = _offset;
|
|
at += length;
|
|
for (let i = 0; i < bytes.length; ++i) {
|
|
vector.push(bytes[i]);
|
|
}
|
|
}
|
|
throw new Error("expected break marker.");
|
|
}
|
|
function decodeUnstructuredByteString(at, to) {
|
|
const length = decodeCount(at, to);
|
|
const offset = _offset;
|
|
at += offset;
|
|
if (to - at < length) {
|
|
throw new Error(`unstructured byte string len ${length} greater than remaining buf len.`);
|
|
}
|
|
const value = payload.subarray(at, at + length);
|
|
_offset = offset + length;
|
|
return value;
|
|
}
|
|
function decodeUnstructuredByteStringIndefinite(at, to) {
|
|
at += 1;
|
|
const vector = [];
|
|
for (const base = at; at < to;) {
|
|
if (payload[at] === 0b1111_1111) {
|
|
const data = alloc(vector.length);
|
|
data.set(vector, 0);
|
|
_offset = at - base + 2;
|
|
return data;
|
|
}
|
|
const major = (payload[at] & 0b1110_0000) >> 5;
|
|
const minor = payload[at] & 0b0001_1111;
|
|
if (major !== majorUnstructuredByteString) {
|
|
throw new Error(`unexpected major type ${major} in indefinite string.`);
|
|
}
|
|
if (minor === minorIndefinite) {
|
|
throw new Error("nested indefinite string.");
|
|
}
|
|
const bytes = decodeUnstructuredByteString(at, to);
|
|
const length = _offset;
|
|
at += length;
|
|
for (let i = 0; i < bytes.length; ++i) {
|
|
vector.push(bytes[i]);
|
|
}
|
|
}
|
|
throw new Error("expected break marker.");
|
|
}
|
|
function decodeList(at, to) {
|
|
const listDataLength = decodeCount(at, to);
|
|
const offset = _offset;
|
|
at += offset;
|
|
const base = at;
|
|
const list = Array(listDataLength);
|
|
for (let i = 0; i < listDataLength; ++i) {
|
|
const item = decode(at, to);
|
|
const itemOffset = _offset;
|
|
list[i] = item;
|
|
at += itemOffset;
|
|
}
|
|
_offset = offset + (at - base);
|
|
return list;
|
|
}
|
|
function decodeListIndefinite(at, to) {
|
|
at += 1;
|
|
const list = [];
|
|
for (const base = at; at < to;) {
|
|
if (payload[at] === 0b1111_1111) {
|
|
_offset = at - base + 2;
|
|
return list;
|
|
}
|
|
const item = decode(at, to);
|
|
const n = _offset;
|
|
at += n;
|
|
list.push(item);
|
|
}
|
|
throw new Error("expected break marker.");
|
|
}
|
|
function decodeMap(at, to) {
|
|
const mapDataLength = decodeCount(at, to);
|
|
const offset = _offset;
|
|
at += offset;
|
|
const base = at;
|
|
const map = {};
|
|
for (let i = 0; i < mapDataLength; ++i) {
|
|
if (at >= to) {
|
|
throw new Error("unexpected end of map payload.");
|
|
}
|
|
const major = (payload[at] & 0b1110_0000) >> 5;
|
|
if (major !== majorUtf8String) {
|
|
throw new Error(`unexpected major type ${major} for map key at index ${at}.`);
|
|
}
|
|
const key = decode(at, to);
|
|
at += _offset;
|
|
const value = decode(at, to);
|
|
at += _offset;
|
|
map[key] = value;
|
|
}
|
|
_offset = offset + (at - base);
|
|
return map;
|
|
}
|
|
function decodeMapIndefinite(at, to) {
|
|
at += 1;
|
|
const base = at;
|
|
const map = {};
|
|
for (; at < to;) {
|
|
if (at >= to) {
|
|
throw new Error("unexpected end of map payload.");
|
|
}
|
|
if (payload[at] === 0b1111_1111) {
|
|
_offset = at - base + 2;
|
|
return map;
|
|
}
|
|
const major = (payload[at] & 0b1110_0000) >> 5;
|
|
if (major !== majorUtf8String) {
|
|
throw new Error(`unexpected major type ${major} for map key.`);
|
|
}
|
|
const key = decode(at, to);
|
|
at += _offset;
|
|
const value = decode(at, to);
|
|
at += _offset;
|
|
map[key] = value;
|
|
}
|
|
throw new Error("expected break marker.");
|
|
}
|
|
function decodeSpecial(at, to) {
|
|
const minor = payload[at] & 0b0001_1111;
|
|
switch (minor) {
|
|
case specialTrue:
|
|
case specialFalse:
|
|
_offset = 1;
|
|
return minor === specialTrue;
|
|
case specialNull:
|
|
_offset = 1;
|
|
return null;
|
|
case specialUndefined:
|
|
_offset = 1;
|
|
return null;
|
|
case extendedFloat16:
|
|
if (to - at < 3) {
|
|
throw new Error("incomplete float16 at end of buf.");
|
|
}
|
|
_offset = 3;
|
|
return bytesToFloat16(payload[at + 1], payload[at + 2]);
|
|
case extendedFloat32:
|
|
if (to - at < 5) {
|
|
throw new Error("incomplete float32 at end of buf.");
|
|
}
|
|
_offset = 5;
|
|
return dataView$1.getFloat32(at + 1);
|
|
case extendedFloat64:
|
|
if (to - at < 9) {
|
|
throw new Error("incomplete float64 at end of buf.");
|
|
}
|
|
_offset = 9;
|
|
return dataView$1.getFloat64(at + 1);
|
|
default:
|
|
throw new Error(`unexpected minor value ${minor}.`);
|
|
}
|
|
}
|
|
function castBigInt(bigInt) {
|
|
if (typeof bigInt === "number") {
|
|
return bigInt;
|
|
}
|
|
const num = Number(bigInt);
|
|
if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
|
|
return num;
|
|
}
|
|
return bigInt;
|
|
}
|
|
|
|
const USE_BUFFER = typeof Buffer !== "undefined";
|
|
const initialSize = 2048;
|
|
let data = alloc(initialSize);
|
|
let dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
let cursor = 0;
|
|
function ensureSpace(bytes) {
|
|
const remaining = data.byteLength - cursor;
|
|
if (remaining < bytes) {
|
|
if (cursor < 16_000_000) {
|
|
resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
|
|
}
|
|
else {
|
|
resize(data.byteLength + bytes + 16_000_000);
|
|
}
|
|
}
|
|
}
|
|
function toUint8Array() {
|
|
const out = alloc(cursor);
|
|
out.set(data.subarray(0, cursor), 0);
|
|
cursor = 0;
|
|
return out;
|
|
}
|
|
function resize(size) {
|
|
const old = data;
|
|
data = alloc(size);
|
|
if (old) {
|
|
if (old.copy) {
|
|
old.copy(data, 0, 0, old.byteLength);
|
|
}
|
|
else {
|
|
data.set(old, 0);
|
|
}
|
|
}
|
|
dataView = new DataView(data.buffer, data.byteOffset, data.byteLength);
|
|
}
|
|
function encodeHeader(major, value) {
|
|
if (value < 24) {
|
|
data[cursor++] = (major << 5) | value;
|
|
}
|
|
else if (value < 1 << 8) {
|
|
data[cursor++] = (major << 5) | 24;
|
|
data[cursor++] = value;
|
|
}
|
|
else if (value < 1 << 16) {
|
|
data[cursor++] = (major << 5) | extendedFloat16;
|
|
dataView.setUint16(cursor, value);
|
|
cursor += 2;
|
|
}
|
|
else if (value < 2 ** 32) {
|
|
data[cursor++] = (major << 5) | extendedFloat32;
|
|
dataView.setUint32(cursor, value);
|
|
cursor += 4;
|
|
}
|
|
else {
|
|
data[cursor++] = (major << 5) | extendedFloat64;
|
|
dataView.setBigUint64(cursor, typeof value === "bigint" ? value : BigInt(value));
|
|
cursor += 8;
|
|
}
|
|
}
|
|
function encode(_input) {
|
|
const encodeStack = [_input];
|
|
while (encodeStack.length) {
|
|
const input = encodeStack.pop();
|
|
ensureSpace(typeof input === "string" ? input.length * 4 : 64);
|
|
if (typeof input === "string") {
|
|
if (USE_BUFFER) {
|
|
encodeHeader(majorUtf8String, Buffer.byteLength(input));
|
|
cursor += data.write(input, cursor);
|
|
}
|
|
else {
|
|
const bytes = utilUtf8.fromUtf8(input);
|
|
encodeHeader(majorUtf8String, bytes.byteLength);
|
|
data.set(bytes, cursor);
|
|
cursor += bytes.byteLength;
|
|
}
|
|
continue;
|
|
}
|
|
else if (typeof input === "number") {
|
|
if (Number.isInteger(input)) {
|
|
const nonNegative = input >= 0;
|
|
const major = nonNegative ? majorUint64 : majorNegativeInt64;
|
|
const value = nonNegative ? input : -input - 1;
|
|
if (value < 24) {
|
|
data[cursor++] = (major << 5) | value;
|
|
}
|
|
else if (value < 256) {
|
|
data[cursor++] = (major << 5) | 24;
|
|
data[cursor++] = value;
|
|
}
|
|
else if (value < 65536) {
|
|
data[cursor++] = (major << 5) | extendedFloat16;
|
|
data[cursor++] = value >> 8;
|
|
data[cursor++] = value;
|
|
}
|
|
else if (value < 4294967296) {
|
|
data[cursor++] = (major << 5) | extendedFloat32;
|
|
dataView.setUint32(cursor, value);
|
|
cursor += 4;
|
|
}
|
|
else {
|
|
data[cursor++] = (major << 5) | extendedFloat64;
|
|
dataView.setBigUint64(cursor, BigInt(value));
|
|
cursor += 8;
|
|
}
|
|
continue;
|
|
}
|
|
data[cursor++] = (majorSpecial << 5) | extendedFloat64;
|
|
dataView.setFloat64(cursor, input);
|
|
cursor += 8;
|
|
continue;
|
|
}
|
|
else if (typeof input === "bigint") {
|
|
const nonNegative = input >= 0;
|
|
const major = nonNegative ? majorUint64 : majorNegativeInt64;
|
|
const value = nonNegative ? input : -input - BigInt(1);
|
|
const n = Number(value);
|
|
if (n < 24) {
|
|
data[cursor++] = (major << 5) | n;
|
|
}
|
|
else if (n < 256) {
|
|
data[cursor++] = (major << 5) | 24;
|
|
data[cursor++] = n;
|
|
}
|
|
else if (n < 65536) {
|
|
data[cursor++] = (major << 5) | extendedFloat16;
|
|
data[cursor++] = n >> 8;
|
|
data[cursor++] = n & 0b1111_1111;
|
|
}
|
|
else if (n < 4294967296) {
|
|
data[cursor++] = (major << 5) | extendedFloat32;
|
|
dataView.setUint32(cursor, n);
|
|
cursor += 4;
|
|
}
|
|
else if (value < BigInt("18446744073709551616")) {
|
|
data[cursor++] = (major << 5) | extendedFloat64;
|
|
dataView.setBigUint64(cursor, value);
|
|
cursor += 8;
|
|
}
|
|
else {
|
|
const binaryBigInt = value.toString(2);
|
|
const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
|
|
let b = value;
|
|
let i = 0;
|
|
while (bigIntBytes.byteLength - ++i >= 0) {
|
|
bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
|
|
b >>= BigInt(8);
|
|
}
|
|
ensureSpace(bigIntBytes.byteLength * 2);
|
|
data[cursor++] = nonNegative ? 0b110_00010 : 0b110_00011;
|
|
if (USE_BUFFER) {
|
|
encodeHeader(majorUnstructuredByteString, Buffer.byteLength(bigIntBytes));
|
|
}
|
|
else {
|
|
encodeHeader(majorUnstructuredByteString, bigIntBytes.byteLength);
|
|
}
|
|
data.set(bigIntBytes, cursor);
|
|
cursor += bigIntBytes.byteLength;
|
|
}
|
|
continue;
|
|
}
|
|
else if (input === null) {
|
|
data[cursor++] = (majorSpecial << 5) | specialNull;
|
|
continue;
|
|
}
|
|
else if (typeof input === "boolean") {
|
|
data[cursor++] = (majorSpecial << 5) | (input ? specialTrue : specialFalse);
|
|
continue;
|
|
}
|
|
else if (typeof input === "undefined") {
|
|
throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
|
|
}
|
|
else if (Array.isArray(input)) {
|
|
for (let i = input.length - 1; i >= 0; --i) {
|
|
encodeStack.push(input[i]);
|
|
}
|
|
encodeHeader(majorList, input.length);
|
|
continue;
|
|
}
|
|
else if (typeof input.byteLength === "number") {
|
|
ensureSpace(input.length * 2);
|
|
encodeHeader(majorUnstructuredByteString, input.length);
|
|
data.set(input, cursor);
|
|
cursor += input.byteLength;
|
|
continue;
|
|
}
|
|
else if (typeof input === "object") {
|
|
if (input instanceof serde.NumericValue) {
|
|
const decimalIndex = input.string.indexOf(".");
|
|
const exponent = decimalIndex === -1 ? 0 : decimalIndex - input.string.length + 1;
|
|
const mantissa = BigInt(input.string.replace(".", ""));
|
|
data[cursor++] = 0b110_00100;
|
|
encodeStack.push(mantissa);
|
|
encodeStack.push(exponent);
|
|
encodeHeader(majorList, 2);
|
|
continue;
|
|
}
|
|
if (input[tagSymbol]) {
|
|
if ("tag" in input && "value" in input) {
|
|
encodeStack.push(input.value);
|
|
encodeHeader(majorTag, input.tag);
|
|
continue;
|
|
}
|
|
else {
|
|
throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
|
|
}
|
|
}
|
|
const keys = Object.keys(input);
|
|
for (let i = keys.length - 1; i >= 0; --i) {
|
|
const key = keys[i];
|
|
encodeStack.push(input[key]);
|
|
encodeStack.push(key);
|
|
}
|
|
encodeHeader(majorMap, keys.length);
|
|
continue;
|
|
}
|
|
throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
|
|
}
|
|
}
|
|
|
|
const cbor = {
|
|
deserialize(payload) {
|
|
setPayload(payload);
|
|
return decode(0, payload.length);
|
|
},
|
|
serialize(input) {
|
|
try {
|
|
encode(input);
|
|
return toUint8Array();
|
|
}
|
|
catch (e) {
|
|
toUint8Array();
|
|
throw e;
|
|
}
|
|
},
|
|
resizeEncodingBuffer(size) {
|
|
resize(size);
|
|
},
|
|
};
|
|
|
|
const parseCborBody = (streamBody, context) => {
|
|
return protocols.collectBody(streamBody, context).then(async (bytes) => {
|
|
if (bytes.length) {
|
|
try {
|
|
return cbor.deserialize(bytes);
|
|
}
|
|
catch (e) {
|
|
Object.defineProperty(e, "$responseBodyText", {
|
|
value: context.utf8Encoder(bytes),
|
|
});
|
|
throw e;
|
|
}
|
|
}
|
|
return {};
|
|
});
|
|
};
|
|
const dateToTag = (date) => {
|
|
return tag({
|
|
tag: 1,
|
|
value: date.getTime() / 1000,
|
|
});
|
|
};
|
|
const parseCborErrorBody = async (errorBody, context) => {
|
|
const value = await parseCborBody(errorBody, context);
|
|
value.message = value.message ?? value.Message;
|
|
return value;
|
|
};
|
|
const loadSmithyRpcV2CborErrorCode = (output, data) => {
|
|
const sanitizeErrorCode = (rawValue) => {
|
|
let cleanValue = rawValue;
|
|
if (typeof cleanValue === "number") {
|
|
cleanValue = cleanValue.toString();
|
|
}
|
|
if (cleanValue.indexOf(",") >= 0) {
|
|
cleanValue = cleanValue.split(",")[0];
|
|
}
|
|
if (cleanValue.indexOf(":") >= 0) {
|
|
cleanValue = cleanValue.split(":")[0];
|
|
}
|
|
if (cleanValue.indexOf("#") >= 0) {
|
|
cleanValue = cleanValue.split("#")[1];
|
|
}
|
|
return cleanValue;
|
|
};
|
|
if (data["__type"] !== undefined) {
|
|
return sanitizeErrorCode(data["__type"]);
|
|
}
|
|
const codeKey = Object.keys(data).find((key) => key.toLowerCase() === "code");
|
|
if (codeKey && data[codeKey] !== undefined) {
|
|
return sanitizeErrorCode(data[codeKey]);
|
|
}
|
|
};
|
|
const checkCborResponse = (response) => {
|
|
if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
|
|
throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
|
|
}
|
|
};
|
|
const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
|
|
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
|
|
const contents = {
|
|
protocol,
|
|
hostname,
|
|
port,
|
|
method: "POST",
|
|
path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
|
|
headers: {
|
|
...headers,
|
|
},
|
|
};
|
|
if (resolvedHostname !== undefined) {
|
|
contents.hostname = resolvedHostname;
|
|
}
|
|
if (body !== undefined) {
|
|
contents.body = body;
|
|
try {
|
|
contents.headers["content-length"] = String(utilBodyLengthBrowser.calculateBodyLength(body));
|
|
}
|
|
catch (e) { }
|
|
}
|
|
return new protocolHttp.HttpRequest(contents);
|
|
};
|
|
|
|
class CborCodec extends protocols.SerdeContext {
|
|
createSerializer() {
|
|
const serializer = new CborShapeSerializer();
|
|
serializer.setSerdeContext(this.serdeContext);
|
|
return serializer;
|
|
}
|
|
createDeserializer() {
|
|
const deserializer = new CborShapeDeserializer();
|
|
deserializer.setSerdeContext(this.serdeContext);
|
|
return deserializer;
|
|
}
|
|
}
|
|
class CborShapeSerializer extends protocols.SerdeContext {
|
|
value;
|
|
write(schema, value) {
|
|
this.value = this.serialize(schema, value);
|
|
}
|
|
serialize(schema$1, source) {
|
|
const ns = schema.NormalizedSchema.of(schema$1);
|
|
if (source == null) {
|
|
if (ns.isIdempotencyToken()) {
|
|
return serde.generateIdempotencyToken();
|
|
}
|
|
return source;
|
|
}
|
|
if (ns.isBlobSchema()) {
|
|
if (typeof source === "string") {
|
|
return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(source);
|
|
}
|
|
return source;
|
|
}
|
|
if (ns.isTimestampSchema()) {
|
|
if (typeof source === "number" || typeof source === "bigint") {
|
|
return dateToTag(new Date((Number(source) / 1000) | 0));
|
|
}
|
|
return dateToTag(source);
|
|
}
|
|
if (typeof source === "function" || typeof source === "object") {
|
|
const sourceObject = source;
|
|
if (ns.isListSchema() && Array.isArray(sourceObject)) {
|
|
const sparse = !!ns.getMergedTraits().sparse;
|
|
const newArray = [];
|
|
let i = 0;
|
|
for (const item of sourceObject) {
|
|
const value = this.serialize(ns.getValueSchema(), item);
|
|
if (value != null || sparse) {
|
|
newArray[i++] = value;
|
|
}
|
|
}
|
|
return newArray;
|
|
}
|
|
if (sourceObject instanceof Date) {
|
|
return dateToTag(sourceObject);
|
|
}
|
|
const newObject = {};
|
|
if (ns.isMapSchema()) {
|
|
const sparse = !!ns.getMergedTraits().sparse;
|
|
for (const key of Object.keys(sourceObject)) {
|
|
const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
|
|
if (value != null || sparse) {
|
|
newObject[key] = value;
|
|
}
|
|
}
|
|
}
|
|
else if (ns.isStructSchema()) {
|
|
for (const [key, memberSchema] of ns.structIterator()) {
|
|
const value = this.serialize(memberSchema, sourceObject[key]);
|
|
if (value != null) {
|
|
newObject[key] = value;
|
|
}
|
|
}
|
|
const isUnion = ns.isUnionSchema();
|
|
if (isUnion && Array.isArray(sourceObject.$unknown)) {
|
|
const [k, v] = sourceObject.$unknown;
|
|
newObject[k] = v;
|
|
}
|
|
}
|
|
else if (ns.isDocumentSchema()) {
|
|
for (const key of Object.keys(sourceObject)) {
|
|
newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
|
|
}
|
|
}
|
|
return newObject;
|
|
}
|
|
return source;
|
|
}
|
|
flush() {
|
|
const buffer = cbor.serialize(this.value);
|
|
this.value = undefined;
|
|
return buffer;
|
|
}
|
|
}
|
|
class CborShapeDeserializer extends protocols.SerdeContext {
|
|
read(schema, bytes) {
|
|
const data = cbor.deserialize(bytes);
|
|
return this.readValue(schema, data);
|
|
}
|
|
readValue(_schema, value) {
|
|
const ns = schema.NormalizedSchema.of(_schema);
|
|
if (ns.isTimestampSchema()) {
|
|
if (typeof value === "number") {
|
|
return serde._parseEpochTimestamp(value);
|
|
}
|
|
if (typeof value === "object") {
|
|
if (value.tag === 1 && "value" in value) {
|
|
return serde._parseEpochTimestamp(value.value);
|
|
}
|
|
}
|
|
}
|
|
if (ns.isBlobSchema()) {
|
|
if (typeof value === "string") {
|
|
return (this.serdeContext?.base64Decoder ?? utilBase64.fromBase64)(value);
|
|
}
|
|
return value;
|
|
}
|
|
if (typeof value === "undefined" ||
|
|
typeof value === "boolean" ||
|
|
typeof value === "number" ||
|
|
typeof value === "string" ||
|
|
typeof value === "bigint" ||
|
|
typeof value === "symbol") {
|
|
return value;
|
|
}
|
|
else if (typeof value === "object") {
|
|
if (value === null) {
|
|
return null;
|
|
}
|
|
if ("byteLength" in value) {
|
|
return value;
|
|
}
|
|
if (value instanceof Date) {
|
|
return value;
|
|
}
|
|
if (ns.isDocumentSchema()) {
|
|
return value;
|
|
}
|
|
if (ns.isListSchema()) {
|
|
const newArray = [];
|
|
const memberSchema = ns.getValueSchema();
|
|
const sparse = !!ns.getMergedTraits().sparse;
|
|
for (const item of value) {
|
|
const itemValue = this.readValue(memberSchema, item);
|
|
if (itemValue != null || sparse) {
|
|
newArray.push(itemValue);
|
|
}
|
|
}
|
|
return newArray;
|
|
}
|
|
const newObject = {};
|
|
if (ns.isMapSchema()) {
|
|
const sparse = !!ns.getMergedTraits().sparse;
|
|
const targetSchema = ns.getValueSchema();
|
|
for (const key of Object.keys(value)) {
|
|
const itemValue = this.readValue(targetSchema, value[key]);
|
|
if (itemValue != null || sparse) {
|
|
newObject[key] = itemValue;
|
|
}
|
|
}
|
|
}
|
|
else if (ns.isStructSchema()) {
|
|
const isUnion = ns.isUnionSchema();
|
|
let keys;
|
|
if (isUnion) {
|
|
keys = new Set(Object.keys(value).filter((k) => k !== "__type"));
|
|
}
|
|
for (const [key, memberSchema] of ns.structIterator()) {
|
|
if (isUnion) {
|
|
keys.delete(key);
|
|
}
|
|
if (value[key] != null) {
|
|
newObject[key] = this.readValue(memberSchema, value[key]);
|
|
}
|
|
}
|
|
if (isUnion && keys?.size === 1 && Object.keys(newObject).length === 0) {
|
|
const k = keys.values().next().value;
|
|
newObject.$unknown = [k, value[k]];
|
|
}
|
|
}
|
|
return newObject;
|
|
}
|
|
else {
|
|
return value;
|
|
}
|
|
}
|
|
}
|
|
|
|
class SmithyRpcV2CborProtocol extends protocols.RpcProtocol {
|
|
codec = new CborCodec();
|
|
serializer = this.codec.createSerializer();
|
|
deserializer = this.codec.createDeserializer();
|
|
constructor({ defaultNamespace }) {
|
|
super({ defaultNamespace });
|
|
}
|
|
getShapeId() {
|
|
return "smithy.protocols#rpcv2Cbor";
|
|
}
|
|
getPayloadCodec() {
|
|
return this.codec;
|
|
}
|
|
async serializeRequest(operationSchema, input, context) {
|
|
const request = await super.serializeRequest(operationSchema, input, context);
|
|
Object.assign(request.headers, {
|
|
"content-type": this.getDefaultContentType(),
|
|
"smithy-protocol": "rpc-v2-cbor",
|
|
accept: this.getDefaultContentType(),
|
|
});
|
|
if (schema.deref(operationSchema.input) === "unit") {
|
|
delete request.body;
|
|
delete request.headers["content-type"];
|
|
}
|
|
else {
|
|
if (!request.body) {
|
|
this.serializer.write(15, {});
|
|
request.body = this.serializer.flush();
|
|
}
|
|
try {
|
|
request.headers["content-length"] = String(request.body.byteLength);
|
|
}
|
|
catch (e) { }
|
|
}
|
|
const { service, operation } = utilMiddleware.getSmithyContext(context);
|
|
const path = `/service/${service}/operation/${operation}`;
|
|
if (request.path.endsWith("/")) {
|
|
request.path += path.slice(1);
|
|
}
|
|
else {
|
|
request.path += path;
|
|
}
|
|
return request;
|
|
}
|
|
async deserializeResponse(operationSchema, context, response) {
|
|
return super.deserializeResponse(operationSchema, context, response);
|
|
}
|
|
async handleError(operationSchema, context, response, dataObject, metadata) {
|
|
const errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
|
|
let namespace = this.options.defaultNamespace;
|
|
if (errorName.includes("#")) {
|
|
[namespace] = errorName.split("#");
|
|
}
|
|
const errorMetadata = {
|
|
$metadata: metadata,
|
|
$fault: response.statusCode <= 500 ? "client" : "server",
|
|
};
|
|
const registry = schema.TypeRegistry.for(namespace);
|
|
let errorSchema;
|
|
try {
|
|
errorSchema = registry.getSchema(errorName);
|
|
}
|
|
catch (e) {
|
|
if (dataObject.Message) {
|
|
dataObject.message = dataObject.Message;
|
|
}
|
|
const synthetic = schema.TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
|
|
const baseExceptionSchema = synthetic.getBaseException();
|
|
if (baseExceptionSchema) {
|
|
const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema);
|
|
throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
|
|
}
|
|
throw Object.assign(new Error(errorName), errorMetadata, dataObject);
|
|
}
|
|
const ns = schema.NormalizedSchema.of(errorSchema);
|
|
const ErrorCtor = registry.getErrorCtor(errorSchema);
|
|
const message = dataObject.message ?? dataObject.Message ?? "Unknown";
|
|
const exception = new ErrorCtor(message);
|
|
const output = {};
|
|
for (const [name, member] of ns.structIterator()) {
|
|
output[name] = this.deserializer.readValue(member, dataObject[name]);
|
|
}
|
|
throw Object.assign(exception, errorMetadata, {
|
|
$fault: ns.getMergedTraits().error,
|
|
message,
|
|
}, output);
|
|
}
|
|
getDefaultContentType() {
|
|
return "application/cbor";
|
|
}
|
|
}
|
|
|
|
exports.CborCodec = CborCodec;
|
|
exports.CborShapeDeserializer = CborShapeDeserializer;
|
|
exports.CborShapeSerializer = CborShapeSerializer;
|
|
exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol;
|
|
exports.buildHttpRpcRequest = buildHttpRpcRequest;
|
|
exports.cbor = cbor;
|
|
exports.checkCborResponse = checkCborResponse;
|
|
exports.dateToTag = dateToTag;
|
|
exports.loadSmithyRpcV2CborErrorCode = loadSmithyRpcV2CborErrorCode;
|
|
exports.parseCborBody = parseCborBody;
|
|
exports.parseCborErrorBody = parseCborErrorBody;
|
|
exports.tag = tag;
|
|
exports.tagSymbol = tagSymbol;
|