src/nodejs/jsutils

    Dark Mode
Search:
Group by:
  Source   Edit

  • Core, primitives, basic proc, string basics, for JavaScript.

Example:

import src/nodejs/jsutils
import sugar  # =>
doAssert base64encode("Como siempre: lo urgente no deja tiempo para lo importante".cstring) == "Q29tbyBzaWVtcHJlOiBsbyB1cmdlbnRlIG5vIGRlamEgdGllbXBvIHBhcmEgbG8gaW1wb3J0YW50ZQ==".cstring
doAssert base64decode("Q29tbyBzaWVtcHJlOiBsbyB1cmdlbnRlIG5vIGRlamEgdGllbXBvIHBhcmEgbG8gaW1wb3J0YW50ZQ==".cstring) == "Como siempre: lo urgente no deja tiempo para lo importante".cstring
doAssert deduplicate([9, 1, 2, 3, 4, 9, 9, 9, 0]) == @[9, 1, 2, 3, 4, 0]
doAssert deduplicate(@[9, 9, 9, 9]) == @[9]

for okis in ["y".cstring, "Y", "1",  "ON", "On", "oN", "on", "yes", "YES",
    "YEs", "YeS", "Yes", "yES", "yEs", "yeS", "TRUE", "TRUe", "TRuE", "TRue",
    "TrUE", "TrUe", "TruE", "True", "tRUE", "tRUe", "tRuE", "tRue", "trUE",
    "trUe", "truE", "true"]:
    doAssert parseBool(okis)

for nope in ["n".cstring, "N", "0", "NO", "No", "nO", "no", "OFF", "OFf",
  "OfF", "Off", "oFF", "oFf", "ofF", "off", "FALSE", "FALSe", "FALsE",
  "FALse", "FAlSE", "FAlSe", "FAlsE", "FAlse", "FaLSE", "FaLSe", "FaLsE",
  "FaLse", "FalSE", "FalSe", "FalsE", "False", "fALSE", "fALSe", "fALsE",
  "fALse", "fAlSE", "fAlSe", "fAlsE", "fAlse", "faLSE", "faLSe", "faLsE",
  "faLse", "falSE", "falSe", "falsE", "false"]:
  doAssert not parseBool(nope)

let exampl = "hello"
doAssert exampl[0] == 'h'
doAssert exampl[0 .. 3] == "hell".cstring
doAssert exampl[0 .. ^2] == "hell".cstring

Example:

import src/nodejs/jsutils
requireUtil()
block:
  doAssert cstring"%s:%s".format("example".cstring) == "example:%s".cstring
  doAssert getSystemErrorName(-1.cint) == "EPERM".cstring
  inspect("nim".cstring)
  proc foo() = echo 42
  discard callbackify(foo)
  discard deprecate(foo)
  doAssert isDeepStrictEqual(42.cint, 42.cint)
block:
  let enco: TextEncoder = newTextEncoder()
  doAssert enco.encoding == "utf-8".cstring
  doAssert enco.encode(input = "example".cstring) == @[101.uint8, 120, 97, 109, 112, 108, 101]
  var buffe: Uint8Array = newUint8Array(9.Natural)
  enco.encodeInto(src = "example".cstring, dest = buffe) ## encodeInto is {.discardable.} for convenience.
  doAssert buffe.toCstring is cstring
  doAssert $buffe == """{"0":101,"1":120,"2":97,"3":109,"4":112,"5":108,"6":101,"7":0,"8":0}"""
  let deco: TextDecoder = newTextDecoder(encoding = "utf-8".cstring, fatal = false, ignoreBOM = false)
  doAssert deco.encoding == "utf-8".cstring
  doAssert not(deco.fatal)
  doAssert not(deco.ignoreBOM)
  let data: ArrayBuffer = newArrayBuffer(9.Natural)
  doAssert deco.decode(input = data) is cstring
