@frontmcp/utils 1.10.16 → 1.11.0-rc.2

package/README.md

@@ -51,6 +51,7 @@ await storage.get('ticket:T-1'); // 'open'
 | Encryption, keys | `encryptValue`, `decryptValue`, `signData`, `verifyData`, `KeyPersistence`, `createKeyPersistence`                                                                        |
 | Storage          | `createStorage`, `createMemoryStorage`, `TypedStorage`, `EncryptedTypedStorage`, and adapters for memory, Redis, Vercel KV, Upstash and the file system                   |
 | File system      | `readFile`, `writeFile`, `mkdir`, `stat`, `fileExists`, `readJSON`, `writeJSON`, `ensureDir`, `isDirEmpty`, `runCmd` and more. Node.js only; `fs` loads on first use.     |
+| Processes        | `spawnOwned`, `reapOrphans`, `watchParent`, `watchPath`, `stopProcessTree`, `signalProcessTree`. Node.js only; `child_process` loads on first use.                        |
 | Environment      | `getEnv`, `isProduction`, `isDevelopment`, `isEdgeRuntime`, `isServerless`, `getRuntimeContext`, `isNode`, `isBrowser`                                                    |
 | Context, events  | `AsyncLocalStorage`, `EventEmitter`, both with browser builds                                                                                                             |
 | Safe regex       | `isPatternSafe`, `createSafeRegExp`, `safeTest`, `safeMatch`, `safeReplace`, against ReDoS (regular expression denial of service)                                         |

package/browser/async-context/browser-async-context.mjs

