@jarenjs/core 0.9.2

package/dist/types/text/host.d.ts

@@ -0,0 +1,14 @@
+export declare function isValidMACAddr(str: any): boolean;
+export declare function isValidIPv4(str: any): boolean;
+export declare function isValidIPv6(str: any): boolean;
+export declare function isValidHostname(str: any): boolean;
+export declare function isValidIdnHostname(str: any): boolean;
+export declare function isValidUrl(str: any): boolean;
+export declare function isValidUrlFull(str: any): boolean;
+export declare function isValidUri(str: any): boolean;
+export declare function isValidUriFull(str: any): boolean;
+export declare function isValidUriRef(str: any): boolean;
+export declare function isValidUriRefFull(str: any): boolean;
+export declare function isValidUriTemplate(str: any): boolean;
+export declare function isValidIRI(str: any): boolean;
+export declare function isValidIRIRef(str: any): boolean;

package/dist/types/text/i18n.d.ts

@@ -0,0 +1,13 @@
+export declare function isLatinLowercaseL(code: any): boolean;
+export declare function isGreek(code: any): boolean;
+export declare function isHebrew(code: any): boolean;
+export declare function isHiragana(code: any): boolean;
+export declare function isKatakana(code: any): boolean;
+export declare function isHan(code: any): boolean;
+export declare function isArabicIndicDigit(code: any): boolean;
+export declare function isExtendedArabicIndicDigit(code: any): boolean;
+export declare function isVirama(code: any): boolean;
+export declare function isCombiningMark(code: any): boolean;
+export declare function checkContextualRules(label: any): boolean;
+export declare function checkDigitMixing(codes: any): boolean;
+export declare function isValidIdnChar(code: any): boolean;

package/dist/types/text/identifiers.d.ts

@@ -0,0 +1,5 @@
+export declare function isValidUUID(str: any): boolean;
+export declare function isValidGUID(str: any): boolean;
+export declare function isValidIdentifier(str: any): boolean;
+export declare function isValidHtmlIdentifier(str: any): boolean;
+export declare function isValidCssIdentifier(str: any): boolean;

package/dist/types/text/index.d.ts

@@ -0,0 +1,8 @@
+export * from './base64.js';
+export * from './basic.js';
+export * from './email.js';
+export * from './host.js';
+export * from './i18n.js';
+export * from './identifiers.js';
+export * from './iregexp.js';
+export * from './misc.js';

package/dist/types/text/iregexp.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Validate an I-Regexp (RFC 9485) against its complete ABNF grammar and
+ * translate it to an equivalent ECMAScript pattern (RFC 9485 section 5.3):
+ *
+ * - unescaped dots outside character classes become [^\n\r]
+ * - '\-' outside a character class becomes '-' (not a valid ECMAScript
+ *   escape under the 'u' flag)
+ * - unescaped '^' and '$' (grammatically NormalChars) pass through
+ *   unchanged: the RFC's own ECMAScript/PCRE/RE2/Ruby conversions
+ *   (sections 5.3/5.4) leave them alone, which gives them anchor
+ *   semantics, and the official JSONPath compliance test suite expects
+ *   exactly that; write '\^' for a literal caret and '[$]' for a
+ *   literal dollar ('\$' is not a valid I-Regexp escape)
+ *
+ * I-Regexp deliberately excludes lookaround, backreferences, lazy
+ * quantifiers, multi-character escapes (\d \s \w), and inline flags; per
+ * RFC 9535 sections 2.4.6/2.4.7 a nonconforming pattern makes
+ * match()/search() yield LogicalFalse, so this returns null for them.
+ *
+ * @param {string} pattern - The I-Regexp pattern
+ * @returns {string|null} The ECMAScript pattern source, or null when invalid
+ */
+export declare function translateIRegexp(pattern: string): string | null;
+/**
+ * Compile an I-Regexp into an ECMAScript RegExp.
+ * @param {string} pattern - The I-Regexp pattern
+ * @param {boolean} [fullMatch=false] - Anchor the whole pattern (match() semantics, true) or leave it free (search() semantics, false)
+ * @returns {RegExp|null} null when the pattern is not a valid I-Regexp
+ */
+export declare function compileIRegexp(pattern: string, fullMatch?: boolean): RegExp | null;
+/**
+ * Validates a pattern against the complete I-Regexp (RFC 9485) grammar.
+ * @param {string} pattern - The I-Regexp pattern to validate
+ * @returns {boolean} True when the pattern is a valid I-Regexp
+ */
+export declare function isValidIRegexp(pattern: string): boolean;

