locutus 2.0.32 → 2.0.35

package/golang/strconv/ParseBool.js

@@ -0,0 +1,35 @@
+module.exports = function ParseBool(str) {
+  //      discuss at: https://locutus.io/golang/strconv/ParseBool
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Parses a boolean string value.
+  //          note 1: Returns [value, null] on success, [false, error] on failure.
+  //          note 1: Accepts: 1, t, T, TRUE, true, True, 0, f, F, FALSE, false, False
+  //       example 1: ParseBool('true')[0]
+  //       returns 1: true
+  //       example 2: ParseBool('FALSE')[0]
+  //       returns 2: false
+  //       example 3: ParseBool('1')[0]
+  //       returns 3: true
+
+  str = (str + '').trim()
+
+  switch (str) {
+    case '1':
+    case 't':
+    case 'T':
+    case 'true':
+    case 'TRUE':
+    case 'True':
+      return [true, null]
+    case '0':
+    case 'f':
+    case 'F':
+    case 'false':
+    case 'FALSE':
+    case 'False':
+      return [false, null]
+    default:
+      return [false, new Error('strconv.ParseBool: parsing "' + str + '": invalid syntax')]
+  }
+}

package/golang/strconv/ParseInt.js

@@ -0,0 +1,27 @@
+module.exports = function ParseInt(s, base, bitSize) {
+  //      discuss at: https://locutus.io/golang/strconv/ParseInt
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Interprets a string s in the given base (0, 2 to 36).
+  //          note 1: Returns [value, null] on success, [0, error] on failure.
+  //       example 1: ParseInt('42', 10, 64)[0]
+  //       returns 1: 42
+  //       example 2: ParseInt('ff', 16, 64)[0]
+  //       returns 2: 255
+  //       example 3: ParseInt('1010', 2, 64)[0]
+  //       returns 3: 10
+
+  s = (s + '').trim()
+  base = parseInt(base, 10) || 10
+
+  if (base < 2 || base > 36) {
+    return [0, new Error('strconv.ParseInt: invalid base ' + base)]
+  }
+
+  const result = parseInt(s, base)
+  if (isNaN(result)) {
+    return [0, new Error('strconv.ParseInt: parsing "' + s + '": invalid syntax')]
+  }
+
+  return [result, null]
+}

package/golang/strconv/index.js

@@ -0,0 +1,6 @@
+module.exports.Atoi = require('./Atoi')
+module.exports.FormatBool = require('./FormatBool')
+module.exports.FormatInt = require('./FormatInt')
+module.exports.Itoa = require('./Itoa')
+module.exports.ParseBool = require('./ParseBool')
+module.exports.ParseInt = require('./ParseInt')

package/golang/strings/Compare.js

@@ -0,0 +1,19 @@
+module.exports = function Compare(a, b) {
+  //      discuss at: https://locutus.io/golang/strings/Compare/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: Compare('a', 'b')
+  //       returns 1: -1
+  //       example 2: Compare('a', 'a')
+  //       returns 2: 0
+  //       example 3: Compare('b', 'a')
+  //       returns 3: 1
+
+  if (a < b) {
+    return -1
+  }
+  if (a > b) {
+    return 1
+  }
+  return 0
+}

package/golang/strings/Contains.js

@@ -1,11 +1,9 @@
-'use strict';
-
 module.exports = function Contains(s, substr) {
-  //  discuss at: https://locutus.io/golang/strings/Contains
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  //   example 1: Contains('Kevin', 'K')
-  //   returns 1: true
+  //      discuss at: https://locutus.io/golang/strings/Contains
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: Contains('Kevin', 'K')
+  //       returns 1: true
 
-  return (s + '').indexOf(substr) !== -1;
-};
-//# sourceMappingURL=Contains.js.map
+  return (s + '').indexOf(substr) !== -1
+}

package/golang/strings/ContainsAny.js

@@ -0,0 +1,18 @@
+module.exports = function ContainsAny(s, chars) {
+  //      discuss at: https://locutus.io/golang/strings/ContainsAny/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: ContainsAny('team', 'i')
+  //       returns 1: false
+  //       example 2: ContainsAny('fail', 'ui')
+  //       returns 2: true
+  //       example 3: ContainsAny('ure', 'ui')
+  //       returns 3: true
+
+  for (const char of chars) {
+    if (s.includes(char)) {
+      return true
+    }
+  }
+  return false
+}

package/golang/strings/Count.js

