@socketsecurity/lib 3.0.2 → 3.0.3

package/dist/url.js

@@ -1,3 +1,144 @@
 /* Socket Lib - Built with esbuild */
-var o=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var c=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var p=(e,r)=>{for(var t in r)o(e,t,{get:r[t],enumerable:!0})},g=(e,r,t,n)=>{if(r&&typeof r=="object"||typeof r=="function")for(let a of c(r))!d.call(e,a)&&a!==t&&o(e,a,{get:()=>r[a],enumerable:!(n=f(r,a))||n.enumerable});return e};var m=e=>g(o({},"__esModule",{value:!0}),e);var x={};p(x,{createRelativeUrl:()=>b,isUrl:()=>S,parseUrl:()=>i,urlSearchParamAsArray:()=>u,urlSearchParamAsBoolean:()=>s,urlSearchParamAsNumber:()=>O,urlSearchParamAsString:()=>A,urlSearchParamsGetArray:()=>P,urlSearchParamsGetBoolean:()=>_});module.exports=m(x);const U=Boolean,h=URL;function S(e){return(typeof e=="string"&&e!==""||e!==null&&typeof e=="object")&&!!i(e)}function i(e){try{return new h(e)}catch{}}function u(e){return typeof e=="string"?e.trim().split(/, */).map(r=>r.trim()).filter(U):[]}function s(e,r){const{defaultValue:t=!1}={__proto__:null,...r};if(typeof e=="string"){const n=e.trim();return n==="1"||n.toLowerCase()==="true"}return e==null?!!t:!!e}function P(e,r){if(e&&typeof e.getAll=="function"){const t=e.getAll(r),n=t[0];return t.length===1&&n&&n.includes(",")?u(n):t}return[]}function _(e,r,t){const{defaultValue:n=!1}={__proto__:null,...t};if(e&&typeof e.get=="function"){const a=e.get(r);return a!==null?s(a,{defaultValue:n}):n}return n}function b(e,r){const{base:t=""}={__proto__:null,...r},n=e.replace(/^\//,"");if(t){let a=t;return a.endsWith("/")||(a+="/"),a+n}return n}function A(e,r,t){const{defaultValue:n=""}={__proto__:null,...t};if(e&&typeof e.get=="function"){const a=e.get(r);return a!==null?a:n}return n}function O(e,r,t){const{defaultValue:n=0}={__proto__:null,...t};if(e&&typeof e.get=="function"){const a=e.get(r);if(a!==null){const l=Number(a);return Number.isNaN(l)?n:l}}return n}0&&(module.exports={createRelativeUrl,isUrl,parseUrl,urlSearchParamAsArray,urlSearchParamAsBoolean,urlSearchParamAsNumber,urlSearchParamAsString,urlSearchParamsGetArray,urlSearchParamsGetBoolean});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var url_exports = {};
+__export(url_exports, {
+  createRelativeUrl: () => createRelativeUrl,
+  isUrl: () => isUrl,
+  parseUrl: () => parseUrl,
+  urlSearchParamAsArray: () => urlSearchParamAsArray,
+  urlSearchParamAsBoolean: () => urlSearchParamAsBoolean,
+  urlSearchParamAsNumber: () => urlSearchParamAsNumber,
+  urlSearchParamAsString: () => urlSearchParamAsString,
+  urlSearchParamsGetArray: () => urlSearchParamsGetArray,
+  urlSearchParamsGetBoolean: () => urlSearchParamsGetBoolean
+});
+module.exports = __toCommonJS(url_exports);
+const BooleanCtor = Boolean;
+const UrlCtor = URL;
+// @__NO_SIDE_EFFECTS__
+function isUrl(value) {
+  return (typeof value === "string" && value !== "" || value !== null && typeof value === "object") && !!/* @__PURE__ */ parseUrl(value);
+}
+// @__NO_SIDE_EFFECTS__
+function parseUrl(value) {
+  try {
+    return new UrlCtor(value);
+  } catch {
+  }
+  return void 0;
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamAsArray(value) {
+  return typeof value === "string" ? value.trim().split(/, */).map((v) => v.trim()).filter(BooleanCtor) : [];
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamAsBoolean(value, options) {
+  const { defaultValue = false } = {
+    __proto__: null,
+    ...options
+  };
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    return trimmed === "1" || trimmed.toLowerCase() === "true";
+  }
+  if (value === null || value === void 0) {
+    return !!defaultValue;
+  }
+  return !!value;
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamsGetArray(params, key) {
+  if (params && typeof params.getAll === "function") {
+    const values = params.getAll(key);
+    const firstValue = values[0];
+    if (values.length === 1 && firstValue && firstValue.includes(",")) {
+      return /* @__PURE__ */ urlSearchParamAsArray(firstValue);
+    }
+    return values;
+  }
+  return [];
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamsGetBoolean(params, key, options) {
+  const { defaultValue = false } = {
+    __proto__: null,
+    ...options
+  };
+  if (params && typeof params.get === "function") {
+    const value = params.get(key);
+    return value !== null ? /* @__PURE__ */ urlSearchParamAsBoolean(value, { defaultValue }) : defaultValue;
+  }
+  return defaultValue;
+}
+// @__NO_SIDE_EFFECTS__
+function createRelativeUrl(path, options) {
+  const { base = "" } = {
+    __proto__: null,
+    ...options
+  };
+  const relativePath = path.replace(/^\//, "");
+  if (base) {
+    let baseUrl = base;
+    if (!baseUrl.endsWith("/")) {
+      baseUrl += "/";
+    }
+    return baseUrl + relativePath;
+  }
+  return relativePath;
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamAsString(params, key, options) {
+  const { defaultValue = "" } = {
+    __proto__: null,
+    ...options
+  };
+  if (params && typeof params.get === "function") {
+    const value = params.get(key);
+    return value !== null ? value : defaultValue;
+  }
+  return defaultValue;
+}
+// @__NO_SIDE_EFFECTS__
+function urlSearchParamAsNumber(params, key, options) {
+  const { defaultValue = 0 } = {
+    __proto__: null,
+    ...options
+  };
+  if (params && typeof params.get === "function") {
+    const value = params.get(key);
+    if (value !== null) {
+      const num = Number(value);
+      return !Number.isNaN(num) ? num : defaultValue;
+    }
+  }
+  return defaultValue;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createRelativeUrl,
+  isUrl,
+  parseUrl,
+  urlSearchParamAsArray,
+  urlSearchParamAsBoolean,
+  urlSearchParamAsNumber,
+  urlSearchParamAsString,
+  urlSearchParamsGetArray,
+  urlSearchParamsGetBoolean
+});
 //# sourceMappingURL=url.js.map

package/dist/url.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../src/url.ts"],
   "sourcesContent": ["/**\n * @fileoverview URL parsing and validation utilities.\n * Provides URL validation, normalization, and parsing helpers.\n */\n\nconst BooleanCtor = Boolean\nconst UrlCtor = URL\n\n/**\n * Check if a value is a valid URL.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function isUrl(value: string | URL | null | undefined): boolean {\n  return (\n    ((typeof value === 'string' && value !== '') ||\n      (value !== null && typeof value === 'object')) &&\n    !!parseUrl(value)\n  )\n}\n\n/**\n * Parse a value as a URL.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function parseUrl(value: string | URL): URL | undefined {\n  try {\n    return new UrlCtor(value)\n  } catch {}\n  return undefined\n}\n\n/**\n * Convert a URL search parameter to an array.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsArray(\n  value: string | null | undefined,\n): string[] {\n  return typeof value === 'string'\n    ? value\n        .trim()\n        .split(/, */)\n        .map(v => v.trim())\n        .filter(BooleanCtor)\n    : []\n}\n\nexport interface UrlSearchParamAsBooleanOptions {\n  defaultValue?: boolean\n}\n\n/**\n * Convert a URL search parameter to a boolean.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsBoolean(\n  value: string | null | undefined,\n  options?: UrlSearchParamAsBooleanOptions | undefined,\n): boolean {\n  const { defaultValue = false } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsBooleanOptions\n  if (typeof value === 'string') {\n    const trimmed = value.trim()\n    return trimmed === '1' || trimmed.toLowerCase() === 'true'\n  }\n  if (value === null || value === undefined) {\n    return !!defaultValue\n  }\n  return !!value\n}\n\n/**\n * Helper to get array from URLSearchParams.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamsGetArray(\n  params: URLSearchParams | null | undefined,\n  key: string,\n): string[] {\n  if (params && typeof params.getAll === 'function') {\n    const values = params.getAll(key)\n    // If single value contains commas, split it\n    const firstValue = values[0]\n    if (values.length === 1 && firstValue && firstValue.includes(',')) {\n      return urlSearchParamAsArray(firstValue)\n    }\n    return values\n  }\n  return []\n}\n\nexport interface UrlSearchParamsGetBooleanOptions {\n  defaultValue?: boolean\n}\n\n/**\n * Helper to get boolean from URLSearchParams.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamsGetBoolean(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamsGetBooleanOptions | undefined,\n): boolean {\n  const { defaultValue = false } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamsGetBooleanOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    return value !== null\n      ? urlSearchParamAsBoolean(value, { defaultValue })\n      : defaultValue\n  }\n  return defaultValue\n}\n\nexport interface CreateRelativeUrlOptions {\n  base?: string\n}\n\n/**\n * Create a relative URL for testing.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function createRelativeUrl(\n  path: string,\n  options?: CreateRelativeUrlOptions | undefined,\n): string {\n  const { base = '' } = {\n    __proto__: null,\n    ...options,\n  } as CreateRelativeUrlOptions\n  // Remove leading slash to make it relative.\n  const relativePath = path.replace(/^\\//, '')\n\n  if (base) {\n    let baseUrl = base\n    if (!baseUrl.endsWith('/')) {\n      baseUrl += '/'\n    }\n    return baseUrl + relativePath\n  }\n\n  return relativePath\n}\n\nexport interface UrlSearchParamAsStringOptions {\n  defaultValue?: string\n}\n\n/**\n * Get string value from URLSearchParams with a default.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsString(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamAsStringOptions | undefined,\n): string {\n  const { defaultValue = '' } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsStringOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    return value !== null ? value : defaultValue\n  }\n  return defaultValue\n}\n\nexport interface UrlSearchParamAsNumberOptions {\n  defaultValue?: number\n}\n\n/**\n * Get number value from URLSearchParams with a default.\n */\n/*@__NO_SIDE_EFFECTS__*/\nexport function urlSearchParamAsNumber(\n  params: URLSearchParams | null | undefined,\n  key: string,\n  options?: UrlSearchParamAsNumberOptions | undefined,\n): number {\n  const { defaultValue = 0 } = {\n    __proto__: null,\n    ...options,\n  } as UrlSearchParamAsNumberOptions\n  if (params && typeof params.get === 'function') {\n    const value = params.get(key)\n    if (value !== null) {\n      const num = Number(value)\n      return !Number.isNaN(num) ? num : defaultValue\n    }\n  }\n  return defaultValue\n}\n"],
-  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,uBAAAE,EAAA,UAAAC,EAAA,aAAAC,EAAA,0BAAAC,EAAA,4BAAAC,EAAA,2BAAAC,EAAA,2BAAAC,EAAA,4BAAAC,EAAA,8BAAAC,IAAA,eAAAC,EAAAX,GAKA,MAAMY,EAAc,QACdC,EAAU,IAMT,SAASV,EAAMW,EAAiD,CACrE,OACI,OAAOA,GAAU,UAAYA,IAAU,IACtCA,IAAU,MAAQ,OAAOA,GAAU,WACtC,CAAC,CAACV,EAASU,CAAK,CAEpB,CAMO,SAASV,EAASU,EAAsC,CAC7D,GAAI,CACF,OAAO,IAAID,EAAQC,CAAK,CAC1B,MAAQ,CAAC,CAEX,CAMO,SAAST,EACdS,EACU,CACV,OAAO,OAAOA,GAAU,SACpBA,EACG,KAAK,EACL,MAAM,KAAK,EACX,IAAIC,GAAKA,EAAE,KAAK,CAAC,EACjB,OAAOH,CAAW,EACrB,CAAC,CACP,CAUO,SAASN,EACdQ,EACAE,EACS,CACT,KAAM,CAAE,aAAAC,EAAe,EAAM,EAAI,CAC/B,UAAW,KACX,GAAGD,CACL,EACA,GAAI,OAAOF,GAAU,SAAU,CAC7B,MAAMI,EAAUJ,EAAM,KAAK,EAC3B,OAAOI,IAAY,KAAOA,EAAQ,YAAY,IAAM,MACtD,CACA,OAAIJ,GAAU,KACL,CAAC,CAACG,EAEJ,CAAC,CAACH,CACX,CAMO,SAASL,EACdU,EACAC,EACU,CACV,GAAID,GAAU,OAAOA,EAAO,QAAW,WAAY,CACjD,MAAME,EAASF,EAAO,OAAOC,CAAG,EAE1BE,EAAaD,EAAO,CAAC,EAC3B,OAAIA,EAAO,SAAW,GAAKC,GAAcA,EAAW,SAAS,GAAG,EACvDjB,EAAsBiB,CAAU,EAElCD,CACT,CACA,MAAO,CAAC,CACV,CAUO,SAASX,EACdS,EACAC,EACAJ,EACS,CACT,KAAM,CAAE,aAAAC,EAAe,EAAM,EAAI,CAC/B,UAAW,KACX,GAAGD,CACL,EACA,GAAIG,GAAU,OAAOA,EAAO,KAAQ,WAAY,CAC9C,MAAML,EAAQK,EAAO,IAAIC,CAAG,EAC5B,OAAON,IAAU,KACbR,EAAwBQ,EAAO,CAAE,aAAAG,CAAa,CAAC,EAC/CA,CACN,CACA,OAAOA,CACT,CAUO,SAASf,EACdqB,EACAP,EACQ,CACR,KAAM,CAAE,KAAAQ,EAAO,EAAG,EAAI,CACpB,UAAW,KACX,GAAGR,CACL,EAEMS,EAAeF,EAAK,QAAQ,MAAO,EAAE,EAE3C,GAAIC,EAAM,CACR,IAAIE,EAAUF,EACd,OAAKE,EAAQ,SAAS,GAAG,IACvBA,GAAW,KAENA,EAAUD,CACnB,CAEA,OAAOA,CACT,CAUO,SAASjB,EACdW,EACAC,EACAJ,EACQ,CACR,KAAM,CAAE,aAAAC,EAAe,EAAG,EAAI,CAC5B,UAAW,KACX,GAAGD,CACL,EACA,GAAIG,GAAU,OAAOA,EAAO,KAAQ,WAAY,CAC9C,MAAML,EAAQK,EAAO,IAAIC,CAAG,EAC5B,OAAON,IAAU,KAAOA,EAAQG,CAClC,CACA,OAAOA,CACT,CAUO,SAASV,EACdY,EACAC,EACAJ,EACQ,CACR,KAAM,CAAE,aAAAC,EAAe,CAAE,EAAI,CAC3B,UAAW,KACX,GAAGD,CACL,EACA,GAAIG,GAAU,OAAOA,EAAO,KAAQ,WAAY,CAC9C,MAAML,EAAQK,EAAO,IAAIC,CAAG,EAC5B,GAAIN,IAAU,KAAM,CAClB,MAAMa,EAAM,OAAOb,CAAK,EACxB,OAAQ,OAAO,MAAMa,CAAG,EAAUV,EAANU,CAC9B,CACF,CACA,OAAOV,CACT",
-  "names": ["url_exports", "__export", "createRelativeUrl", "isUrl", "parseUrl", "urlSearchParamAsArray", "urlSearchParamAsBoolean", "urlSearchParamAsNumber", "urlSearchParamAsString", "urlSearchParamsGetArray", "urlSearchParamsGetBoolean", "__toCommonJS", "BooleanCtor", "UrlCtor", "value", "v", "options", "defaultValue", "trimmed", "params", "key", "values", "firstValue", "path", "base", "relativePath", "baseUrl", "num"]
+  "mappings": "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",
+  "names": []
 }

package/dist/utils/get-ipc.js

@@ -1,3 +1,60 @@
 /* Socket Lib - Built with esbuild */
-var e=Object.defineProperty;var K=Object.getOwnPropertyDescriptor;var n=Object.getOwnPropertyNames;var L=Object.prototype.hasOwnProperty;var t=(S,_)=>{for(var C in _)e(S,C,{get:_[C],enumerable:!0})},c=(S,_,C,E)=>{if(_&&typeof _=="object"||typeof _=="function")for(let I of n(_))!L.call(S,I)&&I!==C&&e(S,I,{get:()=>_[I],enumerable:!(E=K(_,I))||E.enumerable});return S};var A=S=>c(e({},"__esModule",{value:!0}),S);var f={};t(f,{default:()=>i,getIpc:()=>T});module.exports=A(f);let O;async function T(S){if(O===void 0){O={};const{env:_}=process;_.SOCKET_CLI_FIX&&(O.SOCKET_CLI_FIX=_.SOCKET_CLI_FIX),_.SOCKET_CLI_OPTIMIZE&&(O.SOCKET_CLI_OPTIMIZE=_.SOCKET_CLI_OPTIMIZE==="true"||_.SOCKET_CLI_OPTIMIZE==="1"),_.SOCKET_CLI_SHADOW_ACCEPT_RISKS&&(O.SOCKET_CLI_SHADOW_ACCEPT_RISKS=_.SOCKET_CLI_SHADOW_ACCEPT_RISKS==="true"||_.SOCKET_CLI_SHADOW_ACCEPT_RISKS==="1"),_.SOCKET_CLI_SHADOW_API_TOKEN&&(O.SOCKET_CLI_SHADOW_API_TOKEN=_.SOCKET_CLI_SHADOW_API_TOKEN),_.SOCKET_CLI_SHADOW_BIN&&(O.SOCKET_CLI_SHADOW_BIN=_.SOCKET_CLI_SHADOW_BIN),_.SOCKET_CLI_SHADOW_PROGRESS&&(O.SOCKET_CLI_SHADOW_PROGRESS=_.SOCKET_CLI_SHADOW_PROGRESS==="true"||_.SOCKET_CLI_SHADOW_PROGRESS==="1"),_.SOCKET_CLI_SHADOW_SILENT&&(O.SOCKET_CLI_SHADOW_SILENT=_.SOCKET_CLI_SHADOW_SILENT==="true"||_.SOCKET_CLI_SHADOW_SILENT==="1"),Object.freeze(O)}return S?O[S]:O}var i=T;0&&(module.exports={getIpc});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var get_ipc_exports = {};
+__export(get_ipc_exports, {
+  default: () => get_ipc_default,
+  getIpc: () => getIpc
+});
+module.exports = __toCommonJS(get_ipc_exports);
+let _ipcObject;
+async function getIpc(key) {
+  if (_ipcObject === void 0) {
+    _ipcObject = {};
+    const { env } = process;
+    if (env["SOCKET_CLI_FIX"]) {
+      _ipcObject.SOCKET_CLI_FIX = env["SOCKET_CLI_FIX"];
+    }
+    if (env["SOCKET_CLI_OPTIMIZE"]) {
+      _ipcObject.SOCKET_CLI_OPTIMIZE = env["SOCKET_CLI_OPTIMIZE"] === "true" || env["SOCKET_CLI_OPTIMIZE"] === "1";
+    }
+    if (env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"]) {
+      _ipcObject.SOCKET_CLI_SHADOW_ACCEPT_RISKS = env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"] === "true" || env["SOCKET_CLI_SHADOW_ACCEPT_RISKS"] === "1";
+    }
+    if (env["SOCKET_CLI_SHADOW_API_TOKEN"]) {
+      _ipcObject.SOCKET_CLI_SHADOW_API_TOKEN = env["SOCKET_CLI_SHADOW_API_TOKEN"];
+    }
+    if (env["SOCKET_CLI_SHADOW_BIN"]) {
+      _ipcObject.SOCKET_CLI_SHADOW_BIN = env["SOCKET_CLI_SHADOW_BIN"];
+    }
+    if (env["SOCKET_CLI_SHADOW_PROGRESS"]) {
+      _ipcObject.SOCKET_CLI_SHADOW_PROGRESS = env["SOCKET_CLI_SHADOW_PROGRESS"] === "true" || env["SOCKET_CLI_SHADOW_PROGRESS"] === "1";
+    }
+    if (env["SOCKET_CLI_SHADOW_SILENT"]) {
+      _ipcObject.SOCKET_CLI_SHADOW_SILENT = env["SOCKET_CLI_SHADOW_SILENT"] === "true" || env["SOCKET_CLI_SHADOW_SILENT"] === "1";
+    }
+    Object.freeze(_ipcObject);
+  }
+  return key ? _ipcObject[key] : _ipcObject;
+}
+var get_ipc_default = getIpc;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getIpc
+});
 //# sourceMappingURL=get-ipc.js.map

package/dist/utils/get-ipc.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/utils/get-ipc.ts"],
   "sourcesContent": ["/**\n * IPC (Inter-Process Communication) object getter.\n * Handles communication between parent and child processes.\n */\n\nexport interface IpcObject {\n  SOCKET_CLI_FIX?: string | undefined\n  SOCKET_CLI_OPTIMIZE?: boolean | undefined\n  SOCKET_CLI_SHADOW_ACCEPT_RISKS?: boolean | undefined\n  SOCKET_CLI_SHADOW_API_TOKEN?: string | undefined\n  SOCKET_CLI_SHADOW_BIN?: string | undefined\n  SOCKET_CLI_SHADOW_PROGRESS?: boolean | undefined\n  SOCKET_CLI_SHADOW_SILENT?: boolean | undefined\n}\n\nlet _ipcObject: IpcObject | undefined\n\nexport async function getIpc(): Promise<IpcObject>\nexport async function getIpc<K extends keyof IpcObject>(\n  key: K,\n): Promise<IpcObject[K]>\nexport async function getIpc(\n  key?: keyof IpcObject,\n): Promise<IpcObject | IpcObject[keyof IpcObject]> {\n  if (_ipcObject === undefined) {\n    _ipcObject = {}\n\n    // Check for IPC environment variables.\n    const { env } = process\n\n    if (env['SOCKET_CLI_FIX']) {\n      _ipcObject.SOCKET_CLI_FIX = env['SOCKET_CLI_FIX']\n    }\n\n    if (env['SOCKET_CLI_OPTIMIZE']) {\n      _ipcObject.SOCKET_CLI_OPTIMIZE =\n        env['SOCKET_CLI_OPTIMIZE'] === 'true' ||\n        env['SOCKET_CLI_OPTIMIZE'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_ACCEPT_RISKS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_ACCEPT_RISKS =\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_ACCEPT_RISKS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_API_TOKEN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_API_TOKEN =\n        env['SOCKET_CLI_SHADOW_API_TOKEN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_BIN']) {\n      _ipcObject.SOCKET_CLI_SHADOW_BIN = env['SOCKET_CLI_SHADOW_BIN']\n    }\n\n    if (env['SOCKET_CLI_SHADOW_PROGRESS']) {\n      _ipcObject.SOCKET_CLI_SHADOW_PROGRESS =\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_PROGRESS'] === '1'\n    }\n\n    if (env['SOCKET_CLI_SHADOW_SILENT']) {\n      _ipcObject.SOCKET_CLI_SHADOW_SILENT =\n        env['SOCKET_CLI_SHADOW_SILENT'] === 'true' ||\n        env['SOCKET_CLI_SHADOW_SILENT'] === '1'\n    }\n\n    Object.freeze(_ipcObject)\n  }\n\n  return key ? _ipcObject[key] : _ipcObject\n}\n\nexport default getIpc\n"],
-  "mappings": ";4ZAAA,IAAAA,EAAA,GAAAC,EAAAD,EAAA,aAAAE,EAAA,WAAAC,IAAA,eAAAC,EAAAJ,GAeA,IAAIK,EAMJ,eAAsBF,EACpBG,EACiD,CACjD,GAAID,IAAe,OAAW,CAC5BA,EAAa,CAAC,EAGd,KAAM,CAAE,IAAAE,CAAI,EAAI,QAEZA,EAAI,iBACNF,EAAW,eAAiBE,EAAI,gBAG9BA,EAAI,sBACNF,EAAW,oBACTE,EAAI,sBAA2B,QAC/BA,EAAI,sBAA2B,KAG/BA,EAAI,iCACNF,EAAW,+BACTE,EAAI,iCAAsC,QAC1CA,EAAI,iCAAsC,KAG1CA,EAAI,8BACNF,EAAW,4BACTE,EAAI,6BAGJA,EAAI,wBACNF,EAAW,sBAAwBE,EAAI,uBAGrCA,EAAI,6BACNF,EAAW,2BACTE,EAAI,6BAAkC,QACtCA,EAAI,6BAAkC,KAGtCA,EAAI,2BACNF,EAAW,yBACTE,EAAI,2BAAgC,QACpCA,EAAI,2BAAgC,KAGxC,OAAO,OAAOF,CAAU,CAC1B,CAEA,OAAOC,EAAMD,EAAWC,CAAG,EAAID,CACjC,CAEA,IAAOH,EAAQC",
-  "names": ["get_ipc_exports", "__export", "get_ipc_default", "getIpc", "__toCommonJS", "_ipcObject", "key", "env"]
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAeA,IAAI;AAMJ,eAAsB,OACpB,KACiD;AACjD,MAAI,eAAe,QAAW;AAC5B,iBAAa,CAAC;AAGd,UAAM,EAAE,IAAI,IAAI;AAEhB,QAAI,IAAI,gBAAgB,GAAG;AACzB,iBAAW,iBAAiB,IAAI,gBAAgB;AAAA,IAClD;AAEA,QAAI,IAAI,qBAAqB,GAAG;AAC9B,iBAAW,sBACT,IAAI,qBAAqB,MAAM,UAC/B,IAAI,qBAAqB,MAAM;AAAA,IACnC;AAEA,QAAI,IAAI,gCAAgC,GAAG;AACzC,iBAAW,iCACT,IAAI,gCAAgC,MAAM,UAC1C,IAAI,gCAAgC,MAAM;AAAA,IAC9C;AAEA,QAAI,IAAI,6BAA6B,GAAG;AACtC,iBAAW,8BACT,IAAI,6BAA6B;AAAA,IACrC;AAEA,QAAI,IAAI,uBAAuB,GAAG;AAChC,iBAAW,wBAAwB,IAAI,uBAAuB;AAAA,IAChE;AAEA,QAAI,IAAI,4BAA4B,GAAG;AACrC,iBAAW,6BACT,IAAI,4BAA4B,MAAM,UACtC,IAAI,4BAA4B,MAAM;AAAA,IAC1C;AAEA,QAAI,IAAI,0BAA0B,GAAG;AACnC,iBAAW,2BACT,IAAI,0BAA0B,MAAM,UACpC,IAAI,0BAA0B,MAAM;AAAA,IACxC;AAEA,WAAO,OAAO,UAAU;AAAA,EAC1B;AAEA,SAAO,MAAM,WAAW,GAAG,IAAI;AACjC;AAEA,IAAO,kBAAQ;",
+  "names": []
 }

package/dist/validation/json-parser.js

@@ -1,3 +1,129 @@
 /* Socket Lib - Built with esbuild */
-var f=Object.defineProperty;var p=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var h=(e,n)=>{for(var t in n)f(e,t,{get:n[t],enumerable:!0})},w=(e,n,t,s)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of l(n))!m.call(e,r)&&r!==t&&f(e,r,{get:()=>n[r],enumerable:!(s=p(n,r))||s.enumerable});return e};var g=e=>w(f({},"__esModule",{value:!0}),e);var k={};h(k,{createJsonParser:()=>O,parseJsonWithResult:()=>J,parseNdjson:()=>P,safeJsonParse:()=>u,streamNdjson:()=>S,tryJsonParse:()=>T});module.exports=g(k);const{hasOwn:y}=Object;function u(e,n,t={}){const{allowPrototype:s=!1,maxSize:r=10*1024*1024}=t;if(Buffer.byteLength(e,"utf8")>r)throw new Error(`JSON string exceeds maximum size limit${r!==10*1024*1024?` of ${r} bytes`:""}`);let o;try{o=JSON.parse(e)}catch(i){throw new Error(`Failed to parse JSON: ${i}`)}if(!s&&typeof o=="object"&&o!==null&&!Array.isArray(o)){const i=["__proto__","constructor","prototype"];for(const c of i)if(y(o,c))throw new Error("JSON contains potentially malicious prototype pollution keys")}if(n){const i=n.safeParse(o);if(!i.success){const c=i.error.issues.map(d=>`${d.path.join(".")}: ${d.message}`).join(", ");throw new Error(`Validation failed: ${c}`)}return i.data}return o}function T(e,n,t){try{return u(e,n,t)}catch{return}}function J(e,n,t){try{return{success:!0,data:u(e,n,t)}}catch(s){return{success:!1,error:s instanceof Error?s.message:"Unknown error"}}}function O(e,n){return(t,s)=>u(t,e,{...n,...s})}function P(e,n,t){const s=[],r=e.split(/\r?\n/);for(let a=0;a<r.length;a++){const o=r[a]?.trim();if(!(!o||o===""))try{const i=u(o,n,t);s.push(i)}catch(i){const c=i instanceof Error?i.message:String(i);throw new Error(`Failed to parse NDJSON at line ${a+1}: ${c}`)}}return s}function*S(e,n,t){const s=e.split(/\r?\n/);for(let r=0;r<s.length;r++){const a=s[r]?.trim();if(!(!a||a===""))try{yield u(a,n,t)}catch(o){const i=o instanceof Error?o.message:String(o);throw new Error(`Failed to parse NDJSON at line ${r+1}: ${i}`)}}}0&&(module.exports={createJsonParser,parseJsonWithResult,parseNdjson,safeJsonParse,streamNdjson,tryJsonParse});
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_parser_exports = {};
+__export(json_parser_exports, {
+  createJsonParser: () => createJsonParser,
+  parseJsonWithResult: () => parseJsonWithResult,
+  parseNdjson: () => parseNdjson,
+  safeJsonParse: () => safeJsonParse,
+  streamNdjson: () => streamNdjson,
+  tryJsonParse: () => tryJsonParse
+});
+module.exports = __toCommonJS(json_parser_exports);
+const { hasOwn: ObjectHasOwn } = Object;
+function safeJsonParse(jsonString, schema, options = {}) {
+  const { allowPrototype = false, maxSize = 10 * 1024 * 1024 } = options;
+  const byteLength = Buffer.byteLength(jsonString, "utf8");
+  if (byteLength > maxSize) {
+    throw new Error(
+      `JSON string exceeds maximum size limit${maxSize !== 10 * 1024 * 1024 ? ` of ${maxSize} bytes` : ""}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(jsonString);
+  } catch (error) {
+    throw new Error(`Failed to parse JSON: ${error}`);
+  }
+  if (!allowPrototype && typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+    const dangerous = ["__proto__", "constructor", "prototype"];
+    for (const key of dangerous) {
+      if (ObjectHasOwn(parsed, key)) {
+        throw new Error(
+          "JSON contains potentially malicious prototype pollution keys"
+        );
+      }
+    }
+  }
+  if (schema) {
+    const result = schema.safeParse(parsed);
+    if (!result.success) {
+      const errors = result.error.issues.map(
+        (issue) => `${issue.path.join(".")}: ${issue.message}`
+      ).join(", ");
+      throw new Error(`Validation failed: ${errors}`);
+    }
+    return result.data;
+  }
+  return parsed;
+}
+function tryJsonParse(jsonString, schema, options) {
+  try {
+    return safeJsonParse(jsonString, schema, options);
+  } catch {
+    return void 0;
+  }
+}
+function parseJsonWithResult(jsonString, schema, options) {
+  try {
+    const data = safeJsonParse(jsonString, schema, options);
+    return { success: true, data };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    return { success: false, error: message };
+  }
+}
+function createJsonParser(schema, defaultOptions) {
+  return (jsonString, options) => {
+    return safeJsonParse(jsonString, schema, { ...defaultOptions, ...options });
+  };
+}
+function parseNdjson(ndjson, schema, options) {
+  const results = [];
+  const lines = ndjson.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]?.trim();
+    if (!line || line === "") {
+      continue;
+    }
+    try {
+      const parsed = safeJsonParse(line, schema, options);
+      results.push(parsed);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`);
+    }
+  }
+  return results;
+}
+function* streamNdjson(ndjson, schema, options) {
+  const lines = ndjson.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i]?.trim();
+    if (!line || line === "") {
+      continue;
+    }
+    try {
+      yield safeJsonParse(line, schema, options);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`);
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createJsonParser,
+  parseJsonWithResult,
+  parseNdjson,
+  safeJsonParse,
+  streamNdjson,
+  tryJsonParse
+});
 //# sourceMappingURL=json-parser.js.map

package/dist/validation/json-parser.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/validation/json-parser.ts"],
   "sourcesContent": ["/**\n * @fileoverview Safe JSON parsing with validation and security controls.\n * Provides protection against prototype pollution, size limits, and schema validation.\n *\n * Key Features:\n * - Prototype pollution protection: Blocks `__proto__`, `constructor`, and `prototype` keys\n * - Size limits: Configurable maximum JSON string size (default 10MB)\n * - Schema validation: Optional Zod-compatible schema validation\n * - NDJSON support: Parse newline-delimited JSON streams\n * - Memory safety: Prevents memory exhaustion attacks\n */\n\nimport type { JsonParseOptions, JsonParseResult, Schema } from './types'\n\nconst { hasOwn: ObjectHasOwn } = Object\n\n/**\n * Safely parse JSON with optional schema validation and security controls.\n * Throws errors on parse failures, validation failures, or security violations.\n *\n * This is the recommended method for parsing untrusted JSON input as it provides\n * multiple layers of security including prototype pollution protection and size limits.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed and validated data\n *\n * @throws {Error} When JSON string exceeds `maxSize`\n * @throws {Error} When JSON parsing fails\n * @throws {Error} When prototype pollution keys are detected (unless `allowPrototype` is `true`)\n * @throws {Error} When schema validation fails\n *\n * @example\n * ```ts\n * // Basic parsing with type inference\n * const data = safeJsonParse<User>('{\"name\":\"Alice\",\"age\":30}')\n *\n * // With schema validation\n * import { z } from 'zod'\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n * const user = safeJsonParse('{\"name\":\"Alice\",\"age\":30}', userSchema)\n *\n * // With size limit\n * const data = safeJsonParse(jsonString, undefined, {\n *   maxSize: 1024 * 1024 // 1MB\n * })\n *\n * // Allow prototype keys (dangerous - only for trusted sources)\n * const data = safeJsonParse(jsonString, undefined, {\n *   allowPrototype: true\n * })\n * ```\n */\nexport function safeJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options: JsonParseOptions = {},\n): T {\n  const { allowPrototype = false, maxSize = 10 * 1024 * 1024 } = options\n\n  // Check size limit\n  const byteLength = Buffer.byteLength(jsonString, 'utf8')\n  if (byteLength > maxSize) {\n    throw new Error(\n      `JSON string exceeds maximum size limit${maxSize !== 10 * 1024 * 1024 ? ` of ${maxSize} bytes` : ''}`,\n    )\n  }\n\n  // Parse JSON\n  let parsed: unknown\n  try {\n    parsed = JSON.parse(jsonString)\n  } catch (error) {\n    throw new Error(`Failed to parse JSON: ${error}`)\n  }\n\n  // Check for prototype pollution\n  if (\n    !allowPrototype &&\n    typeof parsed === 'object' &&\n    parsed !== null &&\n    !Array.isArray(parsed)\n  ) {\n    const dangerous = ['__proto__', 'constructor', 'prototype']\n    for (const key of dangerous) {\n      if (ObjectHasOwn(parsed, key)) {\n        throw new Error(\n          'JSON contains potentially malicious prototype pollution keys',\n        )\n      }\n    }\n  }\n\n  // Validate against schema if provided\n  if (schema) {\n    const result = schema.safeParse(parsed)\n    if (!result.success) {\n      const errors = result.error.issues\n        .map(\n          (issue: { path: Array<string | number>; message: string }) =>\n            `${issue.path.join('.')}: ${issue.message}`,\n        )\n        .join(', ')\n      throw new Error(`Validation failed: ${errors}`)\n    }\n    return result.data as T\n  }\n\n  return parsed as T\n}\n\n/**\n * Attempt to parse JSON, returning `undefined` on any error.\n * This is a non-throwing wrapper around `safeJsonParse` for cases where\n * you want to gracefully handle parse failures without try-catch blocks.\n *\n * Use this when parsing is optional or you have a fallback strategy.\n * For critical parsing where you need error details, use `safeJsonParse` or `parseJsonWithResult`.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns The parsed data on success, or `undefined` on any error\n *\n * @example\n * ```ts\n * // Graceful fallback to default\n * const config = tryJsonParse<Config>(jsonString) ?? defaultConfig\n *\n * // Optional parsing\n * const data = tryJsonParse(possiblyInvalidJson)\n * if (data) {\n *   console.log('Parsed successfully:', data)\n * }\n *\n * // With schema validation\n * const user = tryJsonParse(jsonString, userSchema)\n * ```\n */\nexport function tryJsonParse<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T | undefined {\n  try {\n    return safeJsonParse(jsonString, schema, options)\n  } catch {\n    return undefined\n  }\n}\n\n/**\n * Parse JSON and return a discriminated union result.\n * Never throws - always returns a result object with success/failure information.\n *\n * This is ideal when you need detailed error messages and type-safe result handling.\n * The discriminated union allows TypeScript to narrow types based on the `success` flag.\n *\n * @template T - The expected type of the parsed data\n * @param jsonString - The JSON string to parse\n * @param schema - Optional Zod-compatible schema for validation\n * @param options - Parsing options for security and behavior control\n * @returns Result object with either `{success: true, data}` or `{success: false, error}`\n *\n * @example\n * ```ts\n * // Type-safe error handling\n * const result = parseJsonWithResult<User>(jsonString, userSchema)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(`User: ${result.data.name}`)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(`Parse failed: ${result.error}`)\n * }\n *\n * // Early return pattern\n * const result = parseJsonWithResult(jsonString)\n * if (!result.success) {\n *   logger.error(result.error)\n *   return\n * }\n * processData(result.data)\n * ```\n */\nexport function parseJsonWithResult<T = unknown>(\n  jsonString: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): JsonParseResult<T> {\n  try {\n    const data = safeJsonParse(jsonString, schema, options)\n    return { success: true, data }\n  } catch (error: unknown) {\n    const message = error instanceof Error ? error.message : 'Unknown error'\n    return { success: false, error: message }\n  }\n}\n\n/**\n * Create a reusable JSON parser with pre-configured schema and options.\n * Useful for parsing multiple JSON strings with the same validation rules.\n *\n * The returned parser function can accept per-call options that override the defaults.\n * This factory pattern reduces repetition when parsing many similar JSON payloads.\n *\n * @template T - The expected type of the parsed data\n * @param schema - Optional Zod-compatible schema for validation\n * @param defaultOptions - Default parsing options applied to all parse calls\n * @returns A parser function that accepts a JSON string and optional per-call options\n *\n * @example\n * ```ts\n * // Create a parser for API responses\n * import { z } from 'zod'\n * const apiResponseSchema = z.object({\n *   status: z.string(),\n *   data: z.unknown()\n * })\n *\n * const parseApiResponse = createJsonParser(apiResponseSchema, {\n *   maxSize: 5 * 1024 * 1024 // 5MB limit for API responses\n * })\n *\n * // Use the parser multiple times\n * const response1 = parseApiResponse(json1)\n * const response2 = parseApiResponse(json2)\n *\n * // Override options for specific calls\n * const response3 = parseApiResponse(json3, { maxSize: 10 * 1024 * 1024 })\n * ```\n */\nexport function createJsonParser<T = unknown>(\n  schema?: Schema<T> | undefined,\n  defaultOptions?: JsonParseOptions | undefined,\n) {\n  return (jsonString: string, options?: JsonParseOptions | undefined): T => {\n    return safeJsonParse(jsonString, schema, { ...defaultOptions, ...options })\n  }\n}\n\n/**\n * Parse newline-delimited JSON (NDJSON) into an array.\n * Each line is treated as a separate JSON object. Empty lines are skipped.\n *\n * NDJSON format is commonly used for streaming logs, bulk data transfers,\n * and event streams where each line represents a complete JSON document.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @returns Array of parsed objects, one per non-empty line\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Parse NDJSON logs\n * const ndjsonString = `\n * {\"level\":\"info\",\"message\":\"Server started\"}\n * {\"level\":\"error\",\"message\":\"Connection failed\"}\n * {\"level\":\"info\",\"message\":\"Retrying...\"}\n * `\n * const logs = parseNdjson<LogEntry>(ndjsonString, logSchema)\n * console.log(logs.length) // 3\n *\n * // Parse with size limits per line\n * const entries = parseNdjson(ndjson, undefined, { maxSize: 1024 })\n *\n * // Empty lines are automatically skipped\n * const data = parseNdjson('{\"a\":1}\\n\\n{\"b\":2}\\n') // 2 objects\n * ```\n */\nexport function parseNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): T[] {\n  const results: T[] = []\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      const parsed = safeJsonParse<T>(line, schema, options)\n      results.push(parsed)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n\n  return results\n}\n\n/**\n * Stream-parse newline-delimited JSON (NDJSON) using a generator.\n * Yields one parsed object at a time, enabling memory-efficient processing of large NDJSON files.\n *\n * Unlike `parseNdjson` which loads all results into memory, this generator allows\n * processing each line individually, making it ideal for large datasets or streaming scenarios.\n *\n * @template T - The expected type of each parsed JSON object\n * @param ndjson - Newline-delimited JSON string (supports both `\\n` and `\\r\\n`)\n * @param schema - Optional Zod-compatible schema for validation of each line\n * @param options - Parsing options applied to each line\n * @yields Parsed objects one at a time as the generator iterates\n *\n * @throws {Error} When any line fails to parse (includes line number in error message)\n *\n * @example\n * ```ts\n * // Memory-efficient processing of large NDJSON files\n * const ndjsonString = readLargeFile('logs.ndjson')\n *\n * for (const log of streamNdjson<LogEntry>(ndjsonString, logSchema)) {\n *   if (log.level === 'error') {\n *     console.error('Error found:', log.message)\n *   }\n * }\n *\n * // Collect filtered results without loading everything\n * const errors = [...streamNdjson(ndjson)]\n *   .filter(log => log.level === 'error')\n *\n * // Early termination when condition is met\n * for (const entry of streamNdjson(ndjson)) {\n *   if (entry.id === targetId) {\n *     processEntry(entry)\n *     break // Stop processing remaining lines\n *   }\n * }\n * ```\n */\nexport function* streamNdjson<T = unknown>(\n  ndjson: string,\n  schema?: Schema<T> | undefined,\n  options?: JsonParseOptions | undefined,\n): Generator<T, void, unknown> {\n  const lines = ndjson.split(/\\r?\\n/)\n\n  for (let i = 0; i < lines.length; i++) {\n    const line = lines[i]?.trim()\n    if (!line || line === '') {\n      continue\n    }\n\n    try {\n      yield safeJsonParse<T>(line, schema, options)\n    } catch (error: unknown) {\n      const message = error instanceof Error ? error.message : String(error)\n      throw new Error(`Failed to parse NDJSON at line ${i + 1}: ${message}`)\n    }\n  }\n}\n"],
-  "mappings": "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",
-  "names": ["json_parser_exports", "__export", "createJsonParser", "parseJsonWithResult", "parseNdjson", "safeJsonParse", "streamNdjson", "tryJsonParse", "__toCommonJS", "ObjectHasOwn", "jsonString", "schema", "options", "allowPrototype", "maxSize", "parsed", "error", "dangerous", "key", "result", "errors", "issue", "defaultOptions", "ndjson", "results", "lines", "i", "line", "message"]
+  "mappings": "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",
+  "names": []
 }