@@ -0,0 +1,177 @@
+// libs/utils/src/async-context/browser-async-context.ts
+import { AsyncContextOverlapError } from "./overlap-error.mjs";
+import { AsyncContextOverlapError as AsyncContextOverlapError2 } from "./overlap-error.mjs";
+var nativeAsyncContext = (() => {
+  const candidate = globalThis.AsyncContext;
+  return typeof candidate?.Variable === "function" ? candidate : void 0;
+})();
+function getAsyncContextMode() {
+  return nativeAsyncContext ? "native" : "serialized";
+}
+var SLOW_TURN_WARNING_MS = 1e4;
+var RequestSlot = class {
+  /** Frames of every storage that are still running in this request. */
+  live = 0;
+  /** Storages whose runs overlapped in this request; they refuse to answer until they unwind. */
+  tainted = /* @__PURE__ */ new Set();
+  idleWaiters = [];
+  enter() {
+    this.live++;
+  }
+  leave() {
+    this.live--;
+    if (this.live === 0) {
+      for (const resolve of this.idleWaiters.splice(0)) resolve();
+    }
+  }
+  /** Resolves once no frame of this request is running any more. */
+  idle() {
+    return this.live === 0 ? Promise.resolve() : new Promise((resolve) => this.idleWaiters.push(resolve));
+  }
+};
+var ROOT = new RequestSlot();
+var active = ROOT;
+var owner;
+var turnQueue = [];
+var slowTurnWarned = false;
+var overlapReported = false;
+function takeTurn(slot) {
+  if (!owner) {
+    owner = slot;
+    active = slot;
+    return Promise.resolve();
+  }
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      if (slowTurnWarned) return;
+      slowTurnWarned = true;
+      console.warn(
+        "[frontmcp] A request has waited more than 10s for another one to finish. This runtime has no AsyncContext, so FrontMCP runs requests one at a time to keep their contexts apart. A tool that calls its own server through a client (instead of this.scope flows) waits for itself."
+      );
+    }, SLOW_TURN_WARNING_MS);
+    timer.unref?.();
+    turnQueue.push({
+      slot,
+      start: () => {
+        clearTimeout(timer);
+        resolve();
+      }
+    });
+  });
+}
+function passTurn(slot) {
+  if (owner !== slot) return;
+  const next = turnQueue.shift();
+  if (next) {
+    owner = next.slot;
+    active = next.slot;
+    next.start();
+  } else {
+    owner = void 0;
+    active = ROOT;
+  }
+}
+async function runRequestExclusive(fn) {
+  if (nativeAsyncContext) return fn();
+  const slot = new RequestSlot();
+  await takeTurn(slot);
+  try {
+    return await fn();
+  } finally {
+    await slot.idle();
+    passTurn(slot);
+  }
+}
+async function awaitOutsideRequest(promise) {
+  if (nativeAsyncContext) return promise;
+  const slot = owner;
+  if (!slot || active !== slot) return promise;
+  passTurn(slot);
+  try {
+    return await promise;
+  } finally {
+    await takeTurn(slot);
+  }
+}
+var AsyncLocalStorage = class {
+  native;
+  stacks = /* @__PURE__ */ new WeakMap();
+  constructor() {
+    if (nativeAsyncContext) this.native = new nativeAsyncContext.Variable();
+  }
+  run(store, callback, ...args) {
+    if (this.native) return this.native.run(store, callback, ...args);
+    const slot = active;
+    let stack = this.stacks.get(slot);
+    if (!stack) {
+      stack = [];
+      this.stacks.set(slot, stack);
+    }
+    const frame = { store };
+    stack.push(frame);
+    slot.enter();
+    let result;
+    try {
+      result = callback(...args);
+    } catch (error) {
+      this.leave(slot, frame);
+      throw error;
+    }
+    if (result instanceof Promise) {
+      return result.then(
+        (value) => {
+          if (!this.leave(slot, frame)) throw this.overlapError();
+          return value;
+        },
+        (error) => {
+          this.leave(slot, frame);
+          throw error;
+        }
+      );
+    }
+    this.leave(slot, frame);
+    return result;
+  }
+  getStore() {
+    if (this.native) return this.native.get();
+    const slot = active;
+    if (slot.tainted.has(this)) throw this.overlapError();
+    const stack = this.stacks.get(slot);
+    return stack && stack.length > 0 ? stack[stack.length - 1].store : void 0;
+  }
+  /**
+   * Remove `frame` from its request's stack. Returns false when it was not the innermost frame: a
+   * later run of this storage in the same request was still open, so the two overlapped and reads
+   * in between may have seen the other run's store.
+   */
+  leave(slot, frame) {
+    const stack = this.stacks.get(slot) ?? [];
+    const index = stack.lastIndexOf(frame);
+    const innermost = index === stack.length - 1;
+    if (index !== -1) stack.splice(index, 1);
+    if (!innermost) {
+      slot.tainted.add(this);
+      if (!overlapReported) {
+        overlapReported = true;
+        console.error(
+          "[frontmcp] Two concurrent runs of one async context overlapped inside a request. This runtime has no AsyncContext, so the context of each cannot be told apart; reads fail for the rest of that request instead of returning the wrong value."
+        );
+      }
+    }
+    if (stack.length === 0) slot.tainted.delete(this);
+    slot.leave();
+    return innermost;
+  }
+  overlapError() {
+    return new AsyncContextOverlapError(
+      "Concurrent runs of an async context overlapped in one request, and this runtime has no AsyncContext to tell them apart. Run the calls one after another, or use a runtime with AsyncContext."
+    );
+  }
+};
+export {
+  AsyncContextOverlapError2 as AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
+};

package/browser/async-context/index.mjs

@@ -0,0 +1,15 @@
+// libs/utils/src/async-context/index.ts
+import {
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
+} from "./browser-async-context.mjs";
+export {
+  AsyncContextOverlapError,
+  AsyncLocalStorage,
+  awaitOutsideRequest,
+  getAsyncContextMode,
+  runRequestExclusive
+};

package/browser/async-context/overlap-error.mjs

@@ -0,0 +1,10 @@
+// libs/utils/src/async-context/overlap-error.ts
+var AsyncContextOverlapError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AsyncContextOverlapError";
+  }
+};
+export {
+  AsyncContextOverlapError
+};

package/browser/class-brand/class-brand.mjs