@@ -1,35 +1,33 @@
-'use strict';
-
 module.exports = function Count(s, sep) {
-  //  discuss at: https://locutus.io/php/printf/
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  //    input by: GopherJS (https://www.gopherjs.org/)
-  //   example 1: Count("cheese", "e")
-  //   returns 1: 3
-  //   example 2: Count("five", "") // before & after each rune
-  //   returns 2: 5
+  //      discuss at: https://locutus.io/golang/strings/Count
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //        input by: GopherJS (https://www.gopherjs.org/)
+  //       example 1: Count("cheese", "e")
+  //       returns 1: 3
+  //       example 2: Count("five", "") // before & after each rune
+  //       returns 2: 5
 
-  var pos = void 0;
-  var n = 0;
+  let pos
+  let n = 0
 
   if (sep.length === 0) {
-    return s.split(sep).length + 1;
+    return s.split(sep).length + 1
   } else if (sep.length > s.length) {
-    return 0;
+    return 0
   } else if (sep.length === s.length) {
     if (sep === s) {
-      return 1;
+      return 1
     }
-    return 0;
+    return 0
   }
   while (true) {
-    pos = (s + '').indexOf(sep);
+    pos = (s + '').indexOf(sep)
     if (pos === -1) {
-      break;
+      break
     }
-    n = n + 1 >> 0;
-    s = s.substring(pos + sep.length >> 0);
+    n = (n + 1) >> 0
+    s = s.substring((pos + sep.length) >> 0)
   }
-  return n;
-};
-//# sourceMappingURL=Count.js.map
+  return n
+}

package/golang/strings/EqualFold.js

@@ -0,0 +1,13 @@
+module.exports = function EqualFold(s, t) {
+  //      discuss at: https://locutus.io/golang/strings/EqualFold/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: EqualFold('Go', 'go')
+  //       returns 1: true
+  //       example 2: EqualFold('Hello', 'HELLO')
+  //       returns 2: true
+  //       example 3: EqualFold('Σ', 'σ')
+  //       returns 3: true
+
+  return s.toLowerCase() === t.toLowerCase()
+}

package/golang/strings/Fields.js

@@ -0,0 +1,12 @@
+module.exports = function Fields(s) {
+  //      discuss at: https://locutus.io/golang/strings/Fields/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: Fields('  foo bar  baz   ')
+  //       returns 1: ['foo', 'bar', 'baz']
+  //       example 2: Fields('')
+  //       returns 2: []
+
+  // Split by whitespace and filter empty strings
+  return s.split(/\s+/).filter((field) => field !== '')
+}

package/golang/strings/HasPrefix.js

@@ -0,0 +1,15 @@
+module.exports = function HasPrefix(s, prefix) {
+  //      discuss at: https://locutus.io/golang/strings/HasPrefix
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: HasPrefix('Gopher', 'Go')
+  //       returns 1: true
+  //       example 2: HasPrefix('Gopher', 'C')
+  //       returns 2: false
+  //       example 3: HasPrefix('Gopher', '')
+  //       returns 3: true
+
+  s = s + ''
+  prefix = prefix + ''
+  return s.slice(0, prefix.length) === prefix
+}

package/golang/strings/HasSuffix.js

@@ -0,0 +1,20 @@
+module.exports = function HasSuffix(s, suffix) {
+  //      discuss at: https://locutus.io/golang/strings/HasSuffix
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: HasSuffix('Amigo', 'go')
+  //       returns 1: true
+  //       example 2: HasSuffix('Amigo', 'O')
+  //       returns 2: false
+  //       example 3: HasSuffix('Amigo', 'Amigo')
+  //       returns 3: true
+  //       example 4: HasSuffix('Amigo', '')
+  //       returns 4: true
+
+  s = s + ''
+  suffix = suffix + ''
+  if (suffix.length === 0) {
+    return true
+  }
+  return s.slice(-suffix.length) === suffix
+}

package/golang/strings/Index.js

@@ -0,0 +1,11 @@
+module.exports = function Index(s, substr) {
+  //      discuss at: https://locutus.io/golang/strings/Index/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: Index('chicken', 'ken')
+  //       returns 1: 4
+  //       example 2: Index('chicken', 'dmr')
+  //       returns 2: -1
+
+  return s.indexOf(substr)
+}

package/golang/strings/Index2.js