package/dist/validation/types.js

@@ -1,3 +1,17 @@
 /* Socket Lib - Built with esbuild */
-var r=Object.defineProperty;var o=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var i=(a,e,t,n)=>{if(e&&typeof e=="object"||typeof e=="function")for(let s of d(e))!u.call(a,s)&&s!==t&&r(a,s,{get:()=>e[s],enumerable:!(n=o(e,s))||n.enumerable});return a};var c=a=>i(r({},"__esModule",{value:!0}),a);var f={};module.exports=c(f);
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
 //# sourceMappingURL=types.js.map

package/dist/validation/types.js.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../src/validation/types.ts"],
   "sourcesContent": ["/**\n * @fileoverview Validation type definitions.\n * Provides core types for schema validation and JSON parsing with security features.\n */\n\n/**\n * Result of a schema validation operation.\n * Contains either successful parsed data or error information.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: ParseResult<User> = schema.safeParse(data)\n * if (result.success) {\n *   console.log(result.data) // User object\n * } else {\n *   console.error(result.error) // Error details\n * }\n * ```\n */\nexport interface ParseResult<T> {\n  /** Indicates whether parsing was successful */\n  success: boolean\n  /** Parsed and validated data (only present when `success` is `true`) */\n  data?: T | undefined\n  /** Error information (only present when `success` is `false`) */\n  error?: any\n}\n\n/**\n * Base schema interface compatible with Zod and similar validation libraries.\n * Provides both safe and throwing parsing methods.\n *\n * @template T - The expected output type after validation\n *\n * @example\n * ```ts\n * import { z } from 'zod'\n *\n * const userSchema = z.object({\n *   name: z.string(),\n *   age: z.number()\n * })\n *\n * // Schema satisfies this interface\n * const schema: Schema<User> = userSchema\n * const result = schema.safeParse({ name: 'Alice', age: 30 })\n * ```\n */\nexport interface Schema<T = any> {\n  /**\n   * Safely parse data without throwing errors.\n   * Returns a result object indicating success or failure.\n   *\n   * @param data - The data to validate\n   * @returns Parse result with success flag and data or error\n   */\n  safeParse(data: any): ParseResult<T>\n\n  /**\n   * Parse data and throw an error if validation fails.\n   * Use this when you want to fail fast on invalid data.\n   *\n   * @param data - The data to validate\n   * @returns The validated and parsed data\n   * @throws {Error} When validation fails\n   */\n  parse(data: any): T\n\n  /**\n   * Optional schema name for debugging and error messages.\n   * Useful for identifying which schema failed in complex validation chains.\n   */\n  _name?: string | undefined\n}\n\n/**\n * Options for configuring JSON parsing behavior with security controls.\n *\n * @example\n * ```ts\n * const options: JsonParseOptions = {\n *   maxSize: 1024 * 1024, // 1MB limit\n *   allowPrototype: false // Block prototype pollution\n * }\n * ```\n */\nexport interface JsonParseOptions {\n  /**\n   * Allow dangerous prototype pollution keys (`__proto__`, `constructor`, `prototype`).\n   * Set to `true` only if you trust the JSON source completely.\n   *\n   * @default false\n   *\n   * @example\n   * ```ts\n   * // Will throw error by default\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}')\n   *\n   * // Allows the parse (dangerous!)\n   * safeJsonParse('{\"__proto__\": {\"polluted\": true}}', undefined, {\n   *   allowPrototype: true\n   * })\n   * ```\n   */\n  allowPrototype?: boolean | undefined\n\n  /**\n   * Maximum allowed size of JSON string in bytes.\n   * Prevents memory exhaustion from extremely large payloads.\n   *\n   * @default 10_485_760 (10 MB)\n   *\n   * @example\n   * ```ts\n   * // Limit to 1KB\n   * safeJsonParse(jsonString, undefined, { maxSize: 1024 })\n   * ```\n   */\n  maxSize?: number | undefined\n}\n\n/**\n * Discriminated union type for JSON parsing results.\n * Enables type-safe handling of success and failure cases.\n *\n * @template T - The expected type of the parsed data\n *\n * @example\n * ```ts\n * const result: JsonParseResult<User> = parseJsonWithResult(jsonString)\n *\n * if (result.success) {\n *   // TypeScript knows result.data is available\n *   console.log(result.data.name)\n * } else {\n *   // TypeScript knows result.error is available\n *   console.error(result.error)\n * }\n * ```\n */\nexport type JsonParseResult<T> =\n  | { success: true; data: T }\n  | { success: false; error: string }\n"],
-  "mappings": ";kWAAA,IAAAA,EAAA,kBAAAC,EAAAD",
-  "names": ["types_exports", "__toCommonJS"]
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
 }