@ray-js/robot-data-stream 0.0.14 → 0.0.15-beta.1

package/lib/myLib/zod/src/v4/core/util.js

@@ -0,0 +1,656 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.map.js";
+import "core-js/modules/esnext.iterator.reduce.js";
+// json
+
+// utils
+
+// | bigint | boolean | symbol;
+
+// string | Array<unknown> | Set<unknown> | File;
+
+// functions
+export function assertEqual(val) {
+  return val;
+}
+export function assertNotEqual(val) {
+  return val;
+}
+export function assertIs() {}
+export function assertNever() {
+  throw new Error("Unexpected value in exhaustive check");
+}
+export function assert() {}
+export function getEnumValues(entries) {
+  const numericValues = Object.values(entries).filter(v => typeof v === "number");
+  const values = Object.entries(entries).filter(_ref => {
+    let [k, _] = _ref;
+    return numericValues.indexOf(+k) === -1;
+  }).map(_ref2 => {
+    let [_, v] = _ref2;
+    return v;
+  });
+  return values;
+}
+export function joinValues(array) {
+  let separator = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "|";
+  return array.map(val => stringifyPrimitive(val)).join(separator);
+}
+export function jsonStringifyReplacer(_, value) {
+  if (typeof value === "bigint") return value.toString();
+  return value;
+}
+export function cached(getter) {
+  return {
+    get value() {
+      {
+        const value = getter();
+        Object.defineProperty(this, "value", {
+          value
+        });
+        return value;
+      }
+      throw new Error("cached value already set");
+    }
+  };
+}
+export function nullish(input) {
+  return input === null || input === undefined;
+}
+export function cleanRegex(source) {
+  const start = source.startsWith("^") ? 1 : 0;
+  const end = source.endsWith("$") ? source.length - 1 : source.length;
+  return source.slice(start, end);
+}
+export function floatSafeRemainder(val, step) {
+  const valDecCount = (val.toString().split(".")[1] || "").length;
+  const stepString = step.toString();
+  let stepDecCount = (stepString.split(".")[1] || "").length;
+  if (stepDecCount === 0 && /\d?e-\d?/.test(stepString)) {
+    const match = stepString.match(/\d?e-(\d?)/);
+    if (match !== null && match !== void 0 && match[1]) {
+      stepDecCount = Number.parseInt(match[1]);
+    }
+  }
+  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
+  const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
+  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
+  return valInt % stepInt / 10 ** decCount;
+}
+const EVALUATING = Symbol("evaluating");
+export function defineLazy(object, key, getter) {
+  let value = undefined;
+  Object.defineProperty(object, key, {
+    get() {
+      if (value === EVALUATING) {
+        // Circular reference detected, return undefined to break the cycle
+        return undefined;
+      }
+      if (value === undefined) {
+        value = EVALUATING;
+        value = getter();
+      }
+      return value;
+    },
+    set(v) {
+      Object.defineProperty(object, key, {
+        value: v
+        // configurable: true,
+      });
+      // object[key] = v;
+    },
+    configurable: true
+  });
+}
+export function objectClone(obj) {
+  return Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));
+}
+export function assignProp(target, prop, value) {
+  Object.defineProperty(target, prop, {
+    value,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+}
+export function mergeDefs() {
+  const mergedDescriptors = {};
+  for (var _len = arguments.length, defs = new Array(_len), _key = 0; _key < _len; _key++) {
+    defs[_key] = arguments[_key];
+  }
+  for (const def of defs) {
+    const descriptors = Object.getOwnPropertyDescriptors(def);
+    Object.assign(mergedDescriptors, descriptors);
+  }
+  return Object.defineProperties({}, mergedDescriptors);
+}
+export function cloneDef(schema) {
+  return mergeDefs(schema._zod.def);
+}
+export function getElementAtPath(obj, path) {
+  if (!path) return obj;
+  return path.reduce((acc, key) => acc === null || acc === void 0 ? void 0 : acc[key], obj);
+}
+export function promiseAllObject(promisesObj) {
+  const keys = Object.keys(promisesObj);
+  const promises = keys.map(key => promisesObj[key]);
+  return Promise.all(promises).then(results => {
+    const resolvedObj = {};
+    for (let i = 0; i < keys.length; i++) {
+      resolvedObj[keys[i]] = results[i];
+    }
+    return resolvedObj;
+  });
+}
+export function randomString() {
+  let length = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 10;
+  const chars = "abcdefghijklmnopqrstuvwxyz";
+  let str = "";
+  for (let i = 0; i < length; i++) {
+    str += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return str;
+}
+export function esc(str) {
+  return JSON.stringify(str);
+}
+export function slugify(input) {
+  return input.toLowerCase().trim().replace(/[^\w\s-]/g, "").replace(/[\s_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export const captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : function () {};
+export function isObject(data) {
+  return typeof data === "object" && data !== null && !Array.isArray(data);
+}
+export const allowsEval = cached(() => {
+  var _navigator;
+  // @ts-ignore
+  if (typeof navigator !== "undefined" && (_navigator = navigator) !== null && _navigator !== void 0 && (_navigator = _navigator.userAgent) !== null && _navigator !== void 0 && _navigator.includes("Cloudflare")) {
+    return false;
+  }
+  try {
+    const F = Function;
+    new F("");
+    return true;
+  } catch (_) {
+    return false;
+  }
+});
+export function isPlainObject(o) {
+  if (isObject(o) === false) return false;
+
+  // modified constructor
+  const ctor = o.constructor;
+  if (ctor === undefined) return true;
+  if (typeof ctor !== "function") return true;
+
+  // modified prototype
+  const prot = ctor.prototype;
+  if (isObject(prot) === false) return false;
+
+  // ctor doesn't have static `isPrototypeOf`
+  if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+    return false;
+  }
+  return true;
+}
+export function shallowClone(o) {
+  if (isPlainObject(o)) return _objectSpread({}, o);
+  if (Array.isArray(o)) return [...o];
+  return o;
+}
+export function numKeys(data) {
+  let keyCount = 0;
+  for (const key in data) {
+    if (Object.prototype.hasOwnProperty.call(data, key)) {
+      keyCount++;
+    }
+  }
+  return keyCount;
+}
+export const getParsedType = data => {
+  const t = typeof data;
+  switch (t) {
+    case "undefined":
+      return "undefined";
+    case "string":
+      return "string";
+    case "number":
+      return Number.isNaN(data) ? "nan" : "number";
+    case "boolean":
+      return "boolean";
+    case "function":
+      return "function";
+    case "bigint":
+      return "bigint";
+    case "symbol":
+      return "symbol";
+    case "object":
+      if (Array.isArray(data)) {
+        return "array";
+      }
+      if (data === null) {
+        return "null";
+      }
+      if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
+        return "promise";
+      }
+      if (typeof Map !== "undefined" && data instanceof Map) {
+        return "map";
+      }
+      if (typeof Set !== "undefined" && data instanceof Set) {
+        return "set";
+      }
+      if (typeof Date !== "undefined" && data instanceof Date) {
+        return "date";
+      }
+      // @ts-ignore
+      if (typeof File !== "undefined" && data instanceof File) {
+        return "file";
+      }
+      return "object";
+    default:
+      throw new Error(`Unknown data type: ${t}`);
+  }
+};
+export const propertyKeyTypes = new Set(["string", "number", "symbol"]);
+export const primitiveTypes = new Set(["string", "number", "bigint", "boolean", "symbol", "undefined"]);
+export function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// zod-specific utils
+export function clone(inst, def, params) {
+  const cl = new inst._zod.constr(def !== null && def !== void 0 ? def : inst._zod.def);
+  if (!def || params !== null && params !== void 0 && params.parent) cl._zod.parent = inst;
+  return cl;
+}
+export function normalizeParams(_params) {
+  const params = _params;
+  if (!params) return {};
+  if (typeof params === "string") return {
+    error: () => params
+  };
+  if ((params === null || params === void 0 ? void 0 : params.message) !== undefined) {
+    if ((params === null || params === void 0 ? void 0 : params.error) !== undefined) throw new Error("Cannot specify both `message` and `error` params");
+    params.error = params.message;
+  }
+  delete params.message;
+  if (typeof params.error === "string") return _objectSpread(_objectSpread({}, params), {}, {
+    error: () => params.error
+  });
+  return params;
+}
+export function createTransparentProxy(getter) {
+  let target;
+  return new Proxy({}, {
+    get(_, prop, receiver) {
+      target ??= getter();
+      return Reflect.get(target, prop, receiver);
+    },
+    set(_, prop, value, receiver) {
+      target ??= getter();
+      return Reflect.set(target, prop, value, receiver);
+    },
+    has(_, prop) {
+      target ??= getter();
+      return Reflect.has(target, prop);
+    },
+    deleteProperty(_, prop) {
+      target ??= getter();
+      return Reflect.deleteProperty(target, prop);
+    },
+    ownKeys() {
+      target ??= getter();
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(_, prop) {
+      target ??= getter();
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+    defineProperty(_, prop, descriptor) {
+      target ??= getter();
+      return Reflect.defineProperty(target, prop, descriptor);
+    }
+  });
+}
+export function stringifyPrimitive(value) {
+  if (typeof value === "bigint") return value.toString() + "n";
+  if (typeof value === "string") return `"${value}"`;
+  return `${value}`;
+}
+export function optionalKeys(shape) {
+  return Object.keys(shape).filter(k => {
+    return shape[k]._zod.optin === "optional" && shape[k]._zod.optout === "optional";
+  });
+}
+export const NUMBER_FORMAT_RANGES = {
+  safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
+  int32: [-2147483648, 2147483647],
+  uint32: [0, 4294967295],
+  float32: [-3.4028234663852886e38, 3.4028234663852886e38],
+  float64: [-Number.MAX_VALUE, Number.MAX_VALUE]
+};
+export const BIGINT_FORMAT_RANGES = {
+  int64: [/* @__PURE__*/BigInt("-9223372036854775808"), /* @__PURE__*/BigInt("9223372036854775807")],
+  uint64: [/* @__PURE__*/BigInt(0), /* @__PURE__*/BigInt("18446744073709551615")]
+};
+export function pick(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".pick() cannot be used on object schemas containing refinements");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = {};
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key]) continue;
+        newShape[key] = currDef.shape[key];
+      }
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+export function omit(schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".omit() cannot be used on object schemas containing refinements");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const newShape = _objectSpread({}, schema._zod.def.shape);
+      for (const key in mask) {
+        if (!(key in currDef.shape)) {
+          throw new Error(`Unrecognized key: "${key}"`);
+        }
+        if (!mask[key]) continue;
+        delete newShape[key];
+      }
+      assignProp(this, "shape", newShape); // self-caching
+      return newShape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+export function extend(schema, shape) {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to extend: expected a plain object");
+  }
+  const checks = schema._zod.def.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    // Only throw if new shape overlaps with existing shape
+    // Use getOwnPropertyDescriptor to check key existence without accessing values
+    const existingShape = schema._zod.def.shape;
+    for (const key in shape) {
+      if (Object.getOwnPropertyDescriptor(existingShape, key) !== undefined) {
+        throw new Error("Cannot overwrite keys on object schemas containing refinements. Use `.safeExtend()` instead.");
+      }
+    }
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = _objectSpread(_objectSpread({}, schema._zod.def.shape), shape);
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    }
+  });
+  return clone(schema, def);
+}
+export function safeExtend(schema, shape) {
+  if (!isPlainObject(shape)) {
+    throw new Error("Invalid input to safeExtend: expected a plain object");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const _shape = _objectSpread(_objectSpread({}, schema._zod.def.shape), shape);
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    }
+  });
+  return clone(schema, def);
+}
+export function merge(a, b) {
+  const def = mergeDefs(a._zod.def, {
+    get shape() {
+      const _shape = _objectSpread(_objectSpread({}, a._zod.def.shape), b._zod.def.shape);
+      assignProp(this, "shape", _shape); // self-caching
+      return _shape;
+    },
+    get catchall() {
+      return b._zod.def.catchall;
+    },
+    checks: [] // delete existing checks
+  });
+  return clone(a, def);
+}
+export function partial(Class, schema, mask) {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".partial() cannot be used on object schemas containing refinements");
+  }
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = _objectSpread({}, oldShape);
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in oldShape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!mask[key]) continue;
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class ? new Class({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      } else {
+        for (const key in oldShape) {
+          // if (oldShape[key]!._zod.optin === "optional") continue;
+          shape[key] = Class ? new Class({
+            type: "optional",
+            innerType: oldShape[key]
+          }) : oldShape[key];
+        }
+      }
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
+    },
+    checks: []
+  });
+  return clone(schema, def);
+}
+export function required(Class, schema, mask) {
+  const def = mergeDefs(schema._zod.def, {
+    get shape() {
+      const oldShape = schema._zod.def.shape;
+      const shape = _objectSpread({}, oldShape);
+      if (mask) {
+        for (const key in mask) {
+          if (!(key in shape)) {
+            throw new Error(`Unrecognized key: "${key}"`);
+          }
+          if (!mask[key]) continue;
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      } else {
+        for (const key in oldShape) {
+          // overwrite with non-optional
+          shape[key] = new Class({
+            type: "nonoptional",
+            innerType: oldShape[key]
+          });
+        }
+      }
+      assignProp(this, "shape", shape); // self-caching
+      return shape;
+    }
+  });
+  return clone(schema, def);
+}
+// invalid_type | too_big | too_small | invalid_format | not_multiple_of | unrecognized_keys | invalid_union | invalid_key | invalid_element | invalid_value | custom
+export function aborted(x) {
+  let startIndex = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+  if (x.aborted === true) return true;
+  for (let i = startIndex; i < x.issues.length; i++) {
+    var _x$issues$i;
+    if (((_x$issues$i = x.issues[i]) === null || _x$issues$i === void 0 ? void 0 : _x$issues$i.continue) !== true) {
+      return true;
+    }
+  }
+  return false;
+}
+export function prefixIssues(path, issues) {
+  return issues.map(iss => {
+    iss.path ??= [];
+    iss.path.unshift(path);
+    return iss;
+  });
+}
+export function unwrapMessage(message) {
+  return typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
+}
+export function finalizeIssue(iss, ctx, config) {
+  var _iss$path;
+  const full = _objectSpread(_objectSpread({}, iss), {}, {
+    path: (_iss$path = iss.path) !== null && _iss$path !== void 0 ? _iss$path : []
+  });
+
+  // for backwards compatibility
+  if (!iss.message) {
+    var _ref3, _ref4, _ref5, _unwrapMessage, _iss$inst, _iss$inst$error, _ctx$error, _config$customError, _config$localeError;
+    const message = (_ref3 = (_ref4 = (_ref5 = (_unwrapMessage = unwrapMessage((_iss$inst = iss.inst) === null || _iss$inst === void 0 || (_iss$inst = _iss$inst._zod.def) === null || _iss$inst === void 0 || (_iss$inst$error = _iss$inst.error) === null || _iss$inst$error === void 0 ? void 0 : _iss$inst$error.call(_iss$inst, iss))) !== null && _unwrapMessage !== void 0 ? _unwrapMessage : unwrapMessage(ctx === null || ctx === void 0 || (_ctx$error = ctx.error) === null || _ctx$error === void 0 ? void 0 : _ctx$error.call(ctx, iss))) !== null && _ref5 !== void 0 ? _ref5 : unwrapMessage((_config$customError = config.customError) === null || _config$customError === void 0 ? void 0 : _config$customError.call(config, iss))) !== null && _ref4 !== void 0 ? _ref4 : unwrapMessage((_config$localeError = config.localeError) === null || _config$localeError === void 0 ? void 0 : _config$localeError.call(config, iss))) !== null && _ref3 !== void 0 ? _ref3 : "Invalid input";
+    full.message = message;
+  }
+
+  // delete (full as any).def;
+  delete full.inst;
+  delete full.continue;
+  if (!(ctx !== null && ctx !== void 0 && ctx.reportInput)) {
+    delete full.input;
+  }
+  return full;
+}
+export function getSizableOrigin(input) {
+  if (input instanceof Set) return "set";
+  if (input instanceof Map) return "map";
+  // @ts-ignore
+  if (input instanceof File) return "file";
+  return "unknown";
+}
+export function getLengthableOrigin(input) {
+  if (Array.isArray(input)) return "array";
+  if (typeof input === "string") return "string";
+  return "unknown";
+}
+export function parsedType(data) {
+  const t = typeof data;
+  switch (t) {
+    case "number":
+      {
+        return Number.isNaN(data) ? "nan" : "number";
+      }
+    case "object":
+      {
+        if (data === null) {
+          return "null";
+        }
+        if (Array.isArray(data)) {
+          return "array";
+        }
+        const obj = data;
+        if (obj && Object.getPrototypeOf(obj) !== Object.prototype && "constructor" in obj && obj.constructor) {
+          return obj.constructor.name;
+        }
+      }
+  }
+  return t;
+}
+
+//////////    REFINES     //////////
+
+export function issue() {
+  for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    args[_key2] = arguments[_key2];
+  }
+  const [iss, input, inst] = args;
+  if (typeof iss === "string") {
+    return {
+      message: iss,
+      code: "custom",
+      input,
+      inst
+    };
+  }
+  return _objectSpread({}, iss);
+}
+export function cleanEnum(obj) {
+  return Object.entries(obj).filter(_ref6 => {
+    let [k, _] = _ref6;
+    // return true if NaN, meaning it's not a number, thus a string key
+    return Number.isNaN(Number.parseInt(k, 10));
+  }).map(el => el[1]);
+}
+
+// Codec utility functions
+export function base64ToUint8Array(base64) {
+  const binaryString = atob(base64);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+export function uint8ArrayToBase64(bytes) {
+  let binaryString = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binaryString += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binaryString);
+}
+export function base64urlToUint8Array(base64url) {
+  const base64 = base64url.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = "=".repeat((4 - base64.length % 4) % 4);
+  return base64ToUint8Array(base64 + padding);
+}
+export function uint8ArrayToBase64url(bytes) {
+  return uint8ArrayToBase64(bytes).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+export function hexToUint8Array(hex) {
+  const cleanHex = hex.replace(/^0x/, "");
+  if (cleanHex.length % 2 !== 0) {
+    throw new Error("Invalid hex string length");
+  }
+  const bytes = new Uint8Array(cleanHex.length / 2);
+  for (let i = 0; i < cleanHex.length; i += 2) {
+    bytes[i / 2] = Number.parseInt(cleanHex.slice(i, i + 2), 16);
+  }
+  return bytes;
+}
+export function uint8ArrayToHex(bytes) {
+  return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+
+// instanceof
+export class Class {
+  constructor() {}
+}

package/lib/myLib/zod/src/v4/core/versions.d.ts

@@ -0,0 +1,5 @@
+export declare const version: {
+    readonly major: 4;
+    readonly minor: 3;
+    readonly patch: number;
+};

package/lib/myLib/zod/src/v4/core/versions.js

@@ -0,0 +1,5 @@
+export const version = {
+  major: 4,
+  minor: 3,
+  patch: 5
+};