@poe-platform/safe-js 0.1.361 → 0.1.362

package/dist/safe-js/chunks/{chunk-MGIF45X7.js → chunk-EF6FLPF6.js}

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-UPTA6E3T.js";
+} from "./chunk-QMF5YOGC.js";
 
 // packages/safe-js/src/migrate.ts
 import { createHash } from "node:crypto";
@@ -8249,4 +8249,4 @@ export {
   parseMcpConfig,
   makeMcpModule
 };
-//# sourceMappingURL=chunk-MGIF45X7.js.map
+//# sourceMappingURL=chunk-EF6FLPF6.js.map

package/dist/safe-js/chunks/{chunk-UPTA6E3T.js → chunk-QMF5YOGC.js}

@@ -14638,6 +14638,96 @@ async function callSetMethod(target, methodName, args, options, stack = []) {
   }
 }
 
+// packages/safe-js/src/interp/globals/uint8-hex.ts
+var hexDigits = "0123456789abcdef";
+function installUint8Hex(budget, constructor, prototype) {
+  const fromHex = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "fromHex",
+    length: 1,
+    call: ([text]) => {
+      if (typeof text !== "string") throw new TypeError("Hex input must be a string.");
+      if (text.length % 2 !== 0) throw new SyntaxError("Hex input must have an even length.");
+      checkTypedArrayAllocation(text.length / 2, budget, 1);
+      const value = new Uint8Array(text.length / 2);
+      decodeHexInto(text, value, budget);
+      setSandboxPrototype(value, prototype, budget);
+      return value;
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "fromHex", {
+    value: fromHex,
+    writable: true,
+    configurable: true
+  });
+  registerIntrinsicFunction(budget, fromHex);
+  Object.defineProperties(prototype, {
+    toHex: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "toHex",
+        length: 0,
+        call: (_args, context) => {
+          const value = uint8Receiver(context?.thisValue);
+          const { length } = typedArrayStorage(value, true);
+          budget.provisionDataUsage(length * 2)();
+          let result = "";
+          for (let index = 0; index < length; index++) {
+            budget.visitNode();
+            const byte = value[index];
+            result = budget.allocateString(result + hexDigits[byte >> 4] + hexDigits[byte & 15]);
+          }
+          return result;
+        }
+      })
+    },
+    setFromHex: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "setFromHex",
+        length: 1,
+        call: ([text], context) => {
+          const value = uint8Receiver(context?.thisValue);
+          if (typeof text !== "string") throw new TypeError("Hex input must be a string.");
+          typedArrayStorage(value, true);
+          const written = decodeHexInto(text, value, budget);
+          return { read: written * 2, written };
+        }
+      })
+    }
+  });
+}
+function uint8Receiver(value) {
+  if (!isNumericTypedArray(value) || typedArrayStorage(value).Native !== Uint8Array)
+    throw new TypeError("Hex conversion requires a Uint8Array receiver.");
+  return value;
+}
+function decodeHexInto(text, value, budget) {
+  if (text.length % 2 !== 0) throw new SyntaxError("Hex input must have an even length.");
+  const length = Math.min(text.length / 2, typedArrayStorage(value).length);
+  for (let index = 0; index < length; index++) {
+    budget.visitNode();
+    const high = hexNibble(text.charCodeAt(index * 2));
+    const low = hexNibble(text.charCodeAt(index * 2 + 1));
+    if (high < 0 || low < 0) throw new SyntaxError("Invalid hexadecimal digit.");
+    value[index] = high * 16 + low;
+  }
+  return length;
+}
+function hexNibble(code) {
+  if (code >= 48 && code <= 57) return code - 48;
+  if (code >= 65 && code <= 70) return code - 55;
+  if (code >= 97 && code <= 102) return code - 87;
+  return -1;
+}
+
 // packages/safe-js/src/interp/globals/numeric-typed-array.ts
 var constructors = /* @__PURE__ */ new WeakMap();
 function createNumericTypedArrayGlobal(budget, nativePrototype = false, Native = Float32Array) {
@@ -14903,8 +14993,11 @@ function createNumericTypedArrayPrototypes(budget, bindings) {
     setSandboxPrototype(constructor, typedArray);
     setSandboxPrototype(prototype, shared);
     prototypes2.set(Native, prototype);
-    registerIntrinsicFunction(budget, constructor);
-    registerIntrinsicObject(budget, prototype);
+  }
+  installUint8Hex(budget, bindings.Uint8Array, prototypes2.get(Uint8Array));
+  for (const [name, Native] of Object.entries(numericTypedArrayConstructors)) {
+    registerIntrinsicFunction(budget, bindings[name]);
+    registerIntrinsicObject(budget, prototypes2.get(Native));
   }
   Object.defineProperty(shared, "constructor", { value: typedArray, writable: true, configurable: true });
   setSandboxPrototype(shared, getSandboxPrototype(/* @__PURE__ */ Object.create(null), budget));
@@ -42828,4 +42921,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-UPTA6E3T.js.map
+//# sourceMappingURL=chunk-QMF5YOGC.js.map