@poe-platform/safe-js 0.1.362 → 0.1.363

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

@@ -27,7 +27,7 @@ import {
   validateMigrationSemantics,
   validateSnapshotData,
   validateSnapshotMigration
-} from "./chunk-QMF5YOGC.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-EF6FLPF6.js.map
+//# sourceMappingURL=chunk-ADA4LH5C.js.map

package/dist/safe-js/chunks/{chunk-QMF5YOGC.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";
@@ -14672,7 +14677,7 @@ function installUint8Hex(budget, constructor, prototype) {
         name: "toHex",
         length: 0,
         call: (_args, context) => {
-          const value = uint8Receiver(context?.thisValue);
+          const value = requireUint8Array(context?.thisValue);
           const { length } = typedArrayStorage(value, true);
           budget.provisionDataUsage(length * 2)();
           let result = "";
@@ -14694,7 +14699,7 @@ function installUint8Hex(budget, constructor, prototype) {
         name: "setFromHex",
         length: 1,
         call: ([text], context) => {
-          const value = uint8Receiver(context?.thisValue);
+          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);
@@ -14704,11 +14709,6 @@ function installUint8Hex(budget, constructor, prototype) {
     }
   });
 }
-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);
@@ -14728,6 +14728,187 @@ function hexNibble(code) {
   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) {
@@ -14995,6 +15176,7 @@ function createNumericTypedArrayPrototypes(budget, bindings) {
     prototypes2.set(Native, 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));
@@ -42921,4 +43103,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-QMF5YOGC.js.map
+//# sourceMappingURL=chunk-OTFEHCGJ.js.map