libskynet - npm Package Compare versions

Comparing version 0.0.23 to 0.0.24

dist/parse.js

@@ -0,4 +1,319 @@
+// @ts-nocheck
 import { tryStringify } from "./stringifytry.js";
-import { default as JSONbigConfigurator } from "json-bigint";
-const JSONbig = JSONbigConfigurator({ alwaysParseAsBig: true, useNativeBigInt: true });
+// json_parse extracted from the json-bigint npm library
+// regexpxs extracted from
+// (c) BSD-3-Clause
+// https://github.com/fastify/secure-json-parse/graphs/contributors and https://github.com/hapijs/bourne/graphs/contributors
+const suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
+const suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
+let json_parse = function (options) {
+    "use strict";
+    // This is a function that can parse a JSON text, producing a JavaScript
+    // data structure. It is a simple, recursive descent parser. It does not use
+    // eval or regular expressions, so it can be used as a model for implementing
+    // a JSON parser in other languages.
+    // We are defining the function inside of another function to avoid creating
+    // global variables.
+    // Default options one can override by passing options to the parse()
+    let _options = {
+        strict: false,
+        storeAsString: false,
+        alwaysParseAsBig: false,
+        protoAction: "error",
+        constructorAction: "error",
+    };
+    // If there are options, then use them to override the default _options
+    if (options !== undefined && options !== null) {
+        if (options.strict === true) {
+            _options.strict = true;
+        }
+        if (options.storeAsString === true) {
+            _options.storeAsString = true;
+        }
+        _options.alwaysParseAsBig = options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
+        if (typeof options.constructorAction !== "undefined") {
+            if (options.constructorAction === "error" ||
+                options.constructorAction === "ignore" ||
+                options.constructorAction === "preserve") {
+                _options.constructorAction = options.constructorAction;
+            }
+            else {
+                throw new Error(`Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`);
+            }
+        }
+        if (typeof options.protoAction !== "undefined") {
+            if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve") {
+                _options.protoAction = options.protoAction;
+            }
+            else {
+                throw new Error(`Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`);
+            }
+        }
+    }
+    let at, // The index of the current character
+    ch, // The current character
+    escapee = {
+        '"': '"',
+        "\\": "\\",
+        "/": "/",
+        b: "\b",
+        f: "\f",
+        n: "\n",
+        r: "\r",
+        t: "\t",
+    }, text, error = function (m) {
+        // Call error when something is wrong.
+        throw {
+            name: "SyntaxError",
+            message: m,
+            at: at,
+            text: text,
+        };
+    }, next = function (c) {
+        // If a c parameter is provided, verify that it matches the current character.
+        if (c && c !== ch) {
+            error("Expected '" + c + "' instead of '" + ch + "'");
+        }
+        // Get the next character. When there are no more characters,
+        // return the empty string.
+        ch = text.charAt(at);
+        at += 1;
+        return ch;
+    }, number = function () {
+        // Parse a number value.
+        let number, string = "";
+        if (ch === "-") {
+            string = "-";
+            next("-");
+        }
+        while (ch >= "0" && ch <= "9") {
+            string += ch;
+            next();
+        }
+        if (ch === ".") {
+            string += ".";
+            while (next() && ch >= "0" && ch <= "9") {
+                string += ch;
+            }
+        }
+        if (ch === "e" || ch === "E") {
+            string += ch;
+            next();
+            if (ch === "-" || ch === "+") {
+                string += ch;
+                next();
+            }
+            while (ch >= "0" && ch <= "9") {
+                string += ch;
+                next();
+            }
+        }
+        number = +string;
+        if (!isFinite(number)) {
+            error("Bad number");
+        }
+        else {
+            if (Number.isSafeInteger(number))
+                return !_options.alwaysParseAsBig ? number : BigInt(number);
+            // Number with fractional part should be treated as number(double) including big integers in scientific notation, i.e 1.79e+308
+            else
+                return _options.storeAsString ? string : /[.eE]/.test(string) ? number : BigInt(string);
+        }
+    }, string = function () {
+        // Parse a string value.
+        let hex, i, string = "", uffff;
+        // When parsing for string values, we must look for " and \ characters.
+        if (ch === '"') {
+            let startAt = at;
+            while (next()) {
+                if (ch === '"') {
+                    if (at - 1 > startAt)
+                        string += text.substring(startAt, at - 1);
+                    next();
+                    return string;
+                }
+                if (ch === "\\") {
+                    if (at - 1 > startAt)
+                        string += text.substring(startAt, at - 1);
+                    next();
+                    if (ch === "u") {
+                        uffff = 0;
+                        for (i = 0; i < 4; i += 1) {
+                            hex = parseInt(next(), 16);
+                            if (!isFinite(hex)) {
+                                break;
+                            }
+                            uffff = uffff * 16 + hex;
+                        }
+                        string += String.fromCharCode(uffff);
+                    }
+                    else if (typeof escapee[ch] === "string") {
+                        string += escapee[ch];
+                    }
+                    else {
+                        break;
+                    }
+                    startAt = at;
+                }
+            }
+        }
+        error("Bad string");
+    }, white = function () {
+        // Skip whitespace.
+        while (ch && ch <= " ") {
+            next();
+        }
+    }, word = function () {
+        // true, false, or null.
+        switch (ch) {
+            case "t":
+                next("t");
+                next("r");
+                next("u");
+                next("e");
+                return true;
+            case "f":
+                next("f");
+                next("a");
+                next("l");
+                next("s");
+                next("e");
+                return false;
+            case "n":
+                next("n");
+                next("u");
+                next("l");
+                next("l");
+                return null;
+        }
+        error("Unexpected '" + ch + "'");
+    }, value, // Place holder for the value function.
+    array = function () {
+        // Parse an array value.
+        let array = [];
+        if (ch === "[") {
+            next("[");
+            white();
+            if (ch === "]") {
+                next("]");
+                return array; // empty array
+            }
+            while (ch) {
+                array.push(value());
+                white();
+                if (ch === "]") {
+                    next("]");
+                    return array;
+                }
+                next(",");
+                white();
+            }
+        }
+        error("Bad array");
+    }, object = function () {
+        // Parse an object value.
+        let key, object = Object.create(null);
+        if (ch === "{") {
+            next("{");
+            white();
+            if (ch === "}") {
+                next("}");
+                return object; // empty object
+            }
+            while (ch) {
+                key = string();
+                white();
+                next(":");
+                if (_options.strict === true && Object.hasOwnProperty.call(object, key)) {
+                    error('Duplicate key "' + key + '"');
+                }
+                if (suspectProtoRx.test(key) === true) {
+                    if (_options.protoAction === "error") {
+                        error("Object contains forbidden prototype property");
+                    }
+                    else if (_options.protoAction === "ignore") {
+                        value();
+                    }
+                    else {
+                        object[key] = value();
+                    }
+                }
+                else if (suspectConstructorRx.test(key) === true) {
+                    if (_options.constructorAction === "error") {
+                        error("Object contains forbidden constructor property");
+                    }
+                    else if (_options.constructorAction === "ignore") {
+                        value();
+                    }
+                    else {
+                        object[key] = value();
+                    }
+                }
+                else {
+                    object[key] = value();
+                }
+                white();
+                if (ch === "}") {
+                    next("}");
+                    return object;
+                }
+                next(",");
+                white();
+            }
+        }
+        error("Bad object");
+    };
+    value = function () {
+        // Parse a JSON value. It could be an object, an array, a string, a number,
+        // or a word.
+        white();
+        switch (ch) {
+            case "{":
+                return object();
+            case "[":
+                return array();
+            case '"':
+                return string();
+            case "-":
+                return number();
+            default:
+                return ch >= "0" && ch <= "9" ? number() : word();
+        }
+    };
+    // Return the json_parse function. It will have access to all of the above
+    // functions and variables.
+    return function (source, reviver) {
+        let result;
+        text = source + "";
+        at = 0;
+        ch = " ";
+        result = value();
+        white();
+        if (ch) {
+            error("Syntax error");
+        }
+        // If there is a reviver function, we recursively walk the new structure,
+        // passing each name/value pair to the reviver function for possible
+        // transformation, starting with a temporary root object that holds the result
+        // in an empty key. If there is not a reviver function, we simply return the
+        // result.
+        return typeof reviver === "function"
+            ? (function walk(holder, key) {
+                let v, value = holder[key];
+                if (value && typeof value === "object") {
+                    Object.keys(value).forEach(function (k) {
+                        v = walk(value, k);
+                        if (v !== undefined) {
+                            value[k] = v;
+                        }
+                        else {
+                            delete value[k];
+                        }
+                    });
+                }
+                return reviver.call(holder, key, value);
+            })({ "": result }, "")
+            : result;
+    };
+};
 // parseJSON is a wrapper for JSONbig.parse that returns an error rather than
@@ -12,3 +327,3 @@ // throwing an error. JSONbig is an alternative to JSON.parse that decodes
     try {
-        let obj = JSONbig.parse(json);
+        let obj = json_parse(json);
         return [obj, null];
@@ -15,0 +330,0 @@ }

package.json

 {
 	"name": "libskynet",
-	"version": "0.0.23",
+	"version": "0.0.24",
 	"description": "helper library to interact with skynet's low level primitives",
@@ -20,3 +20,2 @@ "main": "dist/index.js",
 	"devDependencies": {
-		"@types/json-bigint": "^1.0.1",
 		"@types/node": "^17.0.23",
@@ -26,6 +25,3 @@ "@typescript-eslint/eslint-plugin": "^5.19.0",
 		"prettier": "^2.6.2"
-	},
-	"dependencies": {
-		"json-bigint": "^1.0.0"
 	}
 }

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

140173

increased by8.62%

Dependency count

0

decreased by-100%

Dev dependency count

4

decreased by-20%

Lines of code

4430

increased by7.65%

Dependency changes

• - Removedjson-bigint@^1.0.0

• - Removedbignumber.js@9.1.2(transitive)

• - Removedjson-bigint@1.0.0(transitive)