block:
  doAssert not isAnyArrayBuffer(false)
  doAssert not isArrayBufferView(false)
  doAssert not isArgumentsObject(false)
  doAssert not isArrayBuffer(false)
  doAssert not isBigInt64Array(false)
  doAssert not isBigUint64Array(false)
  doAssert not isBooleanObject(false)
  doAssert not isBoxedPrimitive(false)
  doAssert not isDataView(false)
  doAssert not isDate(false)
  doAssert not isExternal(false)
  doAssert not isFloat32Array(false)
  doAssert not isFloat64Array(false)
  doAssert not isGeneratorFunction(false)
  doAssert not isBigInt64Array(false)
  doAssert not isGeneratorObject(false)
  doAssert not isInt8Array(false)
  doAssert not isInt16Array(false)
  doAssert not isInt32Array(false)
  doAssert not isMap(false)
  doAssert not isMapIterator(false)
  doAssert not isModuleNamespaceObject(false)
  doAssert not isNativeError(false)
  doAssert not isNumberObject(false)
  doAssert not isPromise(false)
  doAssert not isProxy(false)
  doAssert not isRegExp(false)
  doAssert not isSet(false)
  doAssert not isSetIterator(false)
  doAssert not isSharedArrayBuffer(false)
  doAssert not isStringObject("string".cstring)
  doAssert not isSymbolObject(false)
  doAssert not isTypedArray(false)
  doAssert not isUint8Array(false)
  doAssert not isUint8ClampedArray(false)
  doAssert not isUint16Array(false)
  doAssert not isUint32Array(false)
  doAssert not isWeakMap(false)
  doAssert not isWeakSet(false)
  doAssert not isWebAssemblyCompiledModule(false)
  doAssert isBoolean(false)
  doAssert not isBuffer(false)
  doAssert not isFunction(false)
  doAssert not isNumber(false)
  doAssert isString("string".cstring)
  doAssert not isSymbol(false)

Types

ArrayBuffer = ref object of JsRoot
  byteLength*: cint
  Source   Edit
TextDecoder = ref object of JsRoot
  encoding*: cstring         ## https://nodejs.org/api/util.html#util_textdecoder_encoding
  fatal*: bool               ## https://nodejs.org/api/util.html#util_textdecoder_fatal
  ignoreBOM*: bool           ## https://nodejs.org/api/util.html#util_textdecoder_ignorebom
  
https://nodejs.org/api/util.html#util_class_util_textdecoder   Source   Edit
TextEncoder = ref object of JsRoot
  encoding*: cstring         ## https://nodejs.org/api/util.html#util_textencoder_encoding
  
https://nodejs.org/api/util.html#util_class_util_textencoder   Source   Edit
Uint8Array = ref object of JsRoot
  BYTES_PER_ELEMENT*: cint
  Source   Edit

Procs

func `$`(self: Uint8Array or ArrayBuffer): string
  Source   Edit
func `&`(a, b: cstring): cstring {.importjs: "(# + #)", ...raises: [], tags: [].}
  Source   Edit
func `&`(a: char; b: cstring): cstring {.
    importjs: "(String.fromCharCode(#) + #)", ...raises: [], tags: [].}
  Source   Edit
func `&`(a: cstring; b: char): cstring {.
    importjs: "(# + String.fromCharCode(#))", ...raises: [], tags: [].}
  Source   Edit
func `&&=`(lhs, rhs: auto): any {.importjs: "(# &&= #)", discardable,
                                  ...raises: [], tags: [].}
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND_assignment   Source   Edit
func `??=`(lhs, rhs: auto): any {.importjs: "(# ??= #)", discardable,
                                  ...raises: [], tags: [].}
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_nullish_assignment   Source   Edit
proc `[]`(s: cstring; slice: HSlice[SomeInteger, BackwardsIndex]): cstring {.
    asmnostackframe.}
  Source   Edit
proc `[]`(s: cstring; slice: HSlice[SomeInteger, SomeInteger]): cstring {.
    asmnostackframe.}
  Source   Edit
func `[]`(self: Uint8Array or ArrayBuffer; index: Natural): uint8 {.
    importjs: "#[#]", ...raises: [], tags: [].}
  Source   Edit
func `[]=`(self: Uint8Array or ArrayBuffer; index: Natural; value: uint8) {.
    importjs: "#[#] = #", ...raises: [], tags: [].}
  Source   Edit
func base64decode(strng: cstring; encoding = "utf-8".cstring): cstring {.
    importjs: "Buffer.from(#, \'base64\').toString(#)", ...raises: [], tags: [].}