@@ -1,13 +1,11 @@
-'use strict';
-
 module.exports = function Index(s, sep) {
-  //  discuss at: https://locutus.io/golang/strings/Index
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  //   example 1: Index('Kevin', 'K')
-  //   returns 1: 0
-  //   example 2: Index('Kevin', 'Z')
-  //   returns 2: -1
+  //      discuss at: https://locutus.io/golang/strings/Index
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: Index('Kevin', 'K')
+  //       returns 1: 0
+  //       example 2: Index('Kevin', 'Z')
+  //       returns 2: -1
 
-  return (s + '').indexOf(sep);
-};
-//# sourceMappingURL=Index2.js.map
+  return (s + '').indexOf(sep)
+}

package/golang/strings/IndexAny.js

@@ -0,0 +1,18 @@
+module.exports = function IndexAny(s, chars) {
+  //      discuss at: https://locutus.io/golang/strings/IndexAny/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: IndexAny('chicken', 'aeiouy')
+  //       returns 1: 2
+  //       example 2: IndexAny('crwth', 'aeiouy')
+  //       returns 2: -1
+
+  let minIndex = -1
+  for (const char of chars) {
+    const idx = s.indexOf(char)
+    if (idx !== -1 && (minIndex === -1 || idx < minIndex)) {
+      minIndex = idx
+    }
+  }
+  return minIndex
+}

package/golang/strings/Join.js

@@ -0,0 +1,16 @@
+module.exports = function Join(elems, sep) {
+  //      discuss at: https://locutus.io/golang/strings/Join
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Concatenates elements of an array to create a single string
+  //       example 1: Join(['foo', 'bar', 'baz'], ', ')
+  //       returns 1: 'foo, bar, baz'
+  //       example 2: Join(['a', 'b', 'c'], '')
+  //       returns 2: 'abc'
+
+  if (!Array.isArray(elems)) {
+    return ''
+  }
+
+  return elems.join(sep + '')
+}

package/golang/strings/LastIndex.js

@@ -1,14 +1,12 @@
-"use strict";
-
 module.exports = function LastIndex(s, sep) {
-  //  discuss at: https://locutus.io/golang/strings/LastIndex
-  // original by: Kevin van Zonneveld (https://kvz.io)
-  //    input by: GopherJS (https://www.gopherjs.org/)
-  //   example 1: LastIndex('go gopher', 'go')
-  //   returns 1: 3
-  //   example 2: LastIndex('go gopher', 'rodent')
-  //   returns 2: -1
+  //      discuss at: https://locutus.io/golang/strings/LastIndex
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //        input by: GopherJS (https://www.gopherjs.org/)
+  //       example 1: LastIndex('go gopher', 'go')
+  //       returns 1: 3
+  //       example 2: LastIndex('go gopher', 'rodent')
+  //       returns 2: -1
 
-  return parseInt(s.lastIndexOf(sep), 10) >> 0;
-};
-//# sourceMappingURL=LastIndex.js.map
+  return parseInt(s.lastIndexOf(sep), 10) >> 0
+}

package/golang/strings/LastIndexAny.js

@@ -0,0 +1,18 @@
+module.exports = function LastIndexAny(s, chars) {
+  //      discuss at: https://locutus.io/golang/strings/LastIndexAny/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: LastIndexAny('go gopher', 'go')
+  //       returns 1: 4
+  //       example 2: LastIndexAny('go gopher', 'rodent')
+  //       returns 2: 8
+
+  let maxIndex = -1
+  for (const char of chars) {
+    const idx = s.lastIndexOf(char)
+    if (idx > maxIndex) {
+      maxIndex = idx
+    }
+  }
+  return maxIndex
+}

package/golang/strings/Repeat.js

@@ -0,0 +1,19 @@
+module.exports = function Repeat(s, count) {
+  //      discuss at: https://locutus.io/golang/strings/Repeat
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns a new string consisting of count copies of s
+  //       example 1: Repeat('na', 2)
+  //       returns 1: 'nana'
+  //       example 2: Repeat('ba', 3)
+  //       returns 2: 'bababa'
+
+  s = s + ''
+  count = parseInt(count, 10)
+
+  if (count < 0 || !isFinite(count)) {
+    throw new Error('strings: negative Repeat count')
+  }
+
+  return s.repeat(count)
+}

package/golang/strings/Replace.js

