crypto.getRandomValues() method if available.-(2^53 - 1) to (2^53 - 1).";
+ this.infoURL = "https://wikipedia.org/wiki/Pseudorandom_number_generator";
+ this.inputType = "string";
+ this.outputType = "string";
+ this.args = [
+ {
+ "name": "Number of Integers",
+ "type": "number",
+ "value": 1,
+ "min": 1
+ },
+ {
+ "name": "Min Value",
+ "type": "number",
+ "value": 0,
+ "min": Number.MIN_SAFE_INTEGER,
+ "max": Number.MAX_SAFE_INTEGER
+ },
+ {
+ "name": "Max Value",
+ "type": "number",
+ "value": 99,
+ "min": Number.MIN_SAFE_INTEGER,
+ "max": Number.MAX_SAFE_INTEGER
+ },
+ {
+ "name": "Delimiter",
+ "type": "option",
+ "value": DELIM_OPTIONS
+ },
+ {
+ "name": "Output",
+ "type": "option",
+ "value": ["Raw", "Hex", "Decimal"]
+ }
+ ];
+
+ // not using BigUint64Array to avoid BigInt handling overhead
+ this.randomBuffer = new Uint32Array(PseudoRandomIntegerGenerator.BUFFER_SIZE);
+ this.randomBufferOffset = PseudoRandomIntegerGenerator.BUFFER_SIZE;
+ }
+
+ /**
+ * @param {string} input
+ * @param {Object[]} args
+ * @returns {string}
+ */
+ run(input, args) {
+ const [numInts, minInt, maxInt, delimiter, outputType] = args;
+
+ if (minInt === null || maxInt === null) return "";
+
+ const min = Math.ceil(minInt);
+ const max = Math.floor(maxInt);
+ const delim = Utils.charRep(delimiter || "Space");
+
+ if (!Number.isSafeInteger(min) || !Number.isSafeInteger(max)) {
+ throw new OperationError("Min and Max must be between `-(2^53 - 1)` and `2^53 - 1`.");
+ }
+ if (min > max) {
+ throw new OperationError("Min cannot be larger than Max.");
+ }
+ const range = max - min + 1; // inclusive range
+ if (range > PseudoRandomIntegerGenerator.MAX_RANGE) {
+ throw new OperationError("Range between Min and Max cannot be larger than `2^53`");
+ }
+
+ // as large as possible while divisible by range
+ const rejectionThreshold = PseudoRandomIntegerGenerator.MAX_RANGE - (PseudoRandomIntegerGenerator.MAX_RANGE % range);
+ const output = [];
+ for (let i = 0; i < numInts; i++) {
+ const result = this._generateRandomValue(rejectionThreshold);
+ const intValue = min + (result % range);
+
+ switch (outputType) {
+ case "Hex":
+ output.push(intValue.toString(16));
+ break;
+ case "Decimal":
+ output.push(intValue.toString(10));
+ break;
+ case "Raw":
+ default:
+ output.push(Utils.chr(intValue));
+ }
+ }
+
+ if (outputType === "Raw") {
+ return output.join("");
+ }
+ return output.join(delim);
+ }
+
+ /**
+ * Generate a random value, result will be less than the rejection threshold (exclusive).
+ *
+ * @param {number} rejectionThreshold
+ * @returns {number}
+ */
+ _generateRandomValue(rejectionThreshold) {
+ let result;
+ do {
+ if (this.randomBufferOffset + 2 > this.randomBuffer.length) {
+ this._resetRandomBuffer();
+ }
+ // stitching a 53 bit number; not using BigUint64Array to avoid BigInt handling overhead
+ result = (this.randomBuffer[this.randomBufferOffset++] & 0x1f_ffff) * 0x1_0000_0000 +
+ this.randomBuffer[this.randomBufferOffset++];
+ } while (result >= rejectionThreshold);
+
+ return result;
+ }
+
+ /**
+ * Fill random buffer with new random values and rseet the offset.
+ */
+ _resetRandomBuffer() {
+ if (isWorkerEnvironment() && self.crypto) {
+ self.crypto.getRandomValues(this.randomBuffer);
+ } else {
+ const bytes = forge.random.getBytesSync(this.randomBuffer.length * 4);
+ for (let j = 0; j < this.randomBuffer.length; j++) {
+ this.randomBuffer[j] = (bytes.charCodeAt(j * 4) << 24) |
+ (bytes.charCodeAt(j * 4 + 1) << 16) |
+ (bytes.charCodeAt(j * 4 + 2) << 8) |
+ bytes.charCodeAt(j * 4 + 3);
+ }
+ }
+ this.randomBufferOffset = 0;
+ }
+
+}
+
+export default PseudoRandomIntegerGenerator;
diff --git a/src/core/operations/SQLBeautify.mjs b/src/core/operations/SQLBeautify.mjs
index 0f3d2e3c..2171f7fc 100644
--- a/src/core/operations/SQLBeautify.mjs
+++ b/src/core/operations/SQLBeautify.mjs
@@ -3,8 +3,7 @@
* @copyright Crown Copyright 2016
* @license Apache-2.0
*/
-
-import vkbeautify from "vkbeautify";
+import { format } from "sql-formatter";
import Operation from "../Operation.mjs";
/**
@@ -39,7 +38,26 @@ class SQLBeautify extends Operation {
*/
run(input, args) {
const indentStr = args[0];
- return vkbeautify.sql(input, indentStr);
+ // Extract and replace bind variables like :Bind1 with __BIND_0__
+ const bindRegex = /:\w+/g;
+ const bindMap = {};
+ let bindCounter=0;
+ const placeholderInput = input.replace(bindRegex, (match) => {
+ const placeholder = `__BIND_${bindCounter++}__`;
+ bindMap[placeholder] = match;
+ return placeholder;
+ });
+ // Format the SQL with chosen options
+ let formatted= format(placeholderInput, {
+ language: "mysql", // Use MySQL as the default dialect for better compatibility with real-world SQL
+ useTabs: indentStr==="\t", // true if tab, false if spaces
+ tabWidth: indentStr.length || 4, // fallback if empty
+ indentStyle: "standard" // fine for most SQL
+ });
+ // Replace placeholders back with original bind variables
+ formatted = formatted.replace(/__BIND_\d+__/g, match => bindMap[match] || match);
+
+ return formatted;
}
}
diff --git a/src/web/HTMLIngredient.mjs b/src/web/HTMLIngredient.mjs
index 7eddb32c..91cbed89 100755
--- a/src/web/HTMLIngredient.mjs
+++ b/src/web/HTMLIngredient.mjs
@@ -49,15 +49,14 @@ class HTMLIngredient {
toHtml() {
let html = "",
i, m, eventFn;
+ const hintHtml = this.hint ? `data-toggle="tooltip" title="${this.hint}"` : "";
switch (this.type) {
case "string":
case "binaryString":
case "byteArray":
- html += `