@@ -0,0 +1,27 @@
+// libs/utils/src/class-brand/class-brand.ts
+var CLASS_BRAND = /* @__PURE__ */ Symbol.for("@frontmcp/class-brand");
+var ordinaryHasInstance = Function.prototype[Symbol.hasInstance];
+function ownBrandOf(klass) {
+  if (typeof klass !== "function" || !Object.prototype.hasOwnProperty.call(klass, CLASS_BRAND)) return void 0;
+  return klass[CLASS_BRAND];
+}
+function classOfPrototype(proto) {
+  return Object.getOwnPropertyDescriptor(proto, "constructor")?.value;
+}
+function brandClass(klass, brand) {
+  Object.defineProperty(klass, CLASS_BRAND, { value: brand, enumerable: false, writable: false, configurable: false });
+}
+function isBrandedInstance(klass, value) {
+  if (ordinaryHasInstance.call(klass, value)) return true;
+  if (typeof value !== "object" || value === null) return false;
+  const brand = ownBrandOf(klass);
+  if (brand === void 0) return false;
+  for (let proto = Object.getPrototypeOf(value); proto !== null; proto = Object.getPrototypeOf(proto)) {
+    if (ownBrandOf(classOfPrototype(proto)) === brand) return true;
+  }
+  return false;
+}
+export {
+  brandClass,
+  isBrandedInstance
+};

package/browser/class-brand/index.mjs

@@ -0,0 +1,6 @@
+// libs/utils/src/class-brand/index.ts
+import { brandClass, isBrandedInstance } from "./class-brand.mjs";
+export {
+  brandClass,
+  isBrandedInstance
+};

package/browser/content/content.mjs