@@ -0,0 +1,44 @@
+module.exports = function Replace(s, old, newStr, n) {
+  //      discuss at: https://locutus.io/golang/strings/Replace
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: n is the number of replacements. If n < 0, no limit on replacements.
+  //       example 1: Replace('oink oink oink', 'k', 'ky', 2)
+  //       returns 1: 'oinky oinky oink'
+  //       example 2: Replace('oink oink oink', 'oink', 'moo', -1)
+  //       returns 2: 'moo moo moo'
+
+  s = s + ''
+  old = old + ''
+  newStr = newStr + ''
+
+  if (old === '') {
+    return s
+  }
+
+  if (n === 0) {
+    return s
+  }
+
+  if (n < 0) {
+    // Replace all occurrences
+    return s.split(old).join(newStr)
+  }
+
+  // Replace n occurrences
+  let result = s
+  let count = 0
+  let pos = 0
+
+  while (count < n) {
+    const idx = result.indexOf(old, pos)
+    if (idx === -1) {
+      break
+    }
+    result = result.slice(0, idx) + newStr + result.slice(idx + old.length)
+    pos = idx + newStr.length
+    count++
+  }
+
+  return result
+}

package/golang/strings/Split.js

@@ -0,0 +1,24 @@
+module.exports = function Split(s, sep) {
+  //      discuss at: https://locutus.io/golang/strings/Split
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Returns an array of substrings split by sep
+  //       example 1: Split('a,b,c', ',')
+  //       returns 1: ['a', 'b', 'c']
+  //       example 2: Split('a man a plan a canal panama', 'a ')
+  //       returns 2: ['', 'man ', 'plan ', 'canal panama']
+  //       example 3: Split(' xyz ', '')
+  //       returns 3: [' ', 'x', 'y', 'z', ' ']
+  //       example 4: Split('', 'Bernardo O\'Higgins')
+  //       returns 4: ['']
+
+  s = s + ''
+  sep = sep + ''
+
+  if (sep === '') {
+    // Split into individual characters (like Go's behavior)
+    return s.split('')
+  }
+
+  return s.split(sep)
+}

package/golang/strings/ToLower.js

@@ -0,0 +1,9 @@
+module.exports = function ToLower(s) {
+  //      discuss at: https://locutus.io/golang/strings/ToLower
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: ToLower('Gopher')
+  //       returns 1: 'gopher'
+
+  return (s + '').toLowerCase()
+}

package/golang/strings/ToUpper.js

@@ -0,0 +1,9 @@
+module.exports = function ToUpper(s) {
+  //      discuss at: https://locutus.io/golang/strings/ToUpper
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: ToUpper('Gopher')
+  //       returns 1: 'GOPHER'
+
+  return (s + '').toUpperCase()
+}

package/golang/strings/Trim.js

@@ -0,0 +1,19 @@
+module.exports = function Trim(s, cutset) {
+  //      discuss at: https://locutus.io/golang/strings/Trim
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Unlike Go's strings.Trim which removes characters in cutset,
+  //          note 1: this implementation removes exact matches of cutset from both ends
+  //       example 1: Trim('!!!Hello, Gophers!!!', '!')
+  //       returns 1: 'Hello, Gophers'
+  //       example 2: Trim('  Hello  ', ' ')
+  //       returns 2: 'Hello'
+
+  s = s + ''
+  cutset = cutset + ''
+
+  // Build regex to match cutset characters at start and end
+  const escaped = cutset.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+  const regex = new RegExp('^[' + escaped + ']+|[' + escaped + ']+$', 'g')
+  return s.replace(regex, '')
+}

package/golang/strings/TrimLeft.js

@@ -0,0 +1,15 @@
+module.exports = function TrimLeft(s, cutset) {
+  //      discuss at: https://locutus.io/golang/strings/TrimLeft/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: TrimLeft('¡¡¡Hello, Gophers!!!', '!¡')
+  //       returns 1: 'Hello, Gophers!!!'
+  //       example 2: TrimLeft('  hello  ', ' ')
+  //       returns 2: 'hello  '
+
+  let start = 0
+  while (start < s.length && cutset.includes(s[start])) {
+    start++
+  }
+  return s.slice(start)
+}

package/golang/strings/TrimPrefix.js

@@ -0,0 +1,14 @@
+module.exports = function TrimPrefix(s, prefix) {
+  //      discuss at: https://locutus.io/golang/strings/TrimPrefix/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: TrimPrefix('Hello, World!', 'Hello, ')
+  //       returns 1: 'World!'
+  //       example 2: TrimPrefix('Hello, World!', 'Goodbye, ')
+  //       returns 2: 'Hello, World!'
+
+  if (s.startsWith(prefix)) {
+    return s.slice(prefix.length)
+  }
+  return s
+}

