@nudojs/env 0.2.3 → 0.2.5

package/package.json

@@ -1,6 +1,9 @@
 {
   "name": "@nudojs/env",
-  "version": "0.2.3",
+  "version": "0.2.5",
+  "engines": {
+    "node": ">=20"
+  },
   "description": "ES standard, Web platform, and Node.js API type definitions for the Nudo inference engine",
   "type": "module",
   "license": "MIT",
@@ -32,7 +35,7 @@
     "registry": "https://registry.npmjs.org"
   },
   "dependencies": {
-    "@nudojs/core": "0.4.0"
+    "@nudojs/core": "1.0.1"
   },
   "scripts": {
     "build": "tsup src/es.ts src/web.ts src/node.ts --format esm --dts"

package/dist/chunk-VBTQ36SR.js

@@ -1,227 +0,0 @@
-// src/es.ts
-import { T } from "@nudojs/core";
-function litNum(tv) {
-  return tv.kind === "literal" && typeof tv.value === "number" ? tv.value : void 0;
-}
-function litStr(tv) {
-  return tv.kind === "literal" && typeof tv.value === "string" ? tv.value : void 0;
-}
-function numImpl1(fn) {
-  return (args) => {
-    const a = litNum(args[0]);
-    return a !== void 0 ? T.literal(fn(a)) : void 0;
-  };
-}
-function numImpl2(fn) {
-  return (args) => {
-    const a = litNum(args[0]);
-    const b = litNum(args[1]);
-    return a !== void 0 && b !== void 0 ? T.literal(fn(a, b)) : void 0;
-  };
-}
-function strToStrImpl(fn) {
-  return (args) => {
-    const s = litStr(args[0]);
-    return s !== void 0 ? T.literal(fn(s)) : void 0;
-  };
-}
-function defineEnv() {
-  const voidFn = T.fnSig([T.unknown], T.undefined);
-  const consoleMethods = {};
-  for (const name of ["log", "error", "warn", "info", "debug", "trace", "dir", "table", "time", "timeEnd", "timeLog", "clear", "count", "countReset", "group", "groupCollapsed", "groupEnd", "assert"]) {
-    consoleMethods[name] = voidFn;
-  }
-  const jsonStringifyImpl = (args) => {
-    const v = args[0];
-    if (v.kind === "literal") {
-      try {
-        const result = JSON.stringify(v.value);
-        return result === void 0 ? T.undefined : T.literal(result);
-      } catch {
-      }
-    }
-    return void 0;
-  };
-  const parseIntImpl = (args) => {
-    const s = litStr(args[0]);
-    const radix = args[1] !== void 0 ? litNum(args[1]) : 10;
-    if (s !== void 0 && radix !== void 0) {
-      const result = parseInt(s, radix);
-      return Number.isNaN(result) ? T.literal(NaN) : T.literal(result);
-    }
-    return void 0;
-  };
-  const parseFloatImpl = (args) => {
-    const s = litStr(args[0]);
-    if (s !== void 0) {
-      const result = parseFloat(s);
-      return T.literal(result);
-    }
-    return void 0;
-  };
-  const isNaNImpl = (args) => {
-    const v = args[0];
-    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isNaN(v.value));
-    return void 0;
-  };
-  const isFiniteImpl = (args) => {
-    const v = args[0];
-    if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isFinite(v.value));
-    return void 0;
-  };
-  return {
-    globals: {
-      // --- JSON ---
-      JSON: T.object({
-        parse: T.fnSig([T.string], T.unknown, T.instanceOf("SyntaxError")),
-        stringify: T.fnSig([T.unknown], T.union(T.string, T.undefined), T.never, jsonStringifyImpl)
-      }),
-      // --- Math ---
-      Math: T.object({
-        abs: T.fnSig([T.number], T.number, T.never, numImpl1(Math.abs)),
-        ceil: T.fnSig([T.number], T.number, T.never, numImpl1(Math.ceil)),
-        floor: T.fnSig([T.number], T.number, T.never, numImpl1(Math.floor)),
-        round: T.fnSig([T.number], T.number, T.never, numImpl1(Math.round)),
-        trunc: T.fnSig([T.number], T.number, T.never, numImpl1(Math.trunc)),
-        sign: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sign)),
-        max: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.max)),
-        min: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.min)),
-        pow: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.pow)),
-        sqrt: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sqrt)),
-        cbrt: T.fnSig([T.number], T.number, T.never, numImpl1(Math.cbrt)),
-        log: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log)),
-        log2: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log2)),
-        log10: T.fnSig([T.number], T.number, T.never, numImpl1(Math.log10)),
-        exp: T.fnSig([T.number], T.number, T.never, numImpl1(Math.exp)),
-        random: T.fnSig([], T.number),
-        sin: T.fnSig([T.number], T.number, T.never, numImpl1(Math.sin)),
-        cos: T.fnSig([T.number], T.number, T.never, numImpl1(Math.cos)),
-        tan: T.fnSig([T.number], T.number, T.never, numImpl1(Math.tan)),
-        asin: T.fnSig([T.number], T.number, T.never, numImpl1(Math.asin)),
-        acos: T.fnSig([T.number], T.number, T.never, numImpl1(Math.acos)),
-        atan: T.fnSig([T.number], T.number, T.never, numImpl1(Math.atan)),
-        atan2: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.atan2)),
-        hypot: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.hypot)),
-        clz32: T.fnSig([T.number], T.number, T.never, numImpl1(Math.clz32)),
-        imul: T.fnSig([T.number, T.number], T.number, T.never, numImpl2(Math.imul)),
-        fround: T.fnSig([T.number], T.number, T.never, numImpl1(Math.fround)),
-        PI: T.number,
-        E: T.number,
-        LN2: T.number,
-        LN10: T.number,
-        LOG2E: T.number,
-        LOG10E: T.number,
-        SQRT2: T.number,
-        SQRT1_2: T.number
-      }),
-      // --- Number ---
-      Number: T.object({
-        isFinite: T.fnSig([T.unknown], T.boolean, T.never, isFiniteImpl),
-        isInteger: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-          const v = args[0];
-          if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isInteger(v.value));
-          return void 0;
-        }),
-        isNaN: T.fnSig([T.unknown], T.boolean, T.never, isNaNImpl),
-        isSafeInteger: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-          const v = args[0];
-          if (v.kind === "literal" && typeof v.value === "number") return T.literal(Number.isSafeInteger(v.value));
-          return void 0;
-        }),
-        parseFloat: T.fnSig([T.string], T.number, T.never, parseFloatImpl),
-        parseInt: T.fnSig([T.string], T.number, T.never, parseIntImpl),
-        MAX_SAFE_INTEGER: T.number,
-        MIN_SAFE_INTEGER: T.number,
-        MAX_VALUE: T.number,
-        MIN_VALUE: T.number,
-        POSITIVE_INFINITY: T.number,
-        NEGATIVE_INFINITY: T.number,
-        NaN: T.number,
-        EPSILON: T.number
-      }),
-      // --- Boolean ---
-      Boolean: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-        const v = args[0];
-        if (v.kind === "literal") return T.literal(Boolean(v.value));
-        return void 0;
-      }),
-      // --- String ---
-      String: T.fnSig([T.unknown], T.string, T.never, (args) => {
-        const v = args[0];
-        if (v.kind === "literal" && v.value !== null && v.value !== void 0) return T.literal(String(v.value));
-        return void 0;
-      }),
-      // --- Array ---
-      Array: T.object({
-        isArray: T.fnSig([T.unknown], T.boolean, T.never, (args) => {
-          const v = args[0];
-          if (v.kind === "array" || v.kind === "tuple") return T.literal(true);
-          if (v.kind === "literal" || v.kind === "primitive" || v.kind === "object") return T.literal(false);
-          return void 0;
-        }),
-        from: T.fnSig([T.unknown], T.array(T.unknown)),
-        of: T.fnSig([T.unknown], T.array(T.unknown))
-      }),
-      // --- console ---
-      console: T.object(consoleMethods),
-      // --- Global functions ---
-      parseInt: T.fnSig([T.string, T.number], T.number, T.never, parseIntImpl),
-      parseFloat: T.fnSig([T.string], T.number, T.never, parseFloatImpl),
-      isNaN: T.fnSig([T.unknown], T.boolean, T.never, isNaNImpl),
-      isFinite: T.fnSig([T.unknown], T.boolean, T.never, isFiniteImpl),
-      encodeURI: T.fnSig([T.string], T.string, T.never, strToStrImpl(encodeURI)),
-      decodeURI: T.fnSig([T.string], T.string, T.instanceOf("URIError"), strToStrImpl(decodeURI)),
-      encodeURIComponent: T.fnSig([T.string], T.string, T.never, strToStrImpl(encodeURIComponent)),
-      decodeURIComponent: T.fnSig([T.string], T.string, T.instanceOf("URIError"), strToStrImpl(decodeURIComponent)),
-      // --- Error constructors ---
-      Error: T.fnSig([T.string], T.instanceOf("Error")),
-      TypeError: T.fnSig([T.string], T.instanceOf("TypeError")),
-      RangeError: T.fnSig([T.string], T.instanceOf("RangeError")),
-      SyntaxError: T.fnSig([T.string], T.instanceOf("SyntaxError")),
-      ReferenceError: T.fnSig([T.string], T.instanceOf("ReferenceError")),
-      URIError: T.fnSig([T.string], T.instanceOf("URIError")),
-      // --- Promise ---
-      Promise: T.object({
-        resolve: T.fnSig([T.unknown], T.promise(T.unknown), T.never, (args) => T.promise(args[0])),
-        reject: T.fnSig([T.unknown], T.promise(T.never)),
-        all: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.array(T.unknown))),
-        allSettled: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.array(T.unknown))),
-        race: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.unknown)),
-        any: T.fnSig([T.array(T.promise(T.unknown))], T.promise(T.unknown))
-      }),
-      // --- Date ---
-      Date: T.object({
-        now: T.fnSig([], T.number),
-        parse: T.fnSig([T.string], T.number),
-        UTC: T.fnSig([T.number, T.number], T.number)
-      }),
-      // --- Symbol ---
-      Symbol: T.fnSig([T.string], T.symbol),
-      // --- Reflect ---
-      Reflect: T.object({
-        apply: T.fnSig([T.unknown, T.unknown, T.array(T.unknown)], T.unknown),
-        construct: T.fnSig([T.unknown, T.array(T.unknown)], T.unknown),
-        defineProperty: T.fnSig([T.unknown, T.string, T.unknown], T.boolean),
-        deleteProperty: T.fnSig([T.unknown, T.string], T.boolean),
-        get: T.fnSig([T.unknown, T.string], T.unknown),
-        getOwnPropertyDescriptor: T.fnSig([T.unknown, T.string], T.union(T.unknown, T.undefined)),
-        getPrototypeOf: T.fnSig([T.unknown], T.union(T.unknown, T.null)),
-        has: T.fnSig([T.unknown, T.string], T.boolean),
-        isExtensible: T.fnSig([T.unknown], T.boolean),
-        ownKeys: T.fnSig([T.unknown], T.array(T.string)),
-        preventExtensions: T.fnSig([T.unknown], T.boolean),
-        set: T.fnSig([T.unknown, T.string, T.unknown], T.boolean),
-        setPrototypeOf: T.fnSig([T.unknown, T.unknown], T.boolean)
-      }),
-      // --- globalThis ---
-      globalThis: T.unknown,
-      undefined: T.undefined,
-      NaN: T.number,
-      Infinity: T.number
-    }
-  };
-}
-
-export {
-  defineEnv
-};