@@ -0,0 +1,151 @@
+// libs/utils/src/content/content.ts
+function sanitizeToJson(value) {
+  const ancestors = /* @__PURE__ */ new WeakSet();
+  function withinAncestors(container, build) {
+    if (ancestors.has(container)) {
+      return void 0;
+    }
+    ancestors.add(container);
+    try {
+      return build();
+    } finally {
+      ancestors.delete(container);
+    }
+  }
+  function sanitize(val) {
+    if (typeof val === "function" || typeof val === "symbol") {
+      return void 0;
+    }
+    if (typeof val === "bigint") {
+      return val.toString();
+    }
+    if (val instanceof Date) {
+      return val.toISOString();
+    }
+    if (val instanceof Error) {
+      return {
+        name: val.name,
+        message: val.message,
+        stack: val.stack
+      };
+    }
+    if (val instanceof Map) {
+      return withinAncestors(val, () => {
+        const obj = {};
+        for (const [k, v] of val.entries()) {
+          obj[String(k)] = sanitize(v);
+        }
+        return obj;
+      });
+    }
+    if (val instanceof Set) {
+      return withinAncestors(val, () => Array.from(val).map(sanitize));
+    }
+    if (Array.isArray(val)) {
+      return withinAncestors(val, () => val.map(sanitize));
+    }
+    if (val && typeof val === "object") {
+      return withinAncestors(val, () => {
+        const sanitized = {};
+        for (const [key, value2] of Object.entries(val)) {
+          const clean = sanitize(value2);
+          if (clean !== void 0) {
+            sanitized[key] = clean;
+          }
+        }
+        return sanitized;
+      });
+    }
+    return val;
+  }
+  return sanitize(value);
+}
+function findNonFiniteNumber(value) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(val, path) {
+    if (typeof val === "number" && !Number.isFinite(val)) {
+      return { path, value: val };
+    }
+    if (val && typeof val === "object") {
+      if (seen.has(val)) return void 0;
+      seen.add(val);
+      if (Array.isArray(val)) {
+        for (let i = 0; i < val.length; i++) {
+          const found = walk(val[i], `${path}[${i}]`);
+          if (found) return found;
+        }
+        return void 0;
+      }
+      for (const [k, v] of Object.entries(val)) {
+        const found = walk(v, path ? `${path}.${k}` : k);
+        if (found) return found;
+      }
+    }
+    return void 0;
+  }
+  return walk(value, "");
+}
+function findDroppedKeys(original, parsed) {
+  const droppedPaths = /* @__PURE__ */ new Set();
+  function walk(source, target, path) {
+    if (source === target) return;
+    if (Array.isArray(source)) {
+      source.forEach((item, index) => walk(item, Array.isArray(target) ? target[index] : void 0, `${path}[]`));
+      return;
+    }
+    if (!isPlainRecord(source)) return;
+    const targetRecord = isPlainRecord(target) ? target : {};
+    for (const [key, value] of Object.entries(source)) {
+      if (value === void 0) continue;
+      const keyPath = path ? `${path}.${key}` : key;
+      if (Object.prototype.hasOwnProperty.call(targetRecord, key)) walk(value, targetRecord[key], keyPath);
+      else droppedPaths.add(keyPath);
+    }
+  }
+  walk(original, parsed, "");
+  return [...droppedPaths].sort();
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var MIME_TYPES = {
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  htm: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  ts: "application/typescript",
+  txt: "text/plain",
+  md: "text/markdown",
+  yaml: "application/yaml",
+  yml: "application/yaml",
+  csv: "text/csv",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  svg: "image/svg+xml",
+  pdf: "application/pdf"
+};
+function inferMimeType(uri, content) {
+  const ext = uri.split(".").pop()?.toLowerCase();
+  if (ext && MIME_TYPES[ext]) {
+    return MIME_TYPES[ext];
+  }
+  if (typeof content === "string") {
+    if (content.trim().startsWith("{") || content.trim().startsWith("[")) {
+      return "application/json";
+    }
+    if (content.trim().startsWith("<")) {
+      return content.includes("<!DOCTYPE html") || content.includes("<html") ? "text/html" : "application/xml";
+    }
+  }
+  return "text/plain";
+}
+export {
+  findDroppedKeys,
+  findNonFiniteNumber,
+  inferMimeType,
+  sanitizeToJson
+};

package/browser/content/index.mjs

@@ -0,0 +1,8 @@
+// libs/utils/src/content/index.ts
+import { sanitizeToJson, inferMimeType, findNonFiniteNumber, findDroppedKeys } from "./content.mjs";
+export {
+  findDroppedKeys,
+  findNonFiniteNumber,
+  inferMimeType,
+  sanitizeToJson
+};

package/browser/crypto/browser.mjs

@@ -0,0 +1,103 @@
+// libs/utils/src/crypto/browser.ts
+import { gcm } from "@noble/ciphers/aes.js";
+import { hkdf } from "@noble/hashes/hkdf.js";
+import { hmac } from "@noble/hashes/hmac.js";
+import { sha256 as sha256Hash } from "@noble/hashes/sha2.js";
+import { randomBytes as nobleRandomBytes } from "@noble/hashes/utils.js";
+import { isRsaPssAlg, jwtAlgToWebCryptoAlg } from "./jwt-alg.mjs";
+import { rsaVerifyBrowser } from "./web-rsa.mjs";
+function toBytes(data) {
+  if (typeof data === "string") {
+    return new TextEncoder().encode(data);
+  }
+  return data;
+}
+function toHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function generateUUID() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const bytes = nobleRandomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = toHex(bytes);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+function constantTimeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let result = 0;
+  for (let i = 0; i < a.length; i++) {
+    result |= a[i] ^ b[i];
+  }
+  return result === 0;
+}
+var browserCrypto = {
+  randomUUID() {
+    return generateUUID();
+  },
+  randomBytes(length) {
+    return nobleRandomBytes(length);
+  },
+  sha256(data) {
+    return sha256Hash(toBytes(data));
+  },
+  sha256Hex(data) {
+    return toHex(sha256Hash(toBytes(data)));
+  },
+  hmacSha256(key, data) {
+    return hmac(sha256Hash, key, data);
+  },
+  hkdfSha256(ikm, salt, info, length) {
+    const effectiveSalt = salt.length > 0 ? salt : new Uint8Array(32);
+    return hkdf(sha256Hash, ikm, effectiveSalt, info, length);
+  },
+  encryptAesGcm(key, plaintext, iv) {
+    const cipher = gcm(key, iv);
+    const sealed = cipher.encrypt(plaintext);
+    const ciphertext = sealed.slice(0, -16);
+    const tag = sealed.slice(-16);
+    return { ciphertext, tag };
+  },
+  decryptAesGcm(key, ciphertext, iv, tag) {
+    const cipher = gcm(key, iv);
+    const sealed = new Uint8Array(ciphertext.length + tag.length);
+    sealed.set(ciphertext);
+    sealed.set(tag, ciphertext.length);
+    return cipher.decrypt(sealed);
+  },
+  timingSafeEqual(a, b) {
+    return constantTimeEqual(a, b);
+  }
+};
+function nodeOnly(name) {
+  throw new Error(`${name} is only available in Node.js runtimes`);
+}
+function rsaVerify() {
+  return nodeOnly("rsaVerify");
+}
+function rsaSignBase64Url() {
+  return nodeOnly("rsaSignBase64Url");
+}
+function rsaVerifySync() {
+  return nodeOnly("rsaVerifySync");
+}
+function pemToPublicJwk() {
+  return nodeOnly("pemToPublicJwk");
+}
+function generateRsaKeyPair() {
+  return nodeOnly("generateRsaKeyPair");
+}
+export {
+  browserCrypto,
+  browserCrypto as cryptoProvider,
+  generateRsaKeyPair,
+  isRsaPssAlg,
+  jwtAlgToWebCryptoAlg,
+  pemToPublicJwk,
+  rsaSignBase64Url,
+  rsaVerify,
+  rsaVerifyBrowser,
+  rsaVerifySync
+};

