@onetokenfe/coinselect 3.1.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Daniel Cousens
+
+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.

package/README.md

@@ -0,0 +1,95 @@
+# coinselect
+
+[![TRAVIS](https://secure.travis-ci.org/bitcoinjs/coinselect.png)](http://travis-ci.org/bitcoinjs/coinselect)
+[![NPM](http://img.shields.io/npm/v/coinselect.svg)](https://www.npmjs.org/package/coinselect)
+
+[![js-standard-style](https://cdn.rawgit.com/feross/standard/master/badge.svg)](https://github.com/feross/standard)
+
+An unspent transaction output (UTXO) selection module for bitcoin.
+
+**WARNING:** Value units are in `satoshi`s, **not** Bitcoin.
+
+
+## Algorithms
+Module | Algorithm | Re-orders UTXOs?
+-|-|-
+`require('coinselect')` | Blackjack, with Accumulative fallback | By Descending Value
+`require('coinselect/accumulative')` | Accumulative - accumulates inputs until the target value (+fees) is reached, skipping detrimental inputs | -
+`require('coinselect/blackjack')` | Blackjack - accumulates inputs until the target value (+fees) is matched, does not accumulate inputs that go over the target value (within a threshold) | -
+`require('coinselect/break')` | Break - breaks the input values into equal denominations of `output` (as provided) | -
+`require('coinselect/split')` | Split - splits the input values evenly between all `outputs`, any provided `output` with `.value` remains unchanged | -
+
+
+**Note:** Each algorithm will add a change output if the `input - output - fee` value difference is over a dust threshold.
+This is calculated independently by `utils.finalize`, irrespective of the algorithm chosen, for the purposes of safety.
+
+**Pro-tip:** if you want to send-all inputs to an output address, `coinselect/split` with a partial output (`.address` defined, no `.value`) can be used to send-all, while leaving an appropriate amount for the `fee`. 
+
+## Example
+
+``` javascript
+let coinSelect = require('coinselect')
+let feeRate = 55 // satoshis per byte
+let utxos = [
+  ...,
+  {
+    txId: '...',
+    vout: 0,
+    ...,
+    value: 10000,
+    // For use with PSBT:
+    // not needed for coinSelect, but will be passed on to inputs later
+    nonWitnessUtxo: Buffer.from('...full raw hex of txId tx...', 'hex'),
+    // OR
+    // if your utxo is a segwit output, you can use witnessUtxo instead
+    witnessUtxo: {
+      script: Buffer.from('... scriptPubkey hex...', 'hex'),
+      value: 10000 // 0.0001 BTC and is the exact same as the value above
+    }
+  }
+]
+let targets = [
+  ...,
+  {
+    address: '1EHNa6Q4Jz2uvNExL497mE43ikXhwF6kZm',
+    value: 5000
+  }
+]
+
+// ...
+let { inputs, outputs, fee } = coinSelect(utxos, targets, feeRate)
+
+// the accumulated fee is always returned for analysis
+console.log(fee)
+
+// .inputs and .outputs will be undefined if no solution was found
+if (!inputs || !outputs) return
+
+let psbt = new bitcoin.Psbt()
+
+inputs.forEach(input =>
+  psbt.addInput({
+    hash: input.txId,
+    index: input.vout,
+    nonWitnessUtxo: input.nonWitnessUtxo,
+    // OR (not both)
+    witnessUtxo: input.witnessUtxo,
+  })
+)
+outputs.forEach(output => {
+  // watch out, outputs may have been added that you need to provide
+  // an output address/script for
+  if (!output.address) {
+    output.address = wallet.getChangeAddress()
+    wallet.nextChangeAddress()
+  }
+
+  psbt.addOutput({
+    address: output.address,
+    value: output.value,
+  })
+})
+```
+
+
+## License [MIT](LICENSE)

package/accumulative.js

@@ -0,0 +1,38 @@
+var utils = require('./utils')
+
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+module.exports = function accumulative (utxos, outputs, feeRate) {
+  if (!isFinite(utils.uintOrNaN(feeRate))) return {}
+  var bytesAccum = utils.transactionBytes([], outputs)
+
+  var inAccum = 0
+  var inputs = []
+  var outAccum = utils.sumOrNaN(outputs)
+
+  for (var i = 0; i < utxos.length; ++i) {
+    var utxo = utxos[i]
+    var utxoBytes = utils.inputBytes(utxo)
+    var utxoFee = feeRate * utxoBytes
+    var utxoValue = utils.uintOrNaN(utxo.value)
+
+    // skip detrimental input
+    if (utxoFee > utxo.value) {
+      if (i === utxos.length - 1) return { fee: feeRate * (bytesAccum + utxoBytes) }
+      continue
+    }
+
+    bytesAccum += utxoBytes
+    inAccum += utxoValue
+    inputs.push(utxo)
+
+    var fee = feeRate * bytesAccum
+
+    // go again?
+    if (inAccum < outAccum + fee) continue
+
+    return utils.finalize(inputs, outputs, feeRate)
+  }
+
+  return { fee: feeRate * bytesAccum }
+}

package/blackjack.js

@@ -0,0 +1,35 @@
+var utils = require('./utils')
+
+// only add inputs if they don't bust the target value (aka, exact match)
+// worst-case: O(n)
+module.exports = function blackjack (utxos, outputs, feeRate) {
+  if (!isFinite(utils.uintOrNaN(feeRate))) return {}
+
+  var bytesAccum = utils.transactionBytes([], outputs)
+
+  var inAccum = 0
+  var inputs = []
+  var outAccum = utils.sumOrNaN(outputs)
+  var threshold = utils.dustThreshold({}, feeRate)
+
+  for (var i = 0; i < utxos.length; ++i) {
+    var input = utxos[i]
+    var inputBytes = utils.inputBytes(input)
+    var fee = feeRate * (bytesAccum + inputBytes)
+    var inputValue = utils.uintOrNaN(input.value)
+
+    // would it waste value?
+    if ((inAccum + inputValue) > (outAccum + fee + threshold)) continue
+
+    bytesAccum += inputBytes
+    inAccum += inputValue
+    inputs.push(input)
+
+    // go again?
+    if (inAccum < outAccum + fee) continue
+
+    return utils.finalize(inputs, outputs, feeRate)
+  }
+
+  return { fee: feeRate * bytesAccum }
+}

package/break.js

@@ -0,0 +1,34 @@
+var utils = require('./utils')
+
+// break utxos into the maximum number of 'output' possible
+module.exports = function broken (utxos, output, feeRate) {
+  if (!isFinite(utils.uintOrNaN(feeRate))) return {}
+
+  var bytesAccum = utils.transactionBytes(utxos, [])
+  var value = utils.uintOrNaN(output.value)
+  var inAccum = utils.sumOrNaN(utxos)
+  if (!isFinite(value) ||
+      !isFinite(inAccum)) return { fee: feeRate * bytesAccum }
+
+  var outputBytes = utils.outputBytes(output)
+  var outAccum = 0
+  var outputs = []
+
+  while (true) {
+    var fee = feeRate * (bytesAccum + outputBytes)
+
+    // did we bust?
+    if (inAccum < (outAccum + fee + value)) {
+      // premature?
+      if (outAccum === 0) return { fee: fee }
+
+      break
+    }
+
+    bytesAccum += outputBytes
+    outAccum += value
+    outputs.push(output)
+  }
+
+  return utils.finalize(utxos, outputs, feeRate)
+}

package/index.js

@@ -0,0 +1,21 @@
+var accumulative = require('./accumulative')
+var blackjack = require('./blackjack')
+var utils = require('./utils')
+
+// order by descending value, minus the inputs approximate fee
+function utxoScore (x, feeRate) {
+  return x.value - (feeRate * utils.inputBytes(x))
+}
+
+module.exports = function coinSelect (utxos, outputs, feeRate) {
+  utxos = utxos.concat().sort(function (a, b) {
+    return utxoScore(b, feeRate) - utxoScore(a, feeRate)
+  })
+
+  // attempt to use the blackjack strategy first (no change output)
+  var base = blackjack(utxos, outputs, feeRate)
+  if (base.inputs) return base
+
+  // else, try the accumulative strategy
+  return accumulative(utxos, outputs, feeRate)
+}

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@onetokenfe/coinselect",
+  "version": "3.1.16",
+  "description": "A transaction input selection module for bitcoin.",
+  "keywords": [
+    "coinselect",
+    "coin",
+    "unspents",
+    "wallet",
+    "BIP32",
+    "management",
+    "utxo",
+    "transaction",
+    "fee",
+    "optimization",
+    "optimizing",
+    "bitcoin"
+  ],
+  "homepage": "https://github.com/bitcoinjs/coinselect",
+  "bugs": {
+    "url": "https://github.com/bitcoinjs/coinselect/issues"
+  },
+  "license": "MIT",
+  "author": "Daniel Cousens",
+  "files": [
+    "accumulative.js",
+    "blackjack.js",
+    "break.js",
+    "index.js",
+    "split.js",
+    "utils.js",
+    "witness.js",
+    "witness.d.ts",
+    "third-party/**"
+  ],
+  "main": "index.js",
+  "types": "index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bitcoinjs/coinselect.git"
+  },
+  "scripts": {
+    "coverage": "nyc --exclude='third-party/**' --check-coverage --branches 90 --functions 95 tape test/*.js",
+    "standard": "standard",
+    "standard:file": "standard --fix",
+    "test": "npm run standard && npm run unit",
+    "unit": "tape test/*.js",
+    "test-witness": "tape test/witness.js"
+  },
+  "devDependencies": {
+    "nyc": "^15.0.0",
+    "standard": "17.1.2",
+    "tape": "^4.5.1"
+  },
+  "dependencies": {
+    "bchaddrjs": "^0.5.2",
+    "bech32": "^2.0.0",
+    "bip66": "^2.0.0",
+    "bitcoin-ops": "^1.4.1",
+    "blake-hash": "^2.0.0",
+    "blakejs": "^1.2.1",
+    "bn.js": "^5.2.3",
+    "bs58": "^6.0.0",
+    "bs58check": "^4.0.0",
+    "create-hmac": "^1.1.7",
+    "int64-buffer": "^1.0.1",
+    "pushdata-bitcoin": "^1.0.1",
+    "tiny-secp256k1": "^1.1.6",
+    "typeforce": "^1.18.0",
+    "varuint-bitcoin": "2.0.0",
+    "wif": "^5.0.0",
+    "bignumber.js": "9.1.2"
+  },
+  "peerDependencies": {
+    "tslib": "^2.6.2"
+  },
+  "standard": {
+    "ignore": [
+      "third-party/**"
+    ]
+  }
+}

package/split.js

@@ -0,0 +1,45 @@
+var utils = require('./utils')
+
+// split utxos between each output, ignores outputs with .value defined
+module.exports = function split (utxos, outputs, feeRate) {
+  if (!isFinite(utils.uintOrNaN(feeRate))) return {}
+
+  var bytesAccum = utils.transactionBytes(utxos, outputs)
+  var fee = feeRate * bytesAccum
+  if (outputs.length === 0) return { fee: fee }
+
+  var inAccum = utils.sumOrNaN(utxos)
+  var outAccum = utils.sumForgiving(outputs)
+  var remaining = inAccum - outAccum - fee
+  if (!isFinite(remaining) || remaining < 0) return { fee: fee }
+
+  var unspecified = outputs.reduce(function (a, x) {
+    return a + !isFinite(x.value)
+  }, 0)
+
+  if (remaining === 0 && unspecified === 0) return utils.finalize(utxos, outputs, feeRate)
+
+  var splitOutputsCount = outputs.reduce(function (a, x) {
+    if (x.value !== undefined) return a
+    return a + 1
+  }, 0)
+  var splitValue = Math.floor(remaining / splitOutputsCount)
+
+  // ensure every output is either user defined, or over the threshold
+  if (!outputs.every(function (x) {
+    return x.value !== undefined || (splitValue > utils.dustThreshold(x, feeRate))
+  })) return { fee: fee }
+
+  // assign splitValue to outputs not user defined
+  outputs = outputs.map(function (x) {
+    if (x.value !== undefined) return x
+
+    // not user defined, but still copy over any non-value fields
+    var y = {}
+    for (var k in x) y[k] = x[k]
+    y.value = splitValue
+    return y
+  })
+
+  return utils.finalize(utxos, outputs, feeRate)
+}

package/third-party/utils/addDashesToSpaces.d.ts

@@ -0,0 +1,2 @@
+export declare const addDashesToSpaces: (inputString: string) => string;
+//# sourceMappingURL=addDashesToSpaces.d.ts.map

package/third-party/utils/addDashesToSpaces.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addDashesToSpaces = void 0;
+const addDashesToSpaces = (inputString) => inputString.replace(/\s+/g, '-');
+exports.addDashesToSpaces = addDashesToSpaces;
+//# sourceMappingURL=addDashesToSpaces.js.map

package/third-party/utils/arrayDistinct.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayDistinct: <T>(item: T, index: number, self: T[]) => boolean;
+//# sourceMappingURL=arrayDistinct.d.ts.map

package/third-party/utils/arrayDistinct.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayDistinct = void 0;
+const arrayDistinct = (item, index, self) => self.indexOf(item) === index;
+exports.arrayDistinct = arrayDistinct;
+//# sourceMappingURL=arrayDistinct.js.map

package/third-party/utils/arrayPartition.d.ts

@@ -0,0 +1,7 @@
+type ArrayPartition = {
+    <T, S extends T>(array: T[], condition: (elem: T) => elem is S): [S[], Exclude<T, S>[]];
+    <T>(array: T[], condition: (elem: T) => boolean): [T[], T[]];
+};
+export declare const arrayPartition: ArrayPartition;
+export {};
+//# sourceMappingURL=arrayPartition.d.ts.map

package/third-party/utils/arrayPartition.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayPartition = void 0;
+const arrayPartition = (array, condition) => array.reduce(([pass, fail], elem) => condition(elem) ? [[...pass, elem], fail] : [pass, [...fail, elem]], [[], []]);
+exports.arrayPartition = arrayPartition;
+//# sourceMappingURL=arrayPartition.js.map

package/third-party/utils/arrayShuffle.d.ts

@@ -0,0 +1,4 @@
+export declare const arrayShuffle: <T>(array: readonly T[], { randomInt }: {
+    randomInt: (min: number, max: number) => number;
+}) => T[];
+//# sourceMappingURL=arrayShuffle.d.ts.map

package/third-party/utils/arrayShuffle.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayShuffle = void 0;
+const arrayShuffle = (array, { randomInt }) => {
+    const shuffled = array.slice();
+    for (let i = shuffled.length - 1; i > 0; i--) {
+        const j = randomInt(0, i + 1);
+        [shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
+    }
+    return shuffled;
+};
+exports.arrayShuffle = arrayShuffle;
+//# sourceMappingURL=arrayShuffle.js.map

package/third-party/utils/arrayToDictionary.d.ts

@@ -0,0 +1,10 @@
+type DictionaryKey = string | number;
+type GetKey<T> = (item: T) => unknown;
+type Key<Fn extends GetKey<any>, R = ReturnType<Fn>> = R extends DictionaryKey ? R : never;
+type ArrayToDictionary = {
+    <T, Fn extends GetKey<T>>(array: T[], getKey: Fn, multiple?: false): Record<Key<Fn>, T>;
+    <T, Fn extends GetKey<T>>(array: T[], getKey: Fn, multiple: true): Record<Key<Fn>, T[]>;
+};
+export declare const arrayToDictionary: ArrayToDictionary;
+export {};
+//# sourceMappingURL=arrayToDictionary.d.ts.map

package/third-party/utils/arrayToDictionary.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToDictionary = void 0;
+const validateKey = (key) => {
+    if (['string', 'number'].includes(typeof key)) {
+        return true;
+    }
+    return false;
+};
+const arrayToDictionary = (array, getKey, multiple) => multiple
+    ? array.reduce((prev, cur) => {
+        var _a;
+        const key = getKey(cur);
+        if (validateKey(key)) {
+            return Object.assign(Object.assign({}, prev), { [key]: [...((_a = prev[key]) !== null && _a !== void 0 ? _a : []), cur] });
+        }
+        return prev;
+    }, {})
+    : array.reduce((prev, cur) => {
+        const key = getKey(cur);
+        if (validateKey(key)) {
+            return Object.assign(Object.assign({}, prev), { [key]: cur });
+        }
+        return prev;
+    }, {});
+exports.arrayToDictionary = arrayToDictionary;
+//# sourceMappingURL=arrayToDictionary.js.map

package/third-party/utils/asciiUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function isAscii(value?: string): boolean;
+export declare function getNonAsciiChars(value?: string): RegExpMatchArray | null;
+//# sourceMappingURL=asciiUtils.d.ts.map

package/third-party/utils/asciiUtils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAscii = isAscii;
+exports.getNonAsciiChars = getNonAsciiChars;
+const nonAsciiPattern = /[^\x20-\x7E]/g;
+function isAscii(value) {
+    if (!value)
+        return true;
+    return !nonAsciiPattern.test(value);
+}
+function getNonAsciiChars(value) {
+    if (!value)
+        return null;
+    return value.match(nonAsciiPattern);
+}
+//# sourceMappingURL=asciiUtils.js.map

package/third-party/utils/bigNumber.d.ts

@@ -0,0 +1,5 @@
+import BN from 'bignumber.js';
+export declare const BigNumber: typeof BN;
+export type BigNumber = BN;
+export type BigNumberValue = BN.Value;
+//# sourceMappingURL=bigNumber.d.ts.map

package/third-party/utils/bigNumber.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigNumber = void 0;
+const tslib_1 = require("tslib");
+const bignumber_js_1 = tslib_1.__importDefault(require("bignumber.js"));
+exports.BigNumber = bignumber_js_1.default.clone({
+    EXPONENTIAL_AT: 1e9,
+});
+//# sourceMappingURL=bigNumber.js.map

package/third-party/utils/bufferUtils.d.ts

@@ -0,0 +1,3 @@
+export declare const reverseBuffer: (src: Buffer) => Buffer;
+export declare const getChunkSize: (n: number) => Buffer;
+//# sourceMappingURL=bufferUtils.d.ts.map

package/third-party/utils/bufferUtils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChunkSize = exports.reverseBuffer = void 0;
+const reverseBuffer = (src) => {
+    if (src.length < 1)
+        return src;
+    const buffer = Buffer.alloc(src.length);
+    let j = buffer.length - 1;
+    for (let i = 0; i < buffer.length / 2; i++) {
+        buffer[i] = src[j];
+        buffer[j] = src[i];
+        j--;
+    }
+    return buffer;
+};
+exports.reverseBuffer = reverseBuffer;
+const getChunkSize = (n) => {
+    const buf = Buffer.allocUnsafe(1);
+    buf.writeUInt8(n);
+    return buf;
+};
+exports.getChunkSize = getChunkSize;
+//# sourceMappingURL=bufferUtils.js.map

package/third-party/utils/bytesToHumanReadable.d.ts

@@ -0,0 +1,2 @@
+export declare const bytesToHumanReadable: (bytes: number) => string;
+//# sourceMappingURL=bytesToHumanReadable.d.ts.map

package/third-party/utils/bytesToHumanReadable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bytesToHumanReadable = void 0;
+const units = ['B', 'KB', 'MB', 'GB', 'TB'];
+const bytesToHumanReadable = (bytes) => {
+    let size = Math.abs(bytes);
+    let i = 0;
+    while (size >= 1024 || i >= units.length) {
+        size /= 1024;
+        i++;
+    }
+    return `${size.toFixed(1)} ${units[i]}`;
+};
+exports.bytesToHumanReadable = bytesToHumanReadable;
+//# sourceMappingURL=bytesToHumanReadable.js.map

package/third-party/utils/capitalizeFirstLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const capitalizeFirstLetter: <T extends string = string>(str: T) => Capitalize<T>;
+//# sourceMappingURL=capitalizeFirstLetter.d.ts.map

package/third-party/utils/capitalizeFirstLetter.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalizeFirstLetter = void 0;
+const capitalizeFirstLetter = (str) => (str.charAt(0).toUpperCase() + str.slice(1));
+exports.capitalizeFirstLetter = capitalizeFirstLetter;
+//# sourceMappingURL=capitalizeFirstLetter.js.map

package/third-party/utils/cloneObject.d.ts

@@ -0,0 +1,2 @@
+export declare const cloneObject: <T>(obj: T, seen?: WeakMap<object, any>) => T;
+//# sourceMappingURL=cloneObject.d.ts.map

package/third-party/utils/cloneObject.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cloneObject = void 0;
+const cloneObject = (obj, seen = new WeakMap()) => {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (seen.has(obj)) {
+        return seen.get(obj);
+    }
+    if (obj instanceof ArrayBuffer) {
+        return obj.slice(0);
+    }
+    if (ArrayBuffer.isView(obj)) {
+        const TypedArrayConstructor = obj.constructor;
+        return new TypedArrayConstructor(obj);
+    }
+    const clone = Array.isArray(obj) ? [] : {};
+    seen.set(obj, clone);
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            const value = obj[key];
+            if (typeof value === 'function' || typeof value === 'symbol') {
+                continue;
+            }
+            clone[key] = (0, exports.cloneObject)(value, seen);
+        }
+    }
+    return clone;
+};
+exports.cloneObject = cloneObject;
+//# sourceMappingURL=cloneObject.js.map

package/third-party/utils/countBytesInString.d.ts

@@ -0,0 +1,2 @@
+export declare const countBytesInString: (input: string) => number;
+//# sourceMappingURL=countBytesInString.d.ts.map

package/third-party/utils/countBytesInString.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countBytesInString = void 0;
+const countBytesInString = (input) => encodeURI(input).split(/%..|./).length - 1;
+exports.countBytesInString = countBytesInString;
+//# sourceMappingURL=countBytesInString.js.map

package/third-party/utils/createCooldown.d.ts

@@ -0,0 +1,2 @@
+export declare const createCooldown: (cooldownMs: number) => () => boolean;
+//# sourceMappingURL=createCooldown.d.ts.map

package/third-party/utils/createCooldown.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCooldown = void 0;
+const createCooldown = (cooldownMs) => {
+    let last = 0;
+    return () => {
+        const now = Date.now();
+        if (now - last >= cooldownMs) {
+            last = now;
+            return true;
+        }
+        return false;
+    };
+};
+exports.createCooldown = createCooldown;
+//# sourceMappingURL=createCooldown.js.map