package/golang/strings/TrimRight.js

@@ -0,0 +1,15 @@
+module.exports = function TrimRight(s, cutset) {
+  //      discuss at: https://locutus.io/golang/strings/TrimRight/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: TrimRight('¡¡¡Hello, Gophers!!!', '!¡')
+  //       returns 1: '¡¡¡Hello, Gophers'
+  //       example 2: TrimRight('  hello  ', ' ')
+  //       returns 2: '  hello'
+
+  let end = s.length
+  while (end > 0 && cutset.includes(s[end - 1])) {
+    end--
+  }
+  return s.slice(0, end)
+}

package/golang/strings/TrimSpace.js

@@ -0,0 +1,10 @@
+module.exports = function TrimSpace(s) {
+  //      discuss at: https://locutus.io/golang/strings/TrimSpace
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //          note 1: Removes leading and trailing white space (as defined by Unicode)
+  //       example 1: TrimSpace(' \t\n Hello, Gophers \n\t\r\n')
+  //       returns 1: 'Hello, Gophers'
+
+  return (s + '').trim()
+}

package/golang/strings/TrimSuffix.js

@@ -0,0 +1,14 @@
+module.exports = function TrimSuffix(s, suffix) {
+  //      discuss at: https://locutus.io/golang/strings/TrimSuffix/
+  // parity verified: Go 1.23
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: TrimSuffix('Hello, World!', ', World!')
+  //       returns 1: 'Hello'
+  //       example 2: TrimSuffix('Hello, World!', 'Goodbye')
+  //       returns 2: 'Hello, World!'
+
+  if (s.endsWith(suffix)) {
+    return s.slice(0, s.length - suffix.length)
+  }
+  return s
+}

package/golang/strings/index.js

@@ -1,7 +1,25 @@
-'use strict';
-
-module.exports.Contains = require('./Contains');
-module.exports.Count = require('./Count');
-module.exports.Index = require('./Index2');
-module.exports.LastIndex = require('./LastIndex');
-//# sourceMappingURL=index.js.map
+module.exports.Compare = require('./Compare')
+module.exports.Contains = require('./Contains')
+module.exports.ContainsAny = require('./ContainsAny')
+module.exports.Count = require('./Count')
+module.exports.EqualFold = require('./EqualFold')
+module.exports.Fields = require('./Fields')
+module.exports.HasPrefix = require('./HasPrefix')
+module.exports.HasSuffix = require('./HasSuffix')
+module.exports.Index = require('./Index2')
+module.exports.Index = require('./Index2')
+module.exports.IndexAny = require('./IndexAny')
+module.exports.Join = require('./Join')
+module.exports.LastIndex = require('./LastIndex')
+module.exports.LastIndexAny = require('./LastIndexAny')
+module.exports.Repeat = require('./Repeat')
+module.exports.Replace = require('./Replace')
+module.exports.Split = require('./Split')
+module.exports.ToLower = require('./ToLower')
+module.exports.ToUpper = require('./ToUpper')
+module.exports.Trim = require('./Trim')
+module.exports.TrimLeft = require('./TrimLeft')
+module.exports.TrimPrefix = require('./TrimPrefix')
+module.exports.TrimRight = require('./TrimRight')
+module.exports.TrimSpace = require('./TrimSpace')
+module.exports.TrimSuffix = require('./TrimSuffix')

package/index.js

@@ -1,8 +1,5 @@
-'use strict';
-
-module.exports.c = require('./c');
-module.exports.golang = require('./golang');
-module.exports.php = require('./php');
-module.exports.python = require('./python');
-module.exports.ruby = require('./ruby');
-//# sourceMappingURL=index.js.map
+module.exports.c = require('./c')
+module.exports.golang = require('./golang')
+module.exports.php = require('./php')
+module.exports.python = require('./python')
+module.exports.ruby = require('./ruby')

package/julia/Base/abs.js

@@ -0,0 +1,13 @@
+module.exports = function abs(x) {
+  //      discuss at: https://locutus.io/julia/abs/
+  // parity verified: Julia 1.11
+  //     original by: Kevin van Zonneveld (https://kvz.io)
+  //       example 1: abs(-5)
+  //       returns 1: 5
+  //       example 2: abs(3.14)
+  //       returns 2: 3.14
+  //       example 3: abs(0)
+  //       returns 3: 0
+
+  return Math.abs(x)
+}