package/browser/crypto/encrypted-blob.mjs

@@ -0,0 +1,119 @@
+// libs/utils/src/crypto/encrypted-blob.ts
+import { encryptAesGcm, decryptAesGcm, randomBytes, base64urlEncode, base64urlDecode } from "./index.mjs";
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+var EncryptedBlobError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "EncryptedBlobError";
+  }
+};
+function encryptValue(data, key) {
+  if (key.length !== 32) {
+    throw new EncryptedBlobError(`Encryption key must be 32 bytes (AES-256), got ${key.length} bytes`);
+  }
+  let jsonString;
+  try {
+    jsonString = JSON.stringify(data);
+  } catch (error) {
+    throw new EncryptedBlobError(`Failed to serialize data: ${error.message}`);
+  }
+  const plaintext = textEncoder.encode(jsonString);
+  const iv = randomBytes(12);
+  const { ciphertext, tag } = encryptAesGcm(key, plaintext, iv);
+  return {
+    alg: "A256GCM",
+    iv: base64urlEncode(iv),
+    tag: base64urlEncode(tag),
+    data: base64urlEncode(ciphertext)
+  };
+}
+function decryptValue(blob, key) {
+  if (key.length !== 32) {
+    throw new EncryptedBlobError(`Decryption key must be 32 bytes (AES-256), got ${key.length} bytes`);
+  }
+  if (blob.alg !== "A256GCM") {
+    throw new EncryptedBlobError(`Unsupported algorithm: ${blob.alg}, expected A256GCM`);
+  }
+  let iv;
+  let tag;
+  let ciphertext;
+  try {
+    iv = base64urlDecode(blob.iv);
+    tag = base64urlDecode(blob.tag);
+    ciphertext = base64urlDecode(blob.data);
+  } catch (error) {
+    throw new EncryptedBlobError(`Failed to decode blob fields: ${error.message}`);
+  }
+  let decrypted;
+  try {
+    decrypted = decryptAesGcm(key, ciphertext, iv, tag);
+  } catch (error) {
+    throw new EncryptedBlobError(`Decryption failed: ${error.message}`);
+  }
+  try {
+    return JSON.parse(textDecoder.decode(decrypted));
+  } catch (error) {
+    throw new EncryptedBlobError(`Failed to parse decrypted data: ${error.message}`);
+  }
+}
+function tryDecryptValue(blob, key) {
+  try {
+    return decryptValue(blob, key);
+  } catch {
+    return null;
+  }
+}
+function serializeBlob(blob) {
+  return JSON.stringify(blob);
+}
+function deserializeBlob(str) {
+  let parsed;
+  try {
+    parsed = JSON.parse(str);
+  } catch (error) {
+    throw new EncryptedBlobError(`Failed to parse blob JSON: ${error.message}`);
+  }
+  if (!isValidEncryptedBlob(parsed)) {
+    throw new EncryptedBlobError("Invalid encrypted blob structure");
+  }
+  return parsed;
+}
+function tryDeserializeBlob(str) {
+  try {
+    return deserializeBlob(str);
+  } catch {
+    return null;
+  }
+}
+function isValidEncryptedBlob(value) {
+  return typeof value === "object" && value !== null && "alg" in value && "iv" in value && "tag" in value && "data" in value && value.alg === "A256GCM" && typeof value.iv === "string" && typeof value.tag === "string" && typeof value.data === "string";
+}
+function encryptAndSerialize(data, key) {
+  const blob = encryptValue(data, key);
+  return serializeBlob(blob);
+}
+function deserializeAndDecrypt(str, key) {
+  const blob = deserializeBlob(str);
+  return decryptValue(blob, key);
+}
+function tryDeserializeAndDecrypt(str, key) {
+  try {
+    return deserializeAndDecrypt(str, key);
+  } catch {
+    return null;
+  }
+}
+export {
+  EncryptedBlobError,
+  decryptValue,
+  deserializeAndDecrypt,
+  deserializeBlob,
+  encryptAndSerialize,
+  encryptValue,
+  isValidEncryptedBlob,
+  serializeBlob,
+  tryDecryptValue,
+  tryDeserializeAndDecrypt,
+  tryDeserializeBlob
+};