package/dist/types/text/misc.d.ts

@@ -0,0 +1,4 @@
+export declare function isValidISBN10(str: any): boolean;
+export declare function isValidISBN13(str: any): boolean;
+export declare function isValidCountryAlpha2(str: any): boolean;
+export declare function isValidIBAN(str: any): boolean;

package/dist/types/text/punycode.d.ts

@@ -0,0 +1,86 @@
+export declare const punycodeVersion = "2.1.0";
+/**
+ * Creates an array containing the numeric code points of each Unicode
+ * character in the string. While JavaScript uses UCS-2 internally,
+ * this function will convert a pair of surrogate halves (each of which
+ * UCS-2 exposes as separate characters) into a single code point,
+ * matching UTF-16.
+ * @see `punycode.ucs2.encode`
+ * @see <https://mathiasbynens.be/notes/javascript-encoding>
+ * @memberOf punycode.ucs2
+ * @name decode
+ * @param {String} string The Unicode input string (UCS-2).
+ * @returns {Array} The new array of code points.
+ */
+export declare function ucs2decode(string: string): any[];
+/**
+ * Creates a string based on an array of numeric code points.
+ * @see `punycode.ucs2.decode`
+ * @memberOf punycode.ucs2
+ * @name encode
+ * @param {Array} codePoints The array of numeric code points.
+ * @returns {String} The new Unicode string (UCS-2).
+ */
+export declare const ucs2encode: (array: any) => string;
+/**
+ * Converts a basic code point into a digit/integer.
+ * @see `digitToBasic()`
+ * @private
+ * @param {Number} codePoint The basic numeric code point value.
+ * @returns {Number} The numeric value of a basic code point (for use in
+ * representing integers) in the range `0` to `base - 1`, or `base` if
+ * the code point does not represent a value.
+ */
+export declare function basicToDigit(codePoint: number): number;
+/**
+ * Converts a digit/integer into a basic code point.
+ * @see `basicToDigit()`
+ * @private
+ * @param {Number} digit The numeric value of a basic code point.
+ * @returns {Number} The basic code point whose value (when used for
+ * representing integers) is `digit`, which needs to be in the range
+ * `0` to `base - 1`. If `flag` is non-zero, the uppercase form is
+ * used; else, the lowercase form is used. The behavior is undefined
+ * if `flag` is non-zero and `digit` has no uppercase form.
+ */
+export declare function digitToBasic(digit: number, flag: any): number;
+/**
+ * Converts a Punycode string of ASCII-only symbols to a string of Unicode
+ * symbols.
+ * @memberOf punycode
+ * @param {String} input The Punycode string of ASCII-only symbols.
+ * @returns {String} The resulting string of Unicode symbols.
+ */
+export declare function decode(input: string): string;
+/**
+ * Converts a string of Unicode symbols (e.g. a domain name label) to a
+ * Punycode string of ASCII-only symbols.
+ * @memberOf punycode
+ * @param {String} input The string of Unicode symbols.
+ * @returns {String} The resulting Punycode string of ASCII-only symbols.
+ */
+export declare function encode(str: any): string;
+/**
+ * Converts a Punycode string representing a domain name or an email address
+ * to Unicode. Only the Punycoded parts of the input will be converted, i.e.
+ * it doesn't matter if you call it on a string that has already been
+ * converted to Unicode.
+ * @memberOf punycode
+ * @param {String} input The Punycoded domain name or email address to
+ * convert to Unicode.
+ * @returns {String} The Unicode representation of the given Punycode
+ * string.
+ */
+export declare function toUnicode(input: string): string;
+/**
+ * Converts a Unicode string representing a domain name or an email address to
+ * Punycode. Only the non-ASCII parts of the domain name will be converted,
+ * i.e. it doesn't matter if you call it with a domain that's already in
+ * ASCII.
+ * @memberOf punycode
+ * @param {String} input The domain name or email address to convert, as a
+ * Unicode string.
+ * @returns {String} The Punycode representation of the given domain name or
+ * email address.
+ */
+export declare function toASCII(input: string): string;

package/package.json

