@poe-platform/safe-js 0.1.361 → 0.1.363

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-UPTA6E3T.js";
+} from "./chunk-OTFEHCGJ.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-ADA4LH5C.js.map

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

@@ -6995,6 +6995,11 @@ function copyTypedArrayStorage(value, state) {
   }
   return new storage.Native(buffer, storage.byteOffset, storage.length);
 }
+function requireUint8Array(value) {
+  if (!isNumericTypedArray(value) || typedArrayStorage(value).Native !== Uint8Array)
+    throw new TypeError("Conversion requires a Uint8Array receiver.");
+  return value;
+}
 
 // packages/safe-js/src/interp/date.ts
 import { types as types3 } from "node:util";
@@ -14638,6 +14643,272 @@ 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 = requireUint8Array(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 = requireUint8Array(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 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/uint8-base64.ts
+var alphabets = {
+  base64: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  base64url: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
+};
+function installUint8Base64(budget, constructor, prototype) {
+  const fromBase64 = createSandboxClosure({
+    guest: true,
+    sandbox: true,
+    name: "fromBase64",
+    length: 1,
+    call: async ([text, options], context) => {
+      if (typeof text !== "string") throw new TypeError("Base64 input must be a string.");
+      const release = retainValues(budget, () => [text, options]);
+      try {
+        const { alphabet, mode } = await base64Options(options, false, budget, context);
+        const result = decodeBase64(text, alphabet, mode, budget);
+        if (result.error !== void 0) throw result.error;
+        budget.provisionDataUsage(result.bytes.length * 2 + 3)();
+        const value = new Uint8Array(result.bytes);
+        setSandboxPrototype(value, prototype, budget);
+        return value;
+      } finally {
+        release();
+      }
+    }
+  });
+  Object.defineProperty(materializeFunctionProperties(constructor), "fromBase64", {
+    value: fromBase64,
+    writable: true,
+    configurable: true
+  });
+  registerIntrinsicFunction(budget, fromBase64);
+  Object.defineProperties(prototype, {
+    toBase64: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "toBase64",
+        length: 0,
+        call: async ([options], context) => {
+          const value = requireUint8Array(context?.thisValue);
+          const release = retainValues(budget, () => [value, options]);
+          try {
+            const { alphabet, omitPadding } = await base64Options(options, true, budget, context);
+            const { length } = typedArrayStorage(value, true);
+            budget.provisionDataUsage(omitPadding ? Math.ceil(length * 4 / 3) : Math.ceil(length / 3) * 4)();
+            let result = "";
+            for (let index = 0; index < length; index += 3) {
+              budget.visitNode();
+              const a = value[index], b = value[index + 1] ?? 0, c = value[index + 2] ?? 0;
+              const chunk = alphabet[a >> 2] + alphabet[(a & 3) << 4 | b >> 4] + (index + 1 < length ? alphabet[(b & 15) << 2 | c >> 6] : omitPadding ? "" : "=") + (index + 2 < length ? alphabet[c & 63] : omitPadding ? "" : "=");
+              result = budget.allocateString(result + chunk);
+            }
+            return result;
+          } finally {
+            release();
+          }
+        }
+      })
+    },
+    setFromBase64: {
+      writable: true,
+      configurable: true,
+      value: createSandboxClosure({
+        guest: true,
+        sandbox: true,
+        name: "setFromBase64",
+        length: 1,
+        call: async ([text, options], context) => {
+          const value = requireUint8Array(context?.thisValue);
+          if (typeof text !== "string") throw new TypeError("Base64 input must be a string.");
+          const release = retainValues(budget, () => [value, text, options]);
+          try {
+            const { alphabet, mode } = await base64Options(options, false, budget, context);
+            const { length } = typedArrayStorage(value, true);
+            const result = decodeBase64(text, alphabet, mode, budget, length);
+            for (let index = 0; index < result.bytes.length; index++) value[index] = result.bytes[index];
+            if (result.error !== void 0) throw result.error;
+            return { read: result.read, written: result.bytes.length };
+          } finally {
+            release();
+          }
+        }
+      })
+    }
+  });
+}
+async function base64Options(options, encode, budget, context) {
+  if (options !== void 0 && (options === null || typeof options !== "object"))
+    throw new TypeError("Base64 options must be an object.");
+  const read = (key) => {
+    if (options === void 0) return void 0;
+    if (context?.getProperty !== void 0) return context.getProperty(options, key);
+    const descriptor = getSandboxPropertyDescriptor(options, key, budget);
+    return descriptor === void 0 ? void 0 : readPropertyDescriptor(descriptor, options, context);
+  };
+  const alphabet = await read("alphabet");
+  if (alphabet !== void 0 && alphabet !== "base64" && alphabet !== "base64url")
+    throw new TypeError("Invalid base64 alphabet.");
+  const digits = alphabets[alphabet ?? "base64"];
+  if (encode) return { alphabet: digits, omitPadding: Boolean(await read("omitPadding")), mode: "loose" };
+  const mode = await read("lastChunkHandling");
+  if (mode !== void 0 && mode !== "loose" && mode !== "strict" && mode !== "stop-before-partial")
+    throw new TypeError("Invalid base64 lastChunkHandling.");
+  return { alphabet: digits, omitPadding: false, mode: mode ?? "loose" };
+}
+function decodeBase64(text, alphabet, mode, budget, maxLength = Number.MAX_SAFE_INTEGER) {
+  const bytes = [];
+  const chunk = [];
+  let read = 0, index = 0;
+  const skipWhitespace2 = () => {
+    while (index < text.length) {
+      const code = text.charCodeAt(index);
+      if (code !== 9 && code !== 10 && code !== 12 && code !== 13 && code !== 32) break;
+      budget.visitNode();
+      index++;
+    }
+  };
+  const append = (strict) => {
+    if (strict && (chunk.length === 2 && (chunk[1] & 15) !== 0 || chunk.length === 3 && (chunk[2] & 3) !== 0))
+      throw new SyntaxError("Nonzero unused base64 bits.");
+    const length = bytes.length + chunk.length - 1;
+    budget.allocateArrayLength(length);
+    budget.provisionDataUsage(length + 1)();
+    bytes.push(chunk[0] << 2 | chunk[1] >> 4);
+    if (chunk.length > 2) bytes.push((chunk[1] & 15) << 4 | chunk[2] >> 2);
+    if (chunk.length > 3) bytes.push((chunk[2] & 3) << 6 | chunk[3]);
+  };
+  try {
+    if (maxLength === 0) return { read, bytes };
+    for (; ; ) {
+      skipWhitespace2();
+      if (index === text.length) {
+        if (chunk.length > 0) {
+          if (mode === "stop-before-partial") return { read, bytes };
+          if (mode === "strict" || chunk.length === 1) throw new SyntaxError("Incomplete base64 chunk.");
+          append(false);
+        }
+        return { read: index, bytes };
+      }
+      budget.visitNode();
+      const char = text[index++];
+      if (char === "=") {
+        if (chunk.length < 2) throw new SyntaxError("Invalid base64 padding.");
+        skipWhitespace2();
+        if (chunk.length === 2) {
+          if (index === text.length) {
+            if (mode === "stop-before-partial") return { read, bytes };
+            throw new SyntaxError("Incomplete base64 padding.");
+          }
+          if (text[index] === "=") {
+            budget.visitNode();
+            index++;
+            skipWhitespace2();
+          }
+        }
+        if (index < text.length) throw new SyntaxError("Unexpected input after base64 padding.");
+        append(mode === "strict");
+        return { read: index, bytes };
+      }
+      const digit = alphabet.indexOf(char);
+      if (digit < 0) throw new SyntaxError("Invalid base64 character.");
+      const remaining = maxLength - bytes.length;
+      if (remaining === 1 && chunk.length === 2 || remaining === 2 && chunk.length === 3) return { read, bytes };
+      chunk.push(digit);
+      if (chunk.length === 4) {
+        append(false);
+        chunk.length = 0;
+        read = index;
+        if (bytes.length === maxLength) return { read, bytes };
+      }
+    }
+  } catch (error) {
+    if (!(error instanceof SyntaxError)) throw error;
+    return { read, bytes, error };
+  }
+}
+
 // packages/safe-js/src/interp/globals/numeric-typed-array.ts
 var constructors = /* @__PURE__ */ new WeakMap();
 function createNumericTypedArrayGlobal(budget, nativePrototype = false, Native = Float32Array) {
@@ -14903,8 +15174,12 @@ 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));
+  installUint8Base64(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 +43103,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-UPTA6E3T.js.map
+//# sourceMappingURL=chunk-OTFEHCGJ.js.map