package/browser/crypto/hmac-signing.mjs

@@ -0,0 +1,70 @@
+// libs/utils/src/crypto/hmac-signing.ts
+import { hmacSha256 } from "./index.mjs";
+import { base64urlEncode, base64urlDecode } from "./index.mjs";
+import { timingSafeEqual } from "./index.mjs";
+function computeSignature(data, secret) {
+  const encoder = new TextEncoder();
+  const keyBytes = encoder.encode(secret);
+  const dataBytes = encoder.encode(data);
+  const hmac = hmacSha256(keyBytes, dataBytes);
+  return base64urlEncode(hmac);
+}
+function signData(data, config) {
+  const jsonData = JSON.stringify(data);
+  const sig = computeSignature(jsonData, config.secret);
+  const signed = {
+    data,
+    sig,
+    v: 1
+  };
+  return JSON.stringify(signed);
+}
+function verifyData(signedJson, config) {
+  try {
+    const parsed = JSON.parse(signedJson);
+    if (!parsed || typeof parsed !== "object" || !("sig" in parsed)) {
+      return null;
+    }
+    const signed = parsed;
+    if (signed.v !== 1) {
+      return null;
+    }
+    const jsonData = JSON.stringify(signed.data);
+    const expectedSig = computeSignature(jsonData, config.secret);
+    const sigBytes = base64urlDecode(signed.sig);
+    const expectedBytes = base64urlDecode(expectedSig);
+    if (sigBytes.length !== expectedBytes.length) {
+      return null;
+    }
+    if (!timingSafeEqual(sigBytes, expectedBytes)) {
+      return null;
+    }
+    return signed.data;
+  } catch {
+    return null;
+  }
+}
+function isSignedData(json) {
+  try {
+    const parsed = JSON.parse(json);
+    return parsed && typeof parsed === "object" && "sig" in parsed && "v" in parsed;
+  } catch {
+    return false;
+  }
+}
+function verifyOrParseData(json, config) {
+  if (isSignedData(json)) {
+    return verifyData(json, config);
+  }
+  try {
+    return JSON.parse(json);
+  } catch {
+    return null;
+  }
+}
+export {
+  isSignedData,
+  signData,
+  verifyData,
+  verifyOrParseData
+};