From e06ec920f7a5d784e674c4c4b4e6d1da3dc7391d Mon Sep 17 00:00:00 2001
From: Piotr Russ <mail@pruss.it>
Date: Mon, 16 Nov 2020 00:10:28 +0100
Subject: api, login, auth

---
 node_modules/@webassemblyjs/leb128/lib/bufs.js | 236 +++++++++++++++++++++++++
 1 file changed, 236 insertions(+)
 create mode 100644 node_modules/@webassemblyjs/leb128/lib/bufs.js

(limited to 'node_modules/@webassemblyjs/leb128/lib/bufs.js')

diff --git a/node_modules/@webassemblyjs/leb128/lib/bufs.js b/node_modules/@webassemblyjs/leb128/lib/bufs.js
new file mode 100644
index 0000000..f9a176e
--- /dev/null
+++ b/node_modules/@webassemblyjs/leb128/lib/bufs.js
@@ -0,0 +1,236 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.alloc = alloc;
+exports.free = free;
+exports.resize = resize;
+exports.readInt = readInt;
+exports.readUInt = readUInt;
+exports.writeInt64 = writeInt64;
+exports.writeUInt64 = writeUInt64;
+// Copyright 2012 The Obvious Corporation.
+
+/*
+ * bufs: Buffer utilities.
+ */
+
+/*
+ * Module variables
+ */
+
+/** Pool of buffers, where `bufPool[x].length === x`. */
+var bufPool = [];
+/** Maximum length of kept temporary buffers. */
+
+var TEMP_BUF_MAXIMUM_LENGTH = 20;
+/** Minimum exactly-representable 64-bit int. */
+
+var MIN_EXACT_INT64 = -0x8000000000000000;
+/** Maximum exactly-representable 64-bit int. */
+
+var MAX_EXACT_INT64 = 0x7ffffffffffffc00;
+/** Maximum exactly-representable 64-bit uint. */
+
+var MAX_EXACT_UINT64 = 0xfffffffffffff800;
+/**
+ * The int value consisting just of a 1 in bit #32 (that is, one more
+ * than the maximum 32-bit unsigned value).
+ */
+
+var BIT_32 = 0x100000000;
+/**
+ * The int value consisting just of a 1 in bit #64 (that is, one more
+ * than the maximum 64-bit unsigned value).
+ */
+
+var BIT_64 = 0x10000000000000000;
+/*
+ * Helper functions
+ */
+
+/**
+ * Masks off all but the lowest bit set of the given number.
+ */
+
+function lowestBit(num) {
+  return num & -num;
+}
+/**
+ * Gets whether trying to add the second number to the first is lossy
+ * (inexact). The first number is meant to be an accumulated result.
+ */
+
+
+function isLossyToAdd(accum, num) {
+  if (num === 0) {
+    return false;
+  }
+
+  var lowBit = lowestBit(num);
+  var added = accum + lowBit;
+
+  if (added === accum) {
+    return true;
+  }
+
+  if (added - lowBit !== accum) {
+    return true;
+  }
+
+  return false;
+}
+/*
+ * Exported functions
+ */
+
+/**
+ * Allocates a buffer of the given length, which is initialized
+ * with all zeroes. This returns a buffer from the pool if it is
+ * available, or a freshly-allocated buffer if not.
+ */
+
+
+function alloc(length) {
+  var result = bufPool[length];
+
+  if (result) {
+    bufPool[length] = undefined;
+  } else {
+    result = new Buffer(length);
+  }
+
+  result.fill(0);
+  return result;
+}
+/**
+ * Releases a buffer back to the pool.
+ */
+
+
+function free(buffer) {
+  var length = buffer.length;
+
+  if (length < TEMP_BUF_MAXIMUM_LENGTH) {
+    bufPool[length] = buffer;
+  }
+}
+/**
+ * Resizes a buffer, returning a new buffer. Returns the argument if
+ * the length wouldn't actually change. This function is only safe to
+ * use if the given buffer was allocated within this module (since
+ * otherwise the buffer might possibly be shared externally).
+ */
+
+
+function resize(buffer, length) {
+  if (length === buffer.length) {
+    return buffer;
+  }
+
+  var newBuf = alloc(length);
+  buffer.copy(newBuf);
+  free(buffer);
+  return newBuf;
+}
+/**
+ * Reads an arbitrary signed int from a buffer.
+ */
+
+
+function readInt(buffer) {
+  var length = buffer.length;
+  var positive = buffer[length - 1] < 0x80;
+  var result = positive ? 0 : -1;
+  var lossy = false; // Note: We can't use bit manipulation here, since that stops
+  // working if the result won't fit in a 32-bit int.
+
+  if (length < 7) {
+    // Common case which can't possibly be lossy (because the result has
+    // no more than 48 bits, and loss only happens with 54 or more).
+    for (var i = length - 1; i >= 0; i--) {
+      result = result * 0x100 + buffer[i];
+    }
+  } else {
+    for (var _i = length - 1; _i >= 0; _i--) {
+      var one = buffer[_i];
+      result *= 0x100;
+
+      if (isLossyToAdd(result, one)) {
+        lossy = true;
+      }
+
+      result += one;
+    }
+  }
+
+  return {
+    value: result,
+    lossy: lossy
+  };
+}
+/**
+ * Reads an arbitrary unsigned int from a buffer.
+ */
+
+
+function readUInt(buffer) {
+  var length = buffer.length;
+  var result = 0;
+  var lossy = false; // Note: See above in re bit manipulation.
+
+  if (length < 7) {
+    // Common case which can't possibly be lossy (see above).
+    for (var i = length - 1; i >= 0; i--) {
+      result = result * 0x100 + buffer[i];
+    }
+  } else {
+    for (var _i2 = length - 1; _i2 >= 0; _i2--) {
+      var one = buffer[_i2];
+      result *= 0x100;
+
+      if (isLossyToAdd(result, one)) {
+        lossy = true;
+      }
+
+      result += one;
+    }
+  }
+
+  return {
+    value: result,
+    lossy: lossy
+  };
+}
+/**
+ * Writes a little-endian 64-bit signed int into a buffer.
+ */
+
+
+function writeInt64(value, buffer) {
+  if (value < MIN_EXACT_INT64 || value > MAX_EXACT_INT64) {
+    throw new Error("Value out of range.");
+  }
+
+  if (value < 0) {
+    value += BIT_64;
+  }
+
+  writeUInt64(value, buffer);
+}
+/**
+ * Writes a little-endian 64-bit unsigned int into a buffer.
+ */
+
+
+function writeUInt64(value, buffer) {
+  if (value < 0 || value > MAX_EXACT_UINT64) {
+    throw new Error("Value out of range.");
+  }
+
+  var lowWord = value % BIT_32;
+  var highWord = Math.floor(value / BIT_32);
+  buffer.writeUInt32LE(lowWord, 0);
+  buffer.writeUInt32LE(highWord, 4);
+}
\ No newline at end of file
-- 
cgit v1.2.3