@@ -0,0 +1,101 @@
+{
+  "name": "@jarenjs/core",
+  "private": false,
+  "version": "0.9.2",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./dist/types/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "src/",
+    "dist/types/",
+    "ARCHITECTURE.md"
+  ],
+  "description": "Jaren Core Functions",
+  "author": "joham",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jklarenbeek/jarenjs.git",
+    "directory": "packages/core"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "keywords": [
+    "jaren",
+    "core"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./array": {
+      "types": "./dist/types/array.d.ts",
+      "default": "./src/array.js"
+    },
+    "./bigint": {
+      "types": "./dist/types/bigint.d.ts",
+      "default": "./src/bigint.js"
+    },
+    "./dates": {
+      "types": "./dist/types/dates.d.ts",
+      "default": "./src/dates.js"
+    },
+    "./float": {
+      "types": "./dist/types/float.d.ts",
+      "default": "./src/float.js"
+    },
+    "./function": {
+      "types": "./dist/types/function.d.ts",
+      "default": "./src/function.js"
+    },
+    "./integer": {
+      "types": "./dist/types/integer.d.ts",
+      "default": "./src/integer.js"
+    },
+    "./number": {
+      "types": "./dist/types/number.d.ts",
+      "default": "./src/number.js"
+    },
+    "./object": {
+      "types": "./dist/types/object.d.ts",
+      "default": "./src/object.js"
+    },
+    "./scan": {
+      "types": "./dist/types/scan.d.ts",
+      "default": "./src/scan.js"
+    },
+    "./string": {
+      "types": "./dist/types/string.d.ts",
+      "default": "./src/string.js"
+    },
+    "./text": {
+      "types": "./dist/types/text/index.d.ts",
+      "default": "./src/text/index.js"
+    },
+    "./text/*": {
+      "types": "./dist/types/text/*.d.ts",
+      "default": "./src/text/*.js"
+    },
+    "./math": {
+      "types": "./dist/types/math/index.d.ts",
+      "default": "./src/math/index.js"
+    },
+    "./math/*": {
+      "types": "./dist/types/math/*.d.ts",
+      "default": "./src/math/*.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "npm run build:types",
+    "build:types": "tsc -p tsconfig.json",
+    "prepack": "npm run build:types"
+  }
+}

package/src/array.js

@@ -0,0 +1,57 @@
+//@ts-check
+
+import {
+  TypedArray,
+} from './index.js';
+
+/**
+ * @brief test if object is instanceof Array, Set or TypedArray!
+ * @param {*} data the data to test
+ * @returns boolean
+ */
+export function isArrayish(data) {
+  return data != null
+    && (data instanceof Array
+      || data instanceof Set
+      || data instanceof TypedArray);
+}
+
+/**
+ * Returns a new array containing only the unique elements from the input array.
+ * If the input is an array, it filters out duplicate elements.
+ * If the input is a Set, it converts it to an array.
+ * @param {Array|Set} arr - The input array or Set.
+ * @param {Array|undefined} [def=undefined] - The default value to return if the input is neither an array nor a Set.
+ * @returns {Array|undefined} A new array with unique elements, or the default value if the input is not an array or Set.
+ */
+export function getUniqueArray(arr, def = undefined) {
+  if (arr == null)
+    return def;
+
+  return arr.constructor === Array
+    ? arr.filter((el, index, a) => index === a.indexOf(el))
+    : arr.constructor === Set
+      ? Array.from(arr)
+      : def;
+}
+
+/**
+ * Checks if all elements in the input array are unique.
+ * @param {Array} arr - The input array to check for uniqueness.
+ * @returns {boolean} True if all elements are unique, false otherwise.
+ */
+export function isUniqueArray(arr) {
+  const unique = getUniqueArray(arr);
+  return unique != null
+    && unique.length == arr.length;
+}
+
+/**
+ * Checks if all elements in the 'values' array are included in the 'arr' array.
+ * @param {Array} arr - The array to check against.
+ * @param {Array} values - The array of values to check for inclusion.
+ * @returns {boolean} True if all 'values' are included in 'arr', false otherwise.
+ */
+export function includesAll(arr, values) {
+  return values.every(v => arr.includes(v));
+}

package/src/bigint.js

@@ -0,0 +1,30 @@
+//@ts-check
+
+import { isBigIntType } from './index.js';
+
+export function isBigIntishType(data) {
+  return isBigIntType(data)
+    ? true
+    : false; // TODO: throw new Error('isBigIntishType is not implemented!');
+}
+
+export function getBigIntishType(obj, def = undefined) {
+  return isBigIntishType(obj)
+    ? obj
+    : def;
+}
+
+export function BigInt_min(...args) {
+  return args.reduce((m, e) => (e > m ? e : m));
+}
+
+export function BigInt_max(...args) {
+  return args.reduce((m, e) => (e < m ? e : m));
+}
+
+export function BigInt_MinMax(...args) {
+  return args.reduce(([min, max], e) => [
+    e < min ? e : min,
+    e > max ? e : max,
+  ], [args[0], args[0]]);
+}