web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/pvtsutils/build/index.js

@@ -0,0 +1,408 @@
+import { __exports as build } from '../../../_virtual/index12.js';
+
+/*!
+ * MIT License
+ * 
+ * Copyright (c) 2017-2024 Peculiar Ventures, LLC
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+var hasRequiredBuild;
+function requireBuild() {
+  if (hasRequiredBuild) return build;
+  hasRequiredBuild = 1;
+  const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+  class BufferSourceConverter {
+    static isArrayBuffer(data) {
+      return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+    }
+    static toArrayBuffer(data) {
+      if (this.isArrayBuffer(data)) {
+        return data;
+      }
+      if (data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      return this.toUint8Array(data.buffer).slice(data.byteOffset, data.byteOffset + data.byteLength).buffer;
+    }
+    static toUint8Array(data) {
+      return this.toView(data, Uint8Array);
+    }
+    static toView(data, type) {
+      if (data.constructor === type) {
+        return data;
+      }
+      if (this.isArrayBuffer(data)) {
+        return new type(data);
+      }
+      if (this.isArrayBufferView(data)) {
+        return new type(data.buffer, data.byteOffset, data.byteLength);
+      }
+      throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
+    }
+    static isBufferSource(data) {
+      return this.isArrayBufferView(data) || this.isArrayBuffer(data);
+    }
+    static isArrayBufferView(data) {
+      return ArrayBuffer.isView(data) || data && this.isArrayBuffer(data.buffer);
+    }
+    static isEqual(a, b) {
+      const aView = BufferSourceConverter.toUint8Array(a);
+      const bView = BufferSourceConverter.toUint8Array(b);
+      if (aView.length !== bView.byteLength) {
+        return false;
+      }
+      for (let i = 0; i < aView.length; i++) {
+        if (aView[i] !== bView[i]) {
+          return false;
+        }
+      }
+      return true;
+    }
+    static concat() {
+      let buffers;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
+        buffers = args[0];
+      } else if (Array.isArray(args[0]) && args[1] instanceof Function) {
+        buffers = args[0];
+      } else {
+        if (args[args.length - 1] instanceof Function) {
+          buffers = args.slice(0, args.length - 1);
+        } else {
+          buffers = args;
+        }
+      }
+      let size = 0;
+      for (const buffer of buffers) {
+        size += buffer.byteLength;
+      }
+      const res = new Uint8Array(size);
+      let offset = 0;
+      for (const buffer of buffers) {
+        const view = this.toUint8Array(buffer);
+        res.set(view, offset);
+        offset += view.length;
+      }
+      if (args[args.length - 1] instanceof Function) {
+        return this.toView(res, args[args.length - 1]);
+      }
+      return res.buffer;
+    }
+  }
+  const STRING_TYPE = "string";
+  const HEX_REGEX = /^[0-9a-f\s]+$/i;
+  const BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+  const BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
+  class Utf8Converter {
+    static fromString(text) {
+      const s = unescape(encodeURIComponent(text));
+      const uintArray = new Uint8Array(s.length);
+      for (let i = 0; i < s.length; i++) {
+        uintArray[i] = s.charCodeAt(i);
+      }
+      return uintArray.buffer;
+    }
+    static toString(buffer) {
+      const buf = BufferSourceConverter.toUint8Array(buffer);
+      let encodedString = "";
+      for (let i = 0; i < buf.length; i++) {
+        encodedString += String.fromCharCode(buf[i]);
+      }
+      const decodedString = decodeURIComponent(escape(encodedString));
+      return decodedString;
+    }
+  }
+  class Utf16Converter {
+    static toString(buffer) {
+      let littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
+      const dataView = new DataView(arrayBuffer);
+      let res = "";
+      for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
+        const code = dataView.getUint16(i, littleEndian);
+        res += String.fromCharCode(code);
+      }
+      return res;
+    }
+    static fromString(text) {
+      let littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      const res = new ArrayBuffer(text.length * 2);
+      const dataView = new DataView(res);
+      for (let i = 0; i < text.length; i++) {
+        dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+      }
+      return res;
+    }
+  }
+  class Convert {
+    static isHex(data) {
+      return typeof data === STRING_TYPE && HEX_REGEX.test(data);
+    }
+    static isBase64(data) {
+      return typeof data === STRING_TYPE && BASE64_REGEX.test(data);
+    }
+    static isBase64Url(data) {
+      return typeof data === STRING_TYPE && BASE64URL_REGEX.test(data);
+    }
+    static ToString(buffer) {
+      let enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
+      const buf = BufferSourceConverter.toUint8Array(buffer);
+      switch (enc.toLowerCase()) {
+        case "utf8":
+          return this.ToUtf8String(buf);
+        case "binary":
+          return this.ToBinary(buf);
+        case "hex":
+          return this.ToHex(buf);
+        case "base64":
+          return this.ToBase64(buf);
+        case "base64url":
+          return this.ToBase64Url(buf);
+        case "utf16le":
+          return Utf16Converter.toString(buf, true);
+        case "utf16":
+        case "utf16be":
+          return Utf16Converter.toString(buf);
+        default:
+          throw new Error(`Unknown type of encoding '${enc}'`);
+      }
+    }
+    static FromString(str) {
+      let enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
+      if (!str) {
+        return new ArrayBuffer(0);
+      }
+      switch (enc.toLowerCase()) {
+        case "utf8":
+          return this.FromUtf8String(str);
+        case "binary":
+          return this.FromBinary(str);
+        case "hex":
+          return this.FromHex(str);
+        case "base64":
+          return this.FromBase64(str);
+        case "base64url":
+          return this.FromBase64Url(str);
+        case "utf16le":
+          return Utf16Converter.fromString(str, true);
+        case "utf16":
+        case "utf16be":
+          return Utf16Converter.fromString(str);
+        default:
+          throw new Error(`Unknown type of encoding '${enc}'`);
+      }
+    }
+    static ToBase64(buffer) {
+      const buf = BufferSourceConverter.toUint8Array(buffer);
+      if (typeof btoa !== "undefined") {
+        const binary = this.ToString(buf, "binary");
+        return btoa(binary);
+      } else {
+        return Buffer.from(buf).toString("base64");
+      }
+    }
+    static FromBase64(base64) {
+      const formatted = this.formatString(base64);
+      if (!formatted) {
+        return new ArrayBuffer(0);
+      }
+      if (!Convert.isBase64(formatted)) {
+        throw new TypeError("Argument 'base64Text' is not Base64 encoded");
+      }
+      if (typeof atob !== "undefined") {
+        return this.FromBinary(atob(formatted));
+      } else {
+        return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
+      }
+    }
+    static FromBase64Url(base64url) {
+      const formatted = this.formatString(base64url);
+      if (!formatted) {
+        return new ArrayBuffer(0);
+      }
+      if (!Convert.isBase64Url(formatted)) {
+        throw new TypeError("Argument 'base64url' is not Base64Url encoded");
+      }
+      return this.FromBase64(this.Base64Padding(formatted.replace(/\-/g, "+").replace(/\_/g, "/")));
+    }
+    static ToBase64Url(data) {
+      return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+    }
+    static FromUtf8String(text) {
+      let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Convert.DEFAULT_UTF8_ENCODING;
+      switch (encoding) {
+        case "ascii":
+          return this.FromBinary(text);
+        case "utf8":
+          return Utf8Converter.fromString(text);
+        case "utf16":
+        case "utf16be":
+          return Utf16Converter.fromString(text);
+        case "utf16le":
+        case "usc2":
+          return Utf16Converter.fromString(text, true);
+        default:
+          throw new Error(`Unknown type of encoding '${encoding}'`);
+      }
+    }
+    static ToUtf8String(buffer) {
+      let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Convert.DEFAULT_UTF8_ENCODING;
+      switch (encoding) {
+        case "ascii":
+          return this.ToBinary(buffer);
+        case "utf8":
+          return Utf8Converter.toString(buffer);
+        case "utf16":
+        case "utf16be":
+          return Utf16Converter.toString(buffer);
+        case "utf16le":
+        case "usc2":
+          return Utf16Converter.toString(buffer, true);
+        default:
+          throw new Error(`Unknown type of encoding '${encoding}'`);
+      }
+    }
+    static FromBinary(text) {
+      const stringLength = text.length;
+      const resultView = new Uint8Array(stringLength);
+      for (let i = 0; i < stringLength; i++) {
+        resultView[i] = text.charCodeAt(i);
+      }
+      return resultView.buffer;
+    }
+    static ToBinary(buffer) {
+      const buf = BufferSourceConverter.toUint8Array(buffer);
+      let res = "";
+      for (let i = 0; i < buf.length; i++) {
+        res += String.fromCharCode(buf[i]);
+      }
+      return res;
+    }
+    static ToHex(buffer) {
+      const buf = BufferSourceConverter.toUint8Array(buffer);
+      let result = "";
+      const len = buf.length;
+      for (let i = 0; i < len; i++) {
+        const byte = buf[i];
+        if (byte < 16) {
+          result += "0";
+        }
+        result += byte.toString(16);
+      }
+      return result;
+    }
+    static FromHex(hexString) {
+      let formatted = this.formatString(hexString);
+      if (!formatted) {
+        return new ArrayBuffer(0);
+      }
+      if (!Convert.isHex(formatted)) {
+        throw new TypeError("Argument 'hexString' is not HEX encoded");
+      }
+      if (formatted.length % 2) {
+        formatted = `0${formatted}`;
+      }
+      const res = new Uint8Array(formatted.length / 2);
+      for (let i = 0; i < formatted.length; i = i + 2) {
+        const c = formatted.slice(i, i + 2);
+        res[i / 2] = parseInt(c, 16);
+      }
+      return res.buffer;
+    }
+    static ToUtf16String(buffer) {
+      let littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return Utf16Converter.toString(buffer, littleEndian);
+    }
+    static FromUtf16String(text) {
+      let littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      return Utf16Converter.fromString(text, littleEndian);
+    }
+    static Base64Padding(base64) {
+      const padCount = 4 - base64.length % 4;
+      if (padCount < 4) {
+        for (let i = 0; i < padCount; i++) {
+          base64 += "=";
+        }
+      }
+      return base64;
+    }
+    static formatString(data) {
+      return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
+    }
+  }
+  Convert.DEFAULT_UTF8_ENCODING = "utf8";
+  function assign(target) {
+    for (var _len2 = arguments.length, sources = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+      sources[_key2 - 1] = arguments[_key2];
+    }
+    const res = arguments[0];
+    for (let i = 1; i < arguments.length; i++) {
+      const obj = arguments[i];
+      for (const prop in obj) {
+        res[prop] = obj[prop];
+      }
+    }
+    return res;
+  }
+  function combine() {
+    for (var _len3 = arguments.length, buf = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+      buf[_key3] = arguments[_key3];
+    }
+    const totalByteLength = buf.map(item => item.byteLength).reduce((prev, cur) => prev + cur);
+    const res = new Uint8Array(totalByteLength);
+    let currentPos = 0;
+    buf.map(item => new Uint8Array(item)).forEach(arr => {
+      for (const item2 of arr) {
+        res[currentPos++] = item2;
+      }
+    });
+    return res.buffer;
+  }
+  function isEqual(bytes1, bytes2) {
+    if (!(bytes1 && bytes2)) {
+      return false;
+    }
+    if (bytes1.byteLength !== bytes2.byteLength) {
+      return false;
+    }
+    const b1 = new Uint8Array(bytes1);
+    const b2 = new Uint8Array(bytes2);
+    for (let i = 0; i < bytes1.byteLength; i++) {
+      if (b1[i] !== b2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  build.BufferSourceConverter = BufferSourceConverter;
+  build.Convert = Convert;
+  build.assign = assign;
+  build.combine = combine;
+  build.isEqual = isEqual;
+  return build;
+}
+
+export { requireBuild as __require };

package/dist/esm/node_modules/pvutils/build/utils.es.js

@@ -0,0 +1,145 @@
+/*!
+ Copyright (c) Peculiar Ventures, LLC
+*/
+
+function utilFromBase(inputBuffer, inputBase) {
+  let result = 0;
+  if (inputBuffer.length === 1) {
+    return inputBuffer[0];
+  }
+  for (let i = inputBuffer.length - 1; i >= 0; i--) {
+    result += inputBuffer[inputBuffer.length - 1 - i] * Math.pow(2, inputBase * i);
+  }
+  return result;
+}
+function utilToBase(value, base) {
+  let reserved = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
+  const internalReserved = reserved;
+  let internalValue = value;
+  let result = 0;
+  let biggest = Math.pow(2, base);
+  for (let i = 1; i < 8; i++) {
+    if (value < biggest) {
+      let retBuf;
+      if (internalReserved < 0) {
+        retBuf = new ArrayBuffer(i);
+        result = i;
+      } else {
+        if (internalReserved < i) {
+          return new ArrayBuffer(0);
+        }
+        retBuf = new ArrayBuffer(internalReserved);
+        result = internalReserved;
+      }
+      const retView = new Uint8Array(retBuf);
+      for (let j = i - 1; j >= 0; j--) {
+        const basis = Math.pow(2, j * base);
+        retView[result - j - 1] = Math.floor(internalValue / basis);
+        internalValue -= retView[result - j - 1] * basis;
+      }
+      return retBuf;
+    }
+    biggest *= Math.pow(2, base);
+  }
+  return new ArrayBuffer(0);
+}
+function utilConcatView() {
+  let outputLength = 0;
+  let prevLength = 0;
+  for (var _len2 = arguments.length, views = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    views[_key2] = arguments[_key2];
+  }
+  for (const view of views) {
+    outputLength += view.length;
+  }
+  const retBuf = new ArrayBuffer(outputLength);
+  const retView = new Uint8Array(retBuf);
+  for (const view of views) {
+    retView.set(view, prevLength);
+    prevLength += view.length;
+  }
+  return retView;
+}
+function utilDecodeTC() {
+  const buf = new Uint8Array(this.valueHex);
+  if (this.valueHex.byteLength >= 2) {
+    const condition1 = buf[0] === 0xFF && buf[1] & 0x80;
+    const condition2 = buf[0] === 0x00 && (buf[1] & 0x80) === 0x00;
+    if (condition1 || condition2) {
+      this.warnings.push("Needlessly long format");
+    }
+  }
+  const bigIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
+  const bigIntView = new Uint8Array(bigIntBuffer);
+  for (let i = 0; i < this.valueHex.byteLength; i++) {
+    bigIntView[i] = 0;
+  }
+  bigIntView[0] = buf[0] & 0x80;
+  const bigInt = utilFromBase(bigIntView, 8);
+  const smallIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
+  const smallIntView = new Uint8Array(smallIntBuffer);
+  for (let j = 0; j < this.valueHex.byteLength; j++) {
+    smallIntView[j] = buf[j];
+  }
+  smallIntView[0] &= 0x7F;
+  const smallInt = utilFromBase(smallIntView, 8);
+  return smallInt - bigInt;
+}
+function utilEncodeTC(value) {
+  const modValue = value < 0 ? value * -1 : value;
+  let bigInt = 128;
+  for (let i = 1; i < 8; i++) {
+    if (modValue <= bigInt) {
+      if (value < 0) {
+        const smallInt = bigInt - modValue;
+        const retBuf = utilToBase(smallInt, 8, i);
+        const retView = new Uint8Array(retBuf);
+        retView[0] |= 0x80;
+        return retBuf;
+      }
+      let retBuf = utilToBase(modValue, 8, i);
+      let retView = new Uint8Array(retBuf);
+      if (retView[0] & 0x80) {
+        const tempBuf = retBuf.slice(0);
+        const tempView = new Uint8Array(tempBuf);
+        retBuf = new ArrayBuffer(retBuf.byteLength + 1);
+        retView = new Uint8Array(retBuf);
+        for (let k = 0; k < tempBuf.byteLength; k++) {
+          retView[k + 1] = tempView[k];
+        }
+        retView[0] = 0x00;
+      }
+      return retBuf;
+    }
+    bigInt *= Math.pow(2, 8);
+  }
+  return new ArrayBuffer(0);
+}
+function isEqualBuffer(inputBuffer1, inputBuffer2) {
+  if (inputBuffer1.byteLength !== inputBuffer2.byteLength) {
+    return false;
+  }
+  const view1 = new Uint8Array(inputBuffer1);
+  const view2 = new Uint8Array(inputBuffer2);
+  for (let i = 0; i < view1.length; i++) {
+    if (view1[i] !== view2[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+function padNumber(inputNumber, fullLength) {
+  const str = inputNumber.toString(10);
+  if (fullLength < str.length) {
+    return "";
+  }
+  const dif = fullLength - str.length;
+  const padding = new Array(dif);
+  for (let i = 0; i < dif; i++) {
+    padding[i] = "0";
+  }
+  const paddingString = padding.join("");
+  return paddingString.concat(str);
+}
+
+export { isEqualBuffer, padNumber, utilConcatView, utilDecodeTC, utilEncodeTC, utilFromBase, utilToBase };