Convenience func to Base64 decode a string.   Source   Edit
func base64encode(strng: cstring; encoding = "utf-8".cstring): cstring {.
    importjs: "Buffer.from(#, #).toString(\'base64\')", ...raises: [], tags: [].}
Convenience func to Base64 encode a string.   Source   Edit
proc callbackify[T](function: T): T {.importjs: "util.$1(#)", ...raises: [],
                                      tags: [].}
https://nodejs.org/api/util.html#util_util_callbackify_original   Source   Edit
func capitalizeAscii(s: cstring): cstring {.importjs: """  (() => { const s = #; return s.charAt(0).toUpperCase() + s.slice(1) })()""",
    ...raises: [], tags: [].}
  Source   Edit
func contains(a, b: cstring): bool {.importjs: "(#.indexOf(#) >= 0)",
                                     ...raises: [], tags: [].}
  Source   Edit
func contains(a: cstring; b: char): bool {.
    importjs: "(#.indexOf(String.fromCharCode(#)) >= 0)", ...raises: [], tags: [].}
  Source   Edit
func decode(self: TextDecoder; input: ArrayBuffer): cstring {.importcpp,
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_textdecoder_decode_input_options   Source   Edit
func deduplicate[T](arrai: openArray[T]): seq[T] {.importjs: "[...new Set(#)]",
    ...raises: [], tags: [].}
Convenience func to Deduplicate an array.   Source   Edit
func deprecate[T](function: T): T {.importjs: "util.$1(#, \'\')", ...raises: [],
                                    tags: [].}
https://nodejs.org/api/util.html#util_util_deprecate_fn_msg_code   Source   Edit
func deprecate[T](function: T; msg, code: cstring): T {.
    importjs: "util.$1(#, #, #)", ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_deprecate_fn_msg_code   Source   Edit
func deprecate[T](function: T; msg: cstring): T {.importjs: "util.$1(#, #)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_deprecate_fn_msg_code   Source   Edit
func encode(self: TextEncoder; input: cstring): seq[uint8] {.importcpp,
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_textencoder_encode_input   Source   Edit
func encodeInto(self: TextEncoder; src: cstring; dest: Uint8Array): JsObject {.
    importcpp, discardable, ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_textencoder_encodeinto_src_dest   Source   Edit
func find(s: cstring; ss: char): int {.importjs: "#.indexOf(String.fromCharCode(#))",
                                       ...raises: [], tags: [].}
  Source   Edit
func find(s: cstring; ss: cstring): int {.importjs: "#.indexOf(#)", ...raises: [],
    tags: [].}
  Source   Edit
func find(strng: cstring; regex: RegExp): cint {.importjs: "#.search(#)",
    ...raises: [], tags: [].}
  Source   Edit
func format(format: cstring; args: cstring): cstring {.
    importjs: "util.$1(#, @)", varargs, ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_format_format_args   Source   Edit
func getSystemErrorName(err: cint): cstring {.importjs: "util.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_getsystemerrorname_err   Source   Edit
func importUtil() {.importjs: "import * as util from \'util\'@", ...raises: [],
                    tags: [].}
Alias for import * as module_name from 'module_name';. Must be called once before using the module   Source   Edit
func indentation(s: cstring): cint {.importjs: """  (() => {
    const m = #.match(/^[\s\\t]*/gm);
    let result = m[0].length;
    for (var i = 1; i < m.length; i++) { result = Math.min(m[i].length, result) }
    return result;
  })()""",
                                     ...raises: [], tags: [].}
Returns the amount of indentation all lines of s have in common, ignoring lines that consist only of whitespace.   Source   Edit
func inherits[T](constructor, superConstructor: T) {.importjs: "util.$1(#, #)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_inherits_constructor_superconstructor   Source   Edit
func inspect(objec: auto; showHidden = false; depth = 2.cint; colors = false) {.
    importjs: "util.$1(#, #, #, #)", ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_inspect_object_showhidden_depth_colors   Source   Edit
func isAnyArrayBuffer(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isanyarraybuffer_value   Source   Edit
func isArgumentsObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isargumentsobject_value   Source   Edit
func isArrayBuffer(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isarraybuffer_value   Source   Edit
func isArrayBufferView(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isarraybufferview_value   Source   Edit
func isAsyncFunction(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isasyncfunction_value   Source   Edit
func isBigInt64Array(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isbigint64array_value   Source   Edit
func isBigUint64Array(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isbiguint64array_value   Source   Edit
func isBoolean(value: auto): bool {.importjs: "(typeof # === \'boolean\')",
                                    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_isboolean_object   Source   Edit
func isBooleanObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isbooleanobject_value   Source   Edit
func isBoxedPrimitive(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isboxedprimitive_value   Source   Edit
func isBuffer(value: auto): bool {.importjs: "Buffer.isBuffer(#)", ...raises: [],
                                   tags: [].}
https://nodejs.org/api/util.html#util_util_isbuffer_object   Source   Edit
func isDataView(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                     tags: [].}
https://nodejs.org/api/util.html#util_util_types_isdataview_value   Source   Edit
func isDate(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                 tags: [].}
https://nodejs.org/api/util.html#util_util_types_isdate_value   Source   Edit
func isDeepStrictEqual(val1, val2: auto): bool {.importjs: "util.$1(#, #)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_isdeepstrictequal_val1_val2   Source   Edit
func isDigit(c: char): bool {.importjs: "(() => { const c = #; return (c >= \'0\' && c <= \'9\') })()",
                              ...raises: [], tags: [].}
  Source   Edit
func isExternal(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                     tags: [].}
https://nodejs.org/api/util.html#util_util_types_isexternal_value   Source   Edit
func isFinite(n: SomeNumber): bool {.importjs: "Number.$1(#)", ...raises: [],
                                     tags: [].}
  Source   Edit
func isFloat32Array(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isfloat32array_value   Source   Edit
func isFloat64Array(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isfloat64array_value   Source   Edit
func isFunction(value: auto): bool {.importjs: "(typeof # === \'function\')",
                                     ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_isfunction_object   Source   Edit
func isGeneratorFunction(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isgeneratorfunction_value   Source   Edit
func isGeneratorObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isgeneratorobject_value   Source   Edit
func isInt8Array(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                      tags: [].}
https://nodejs.org/api/util.html#util_util_types_isint8array_value   Source   Edit
func isInt16Array(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                       tags: [].}
https://nodejs.org/api/util.html#util_util_types_isint16array_value   Source   Edit
func isInt32Array(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                       tags: [].}
https://nodejs.org/api/util.html#util_util_types_isint32array_value   Source   Edit
func isInteger(n: SomeNumber): bool {.importjs: "Number.$1(#)", ...raises: [],
                                      tags: [].}
  Source   Edit
func isMap(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                tags: [].}
https://nodejs.org/api/util.html#util_util_types_ismap_value   Source   Edit
func isMapIterator(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_ismapiterator_value   Source   Edit
func isModuleNamespaceObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_ismodulenamespaceobject_value   Source   Edit
func isNativeError(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isnativeerror_value   Source   Edit
func isNumber(value: auto): bool {.importjs: "(typeof # === \'number\')",
                                   ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_isnumber_object   Source   Edit
func isNumberObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isnumberobject_value   Source   Edit
func isPromise(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                    tags: [].}
https://nodejs.org/api/util.html#util_util_types_ispromise_value   Source   Edit
func isProxy(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                  tags: [].}
https://nodejs.org/api/util.html#util_util_types_isproxy_value   Source   Edit
func isRegExp(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                   tags: [].}
https://nodejs.org/api/util.html#util_util_types_isregexp_value   Source   Edit
func isSafeInteger(n: SomeNumber): bool {.importjs: "Number.$1(#)", ...raises: [],
    tags: [].}
  Source   Edit
func isSet(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                tags: [].}
https://nodejs.org/api/util.html#util_util_types_isset_value   Source   Edit
func isSetIterator(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_issetiterator_value   Source   Edit
func isSharedArrayBuffer(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_issharedarraybuffer_value   Source   Edit
func isString(value: auto): bool {.importjs: "(typeof # === \'string\')",
                                   ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_isstring_object   Source   Edit
func isStringObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isstringobject_value   Source   Edit
func isSymbol(value: auto): bool {.importjs: "(typeof # === \'symbol\')",
                                   ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_issymbol_object   Source   Edit
func isSymbolObject(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_issymbolobject_value   Source   Edit
func isTypedArray(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                       tags: [].}
https://nodejs.org/api/util.html#util_util_types_istypedarray_value   Source   Edit
func isUint8Array(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                       tags: [].}
https://nodejs.org/api/util.html#util_util_types_isuint8array_value   Source   Edit
func isUint8ClampedArray(value: auto): bool {.importjs: "util.types.$1(#)",
    ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isuint8clampedarray_value   Source   Edit
func isUint16Array(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isuint16array_value   Source   Edit
func isUint32Array(value: auto): bool {.importjs: "util.types.$1(#)",
                                        ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_isuint32array_value   Source   Edit
func isWeakMap(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                    tags: [].}
https://nodejs.org/api/util.html#util_util_types_isweakmap_value   Source   Edit
func isWeakSet(value: auto): bool {.importjs: "util.types.$1(#)", ...raises: [],
                                    tags: [].}
https://nodejs.org/api/util.html#util_util_types_isweakset_value   Source   Edit
func isWebAssemblyCompiledModule(value: auto): bool {.
    importjs: "(# instanceof WebAssembly.Module)", ...raises: [], tags: [].}
https://nodejs.org/api/util.html#util_util_types_iswebassemblycompiledmodule_value   Source   Edit
func len(self: Uint8Array): int {.importjs: "(#.length)", ...raises: [], tags: [].}
  Source   Edit
func match(strng: cstring; regex: RegExp): seq[cstring] {.
    importjs: "#.match(#)", ...raises: [], tags: [].}
  Source   Edit
func matchAll(strng: cstring; regex: RegExp): seq[cstring] {.
    importjs: "Array.from(#.matchAll(#))", ...raises: [], tags: [].}
  Source   Edit
func newArrayBuffer(number: Natural): ArrayBuffer {.
    importjs: "new ArrayBuffer(#)", ...raises: [], tags: [].}
  Source   Edit
func newTextDecoder(encoding = "utf-8".cstring; fatal = false; ignoreBOM = false): TextDecoder {.
    importjs: "(new util.TextDecoder(#, {fatal: #, ignoreBOM: #}))", ...raises: [],
    tags: [].}
  Source   Edit
func newTextEncoder(): TextEncoder {.importjs: "(new util.TextEncoder(@))",
                                     ...raises: [], tags: [].}
  Source   Edit
func newUint8Array(number: Natural): Uint8Array {.importjs: "new Uint8Array(#)",
    ...raises: [], tags: [].}
  Source   Edit
func normalize(strng: cstring; form = "NFC".cstring): cstring {.
    importjs: "#.normalize(#)", ...raises: [], tags: [].}
  Source   Edit
func parseBool(s: cstring): bool {.asmnostackframe, ...raises: [], tags: [].}
Convenience func mimics Nim parseBool but optimized for NodeJS. Does NOT ignore '_', if you need to ignore '_' use stdlib or remove the '_'. The reason is that it is more strict than stdlib, because does not allow '_', is not the same as stdlib one.   Source   Edit
proc parseFloat(s: cstring): BiggestFloat {.importjs: "parseFloat(#)",
    ...raises: [], tags: [].}
  Source   Edit
proc parseInt(s: char): cint {.importjs: "parseInt(String.fromCharCode(#), 10)",
                               ...raises: [], tags: [].}
  Source   Edit
proc parseInt(s: cstring): cint {.importjs: "parseInt(#, 10)", ...raises: [],
                                  tags: [].}
  Source   Edit
proc parseUInt(s: char): uint {.importjs: "parseInt(String.fromCharCode(#), 10)",
                                ...raises: [], tags: [].}
  Source   Edit
proc parseUInt(s: cstring): uint {.importjs: "parseInt(#, 10)", ...raises: [],
                                   tags: [].}
  Source   Edit
func repeat(s: cstring; n: Natural): cstring {.importjs: "#.repeat(#)",
    ...raises: [], tags: [].}
  Source   Edit
func replace(s, sub: cstring; by = "".cstring): cstring {.
    importjs: "#.replace(#, #)", ...raises: [], tags: [].}
  Source   Edit
func replace(s: cstring; sub: char; by = "".cstring): cstring {.
    importjs: "#.replace(String.fromCharCode(#), #)", ...raises: [], tags: [].}
  Source   Edit
func replace(s: cstring; sub: char; by: char): cstring {.
    importjs: "#.replace(String.fromCharCode(#), String.fromCharCode(#))",
    ...raises: [], tags: [].}
  Source   Edit
func replace(strng: cstring; regex: RegExp; by = "".cstring): cstring {.
    importjs: "#.replace(#, #)", ...raises: [], tags: [].}
  Source   Edit
func replaceAll(strng: cstring; regex: RegExp; by = "".cstring): cstring {.
    importjs: "#.replaceAll(#, #)", ...raises: [], tags: [].}
  Source   Edit
func requireUtil() {.importjs: "const util = require(\'util\')@", ...raises: [],
                     tags: [].}
Alias for const module_name = require('module_name');. Must be called once before using the module   Source   Edit
func shuffle(arrai: openArray[auto]): seq[auto] {.
    importjs: "#.sort(() => { return Math.random() - 0.5})", ...raises: [],
    tags: [].}
Convenience func to Random shuffle an array.   Source   Edit
func slice(s: cstring; start: cint; ends: cint): cstring {.
    importjs: "#.slice(#, #)", ...raises: [], tags: [].}
  Source   Edit
func split(a: cstring; b: char): seq[cstring] {.
    importjs: "#.split(String.fromCharCode(#))", ...raises: [], tags: [].}
  Source   Edit
func split(a: cstring; b: cstring): seq[cstring] {.importjs: "#.split(#)",
    ...raises: [], tags: [].}
  Source   Edit
func split(strng: cstring; regex: RegExp): seq[cstring] {.
    importjs: "#.split(#)", ...raises: [], tags: [].}
  Source   Edit
func strip(s: cstring): cstring {.importjs: "#.trim()", ...raises: [], tags: [].}
  Source   Edit
func strip(s: cstring; leading: bool; trailing: bool): cstring {.importjs: """  (() => {
    let result = #;
    if (#) { result = result.trimStart() }
    if (#) { result = result.trimEnd()   }
    return result;
  })()""",
    ...raises: [], tags: [].}
  Source   Edit
func structuredClone(value, transfer: auto) {.importjs: "$1(#, #)", ...raises: [],
    tags: [].}
https://developer.mozilla.org/en-US/docs/Web/API/structuredClone   Source   Edit
func structuredClone(value: auto) {.importjs: "$1(#)", ...raises: [], tags: [].}
https://developer.mozilla.org/en-US/docs/Web/API/structuredClone   Source   Edit
func toArray(self: ArrayBuffer): seq[int] {.
    importjs: "Array.from(new Uint8Array(#))", ...raises: [], tags: [].}
  Source   Edit
func toArray(self: Uint8Array): seq[uint8] {.importjs: "Array.from(#)",
    ...raises: [], tags: [].}
  Source   Edit
func toCstring(self: Uint8Array or ArrayBuffer): cstring {.
    importjs: "JSON.stringify(#)", ...raises: [], tags: [].}
  Source   Edit
func toExponential(n: SomeFloat; fractionDigits: Positive): cstring {.
    importjs: "#.$1(#)", ...raises: [], tags: [].}
  Source   Edit
func toFixed(n: SomeFloat; digits: 0 .. 20): cstring {.importjs: "#.$1(#)",
    ...raises: [], tags: [].}
  Source   Edit
func toLowerAscii(c: char): cstring {.importjs: "String.fromCharCode(#).toLowerCase()",
                                      ...raises: [], tags: [].}
  Source   Edit
func toLowerAscii(s: cstring): cstring {.importjs: "#.toLowerCase()",
    ...raises: [], tags: [].}
  Source   Edit
func toPrecision(n: SomeFloat; fractionDigits: Positive): cstring {.
    importjs: "#.$1(#)", ...raises: [], tags: [].}
  Source   Edit
func toUpperAscii(c: char): cstring {.importjs: "String.fromCharCode(#).toUpperCase()",
                                      ...raises: [], tags: [].}
  Source   Edit
func toUpperAscii(s: cstring): cstring {.importjs: "#.toUpperCase()",
    ...raises: [], tags: [].}
  Source   Edit
func `||=`(lhs, rhs: auto): any {.importjs: "(# ||= #)", discardable,
                                  ...raises: [], tags: [].}
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR_assignment   Source   Edit