@ricsam/quickjs-encoding 0.0.1 → 0.2.5

package/README.md

@@ -1,45 +1,50 @@
 # @ricsam/quickjs-encoding
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/quickjs-encoding`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Base64 encoding and decoding via `atob` and `btoa`.
+
+```typescript
+import { setupEncoding } from "@ricsam/quickjs-encoding";
+
+const handle = setupEncoding(context);
+```
+
+**Injected Globals:**
+- `atob(encodedData)` - Decode a Base64-encoded string
+- `btoa(stringToEncode)` - Encode a string to Base64
+
+**Usage in QuickJS:**
+
+```javascript
+// Encode string to Base64
+const encoded = btoa("Hello, World!");
+console.log(encoded); // "SGVsbG8sIFdvcmxkIQ=="
+
+// Decode Base64 to string
+const decoded = atob("SGVsbG8sIFdvcmxkIQ==");
+console.log(decoded); // "Hello, World!"
+
+// Common use case: encoding JSON for transport
+const data = { user: "john", token: "abc123" };
+const base64Data = btoa(JSON.stringify(data));
+
+// Decode it back
+const originalData = JSON.parse(atob(base64Data));
+```
+
+**Error Handling:**
+
+```javascript
+// btoa throws for characters outside Latin1 range (0-255)
+try {
+  btoa("Hello 世界"); // Throws DOMException
+} catch (e) {
+  console.error("Cannot encode non-Latin1 characters");
+}
+
+// atob throws for invalid Base64
+try {
+  atob("not valid base64!!!");
+} catch (e) {
+  console.error("Invalid Base64 string");
+}
+```

package/dist/cjs/base64.cjs

@@ -0,0 +1,61 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/encoding/src/base64.ts
+var exports_base64 = {};
+__export(exports_base64, {
+  createBtoaFunction: () => createBtoaFunction,
+  createAtobFunction: () => createAtobFunction
+});
+module.exports = __toCommonJS(exports_base64);
+var import_quickjs_core = require("@ricsam/quickjs-core");
+function createAtobFunction(context) {
+  return import_quickjs_core.defineFunction(context, "atob", (encoded) => {
+    const str = String(encoded ?? "");
+    try {
+      return atob(str);
+    } catch {
+      throw new DOMException("The string to be decoded is not correctly encoded.", "InvalidCharacterError");
+    }
+  });
+}
+function createBtoaFunction(context) {
+  return import_quickjs_core.defineFunction(context, "btoa", (input) => {
+    const str = String(input ?? "");
+    for (let i = 0;i < str.length; i++) {
+      if (str.charCodeAt(i) > 255) {
+        throw new DOMException("The string to be encoded contains characters outside of the Latin1 range.", "InvalidCharacterError");
+      }
+    }
+    return btoa(str);
+  });
+}
+})
+
+//# debugId=89685572A9F95C3864756E2164756E21

package/dist/cjs/base64.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/base64.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport { defineFunction } from \"@ricsam/quickjs-core\";\n\n/**\n * Create the atob function for QuickJS\n *\n * Decodes a Base64-encoded string.\n *\n * @throws DOMException with \"InvalidCharacterError\" if the input is invalid Base64\n */\nexport function createAtobFunction(context: QuickJSContext): QuickJSHandle {\n  return defineFunction(context, \"atob\", (encoded: unknown) => {\n    const str = String(encoded ?? \"\");\n\n    // Validate and decode using host's atob\n    try {\n      return atob(str);\n    } catch {\n      throw new DOMException(\n        \"The string to be decoded is not correctly encoded.\",\n        \"InvalidCharacterError\"\n      );\n    }\n  });\n}\n\n/**\n * Create the btoa function for QuickJS\n *\n * Encodes a string to Base64.\n *\n * @throws DOMException with \"InvalidCharacterError\" if the string contains\n *         characters outside the Latin1 range (0-255)\n */\nexport function createBtoaFunction(context: QuickJSContext): QuickJSHandle {\n  return defineFunction(context, \"btoa\", (input: unknown) => {\n    const str = String(input ?? \"\");\n\n    // Check for characters outside Latin1 range (0-255)\n    for (let i = 0; i < str.length; i++) {\n      if (str.charCodeAt(i) > 255) {\n        throw new DOMException(\n          \"The string to be encoded contains characters outside of the Latin1 range.\",\n          \"InvalidCharacterError\"\n        );\n      }\n    }\n\n    return btoa(str);\n  });\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC+B,IAA/B;AASO,SAAS,kBAAkB,CAAC,SAAwC;AAAA,EACzE,OAAO,mCAAe,SAAS,QAAQ,CAAC,YAAqB;AAAA,IAC3D,MAAM,MAAM,OAAO,WAAW,EAAE;AAAA,IAGhC,IAAI;AAAA,MACF,OAAO,KAAK,GAAG;AAAA,MACf,MAAM;AAAA,MACN,MAAM,IAAI,aACR,sDACA,uBACF;AAAA;AAAA,GAEH;AAAA;AAWI,SAAS,kBAAkB,CAAC,SAAwC;AAAA,EACzE,OAAO,mCAAe,SAAS,QAAQ,CAAC,UAAmB;AAAA,IACzD,MAAM,MAAM,OAAO,SAAS,EAAE;AAAA,IAG9B,SAAS,IAAI,EAAG,IAAI,IAAI,QAAQ,KAAK;AAAA,MACnC,IAAI,IAAI,WAAW,CAAC,IAAI,KAAK;AAAA,QAC3B,MAAM,IAAI,aACR,6EACA,uBACF;AAAA,MACF;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,GAAG;AAAA,GAChB;AAAA;",
+  "debugId": "89685572A9F95C3864756E2164756E21",
+  "names": []
+}

package/dist/cjs/index.cjs

@@ -0,0 +1,57 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __reExport = (target, mod, secondTarget) => {
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(target, key) && key !== "default")
+      __defProp(target, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  if (secondTarget) {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(secondTarget, key) && key !== "default")
+        __defProp(secondTarget, key, {
+          get: () => mod[key],
+          enumerable: true
+        });
+    return secondTarget;
+  }
+};
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/encoding/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  setupEncoding: () => import_setup.setupEncoding
+});
+module.exports = __toCommonJS(exports_src);
+__reExport(exports_src, require("./types.cjs"), module.exports);
+var import_setup = require("./setup.cjs");
+})
+
+//# debugId=5F2EF321A5FE813364756E2164756E21

package/dist/cjs/index.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "// Re-export types\nexport * from \"./types.cjs\";\n\n// Re-export setup function\nexport { setupEncoding } from \"./setup.cjs\";\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA;AAG8B,IAA9B;",
+  "debugId": "5F2EF321A5FE813364756E2164756E21",
+  "names": []
+}

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-encoding",
+  "version": "0.2.5",
+  "type": "commonjs"
+}

package/dist/cjs/setup.cjs

@@ -0,0 +1,54 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// packages/encoding/src/setup.ts
+var exports_setup = {};
+__export(exports_setup, {
+  setupEncoding: () => setupEncoding
+});
+module.exports = __toCommonJS(exports_setup);
+var import_quickjs_core = require("@ricsam/quickjs-core");
+var import_base64 = require("./base64.cjs");
+function setupEncoding(context, options = {}) {
+  const coreHandle = options.coreHandle ?? import_quickjs_core.setupCore(context, { stateMap: options.stateMap });
+  const stateMap = options.stateMap ?? coreHandle.stateMap;
+  const atobFn = import_base64.createAtobFunction(context);
+  context.setProp(context.global, "atob", atobFn);
+  atobFn.dispose();
+  const btoaFn = import_base64.createBtoaFunction(context);
+  context.setProp(context.global, "btoa", btoaFn);
+  btoaFn.dispose();
+  return {
+    stateMap,
+    dispose() {}
+  };
+}
+})
+
+//# debugId=80C831C927BA3F9E64756E2164756E21

package/dist/cjs/setup.cjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/setup.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext } from \"quickjs-emscripten\";\nimport { setupCore, createStateMap } from \"@ricsam/quickjs-core\";\nimport type { SetupEncodingOptions, EncodingHandle } from \"./types.cjs\";\nimport { createAtobFunction, createBtoaFunction } from \"./base64.cjs\";\n\n/**\n * Setup encoding globals in a QuickJS context\n *\n * Provides: atob, btoa\n *\n * @example\n * ```typescript\n * const handle = setupEncoding(context);\n *\n * context.evalCode(`\n *   const encoded = btoa(\"Hello\");\n *   const decoded = atob(encoded);\n * `);\n *\n * handle.dispose();\n * ```\n *\n * @param context - QuickJS context\n * @param options - Setup options\n * @returns EncodingHandle for cleanup\n */\nexport function setupEncoding(\n  context: QuickJSContext,\n  options: SetupEncodingOptions = {}\n): EncodingHandle {\n  // Setup core if not provided (needed for defineFunction infrastructure)\n  const coreHandle =\n    options.coreHandle ?? setupCore(context, { stateMap: options.stateMap });\n  const stateMap = options.stateMap ?? coreHandle.stateMap;\n\n  // Create atob function\n  const atobFn = createAtobFunction(context);\n  context.setProp(context.global, \"atob\", atobFn);\n  atobFn.dispose();\n\n  // Create btoa function\n  const btoaFn = createBtoaFunction(context);\n  context.setProp(context.global, \"btoa\", btoaFn);\n  btoaFn.dispose();\n\n  return {\n    stateMap,\n    dispose() {\n      // Globals are owned by context.global, cleaned up by context.dispose()\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAC0C,IAA1C;AAEuD,IAAvD;AAuBO,SAAS,aAAa,CAC3B,SACA,UAAgC,CAAC,GACjB;AAAA,EAEhB,MAAM,aACJ,QAAQ,cAAc,8BAAU,SAAS,EAAE,UAAU,QAAQ,SAAS,CAAC;AAAA,EACzE,MAAM,WAAW,QAAQ,YAAY,WAAW;AAAA,EAGhD,MAAM,SAAS,iCAAmB,OAAO;AAAA,EACzC,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC9C,OAAO,QAAQ;AAAA,EAGf,MAAM,SAAS,iCAAmB,OAAO;AAAA,EACzC,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC9C,OAAO,QAAQ;AAAA,EAEf,OAAO;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AAAA,EAGZ;AAAA;",
+  "debugId": "80C831C927BA3F9E64756E2164756E21",
+  "names": []
+}

package/dist/cjs/types.cjs

@@ -0,0 +1,26 @@
+// @bun @bun-cjs
+(function(exports, require, module, __filename, __dirname) {var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+
+// packages/encoding/src/types.ts
+var exports_types = {};
+module.exports = __toCommonJS(exports_types);
+})
+
+//# debugId=DCCE6E4031E02C5064756E2164756E21

package/dist/cjs/types.cjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "DCCE6E4031E02C5064756E2164756E21",
+  "names": []
+}

package/dist/mjs/base64.mjs

@@ -0,0 +1,30 @@
+// @bun
+// packages/encoding/src/base64.ts
+import { defineFunction } from "@ricsam/quickjs-core";
+function createAtobFunction(context) {
+  return defineFunction(context, "atob", (encoded) => {
+    const str = String(encoded ?? "");
+    try {
+      return atob(str);
+    } catch {
+      throw new DOMException("The string to be decoded is not correctly encoded.", "InvalidCharacterError");
+    }
+  });
+}
+function createBtoaFunction(context) {
+  return defineFunction(context, "btoa", (input) => {
+    const str = String(input ?? "");
+    for (let i = 0;i < str.length; i++) {
+      if (str.charCodeAt(i) > 255) {
+        throw new DOMException("The string to be encoded contains characters outside of the Latin1 range.", "InvalidCharacterError");
+      }
+    }
+    return btoa(str);
+  });
+}
+export {
+  createBtoaFunction,
+  createAtobFunction
+};
+
+//# debugId=F0CAC86FB1CB9DD464756E2164756E21

package/dist/mjs/base64.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/base64.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext, QuickJSHandle } from \"quickjs-emscripten\";\nimport { defineFunction } from \"@ricsam/quickjs-core\";\n\n/**\n * Create the atob function for QuickJS\n *\n * Decodes a Base64-encoded string.\n *\n * @throws DOMException with \"InvalidCharacterError\" if the input is invalid Base64\n */\nexport function createAtobFunction(context: QuickJSContext): QuickJSHandle {\n  return defineFunction(context, \"atob\", (encoded: unknown) => {\n    const str = String(encoded ?? \"\");\n\n    // Validate and decode using host's atob\n    try {\n      return atob(str);\n    } catch {\n      throw new DOMException(\n        \"The string to be decoded is not correctly encoded.\",\n        \"InvalidCharacterError\"\n      );\n    }\n  });\n}\n\n/**\n * Create the btoa function for QuickJS\n *\n * Encodes a string to Base64.\n *\n * @throws DOMException with \"InvalidCharacterError\" if the string contains\n *         characters outside the Latin1 range (0-255)\n */\nexport function createBtoaFunction(context: QuickJSContext): QuickJSHandle {\n  return defineFunction(context, \"btoa\", (input: unknown) => {\n    const str = String(input ?? \"\");\n\n    // Check for characters outside Latin1 range (0-255)\n    for (let i = 0; i < str.length; i++) {\n      if (str.charCodeAt(i) > 255) {\n        throw new DOMException(\n          \"The string to be encoded contains characters outside of the Latin1 range.\",\n          \"InvalidCharacterError\"\n        );\n      }\n    }\n\n    return btoa(str);\n  });\n}\n"
+  ],
+  "mappings": ";;AACA;AASO,SAAS,kBAAkB,CAAC,SAAwC;AAAA,EACzE,OAAO,eAAe,SAAS,QAAQ,CAAC,YAAqB;AAAA,IAC3D,MAAM,MAAM,OAAO,WAAW,EAAE;AAAA,IAGhC,IAAI;AAAA,MACF,OAAO,KAAK,GAAG;AAAA,MACf,MAAM;AAAA,MACN,MAAM,IAAI,aACR,sDACA,uBACF;AAAA;AAAA,GAEH;AAAA;AAWI,SAAS,kBAAkB,CAAC,SAAwC;AAAA,EACzE,OAAO,eAAe,SAAS,QAAQ,CAAC,UAAmB;AAAA,IACzD,MAAM,MAAM,OAAO,SAAS,EAAE;AAAA,IAG9B,SAAS,IAAI,EAAG,IAAI,IAAI,QAAQ,KAAK;AAAA,MACnC,IAAI,IAAI,WAAW,CAAC,IAAI,KAAK;AAAA,QAC3B,MAAM,IAAI,aACR,6EACA,uBACF;AAAA,MACF;AAAA,IACF;AAAA,IAEA,OAAO,KAAK,GAAG;AAAA,GAChB;AAAA;",
+  "debugId": "F0CAC86FB1CB9DD464756E2164756E21",
+  "names": []
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,9 @@
+// @bun
+// packages/encoding/src/index.ts
+export * from "./types.mjs";
+import { setupEncoding } from "./setup.mjs";
+export {
+  setupEncoding
+};
+
+//# debugId=2BCBF4726489F33E64756E2164756E21

package/dist/mjs/index.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/index.ts"],
+  "sourcesContent": [
+    "// Re-export types\nexport * from \"./types.mjs\";\n\n// Re-export setup function\nexport { setupEncoding } from \"./setup.mjs\";\n"
+  ],
+  "mappings": ";;AACA;AAGA;",
+  "debugId": "2BCBF4726489F33E64756E2164756E21",
+  "names": []
+}

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/quickjs-encoding",
+  "version": "0.2.5",
+  "type": "module"
+}

package/dist/mjs/setup.mjs

@@ -0,0 +1,23 @@
+// @bun
+// packages/encoding/src/setup.ts
+import { setupCore } from "@ricsam/quickjs-core";
+import { createAtobFunction, createBtoaFunction } from "./base64.mjs";
+function setupEncoding(context, options = {}) {
+  const coreHandle = options.coreHandle ?? setupCore(context, { stateMap: options.stateMap });
+  const stateMap = options.stateMap ?? coreHandle.stateMap;
+  const atobFn = createAtobFunction(context);
+  context.setProp(context.global, "atob", atobFn);
+  atobFn.dispose();
+  const btoaFn = createBtoaFunction(context);
+  context.setProp(context.global, "btoa", btoaFn);
+  btoaFn.dispose();
+  return {
+    stateMap,
+    dispose() {}
+  };
+}
+export {
+  setupEncoding
+};
+
+//# debugId=805B838B0A7777DF64756E2164756E21

package/dist/mjs/setup.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": ["../../src/setup.ts"],
+  "sourcesContent": [
+    "import type { QuickJSContext } from \"quickjs-emscripten\";\nimport { setupCore, createStateMap } from \"@ricsam/quickjs-core\";\nimport type { SetupEncodingOptions, EncodingHandle } from \"./types.mjs\";\nimport { createAtobFunction, createBtoaFunction } from \"./base64.mjs\";\n\n/**\n * Setup encoding globals in a QuickJS context\n *\n * Provides: atob, btoa\n *\n * @example\n * ```typescript\n * const handle = setupEncoding(context);\n *\n * context.evalCode(`\n *   const encoded = btoa(\"Hello\");\n *   const decoded = atob(encoded);\n * `);\n *\n * handle.dispose();\n * ```\n *\n * @param context - QuickJS context\n * @param options - Setup options\n * @returns EncodingHandle for cleanup\n */\nexport function setupEncoding(\n  context: QuickJSContext,\n  options: SetupEncodingOptions = {}\n): EncodingHandle {\n  // Setup core if not provided (needed for defineFunction infrastructure)\n  const coreHandle =\n    options.coreHandle ?? setupCore(context, { stateMap: options.stateMap });\n  const stateMap = options.stateMap ?? coreHandle.stateMap;\n\n  // Create atob function\n  const atobFn = createAtobFunction(context);\n  context.setProp(context.global, \"atob\", atobFn);\n  atobFn.dispose();\n\n  // Create btoa function\n  const btoaFn = createBtoaFunction(context);\n  context.setProp(context.global, \"btoa\", btoaFn);\n  btoaFn.dispose();\n\n  return {\n    stateMap,\n    dispose() {\n      // Globals are owned by context.global, cleaned up by context.dispose()\n    },\n  };\n}\n"
+  ],
+  "mappings": ";;AACA;AAEA;AAuBO,SAAS,aAAa,CAC3B,SACA,UAAgC,CAAC,GACjB;AAAA,EAEhB,MAAM,aACJ,QAAQ,cAAc,UAAU,SAAS,EAAE,UAAU,QAAQ,SAAS,CAAC;AAAA,EACzE,MAAM,WAAW,QAAQ,YAAY,WAAW;AAAA,EAGhD,MAAM,SAAS,mBAAmB,OAAO;AAAA,EACzC,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC9C,OAAO,QAAQ;AAAA,EAGf,MAAM,SAAS,mBAAmB,OAAO;AAAA,EACzC,QAAQ,QAAQ,QAAQ,QAAQ,QAAQ,MAAM;AAAA,EAC9C,OAAO,QAAQ;AAAA,EAEf,OAAO;AAAA,IACL;AAAA,IACA,OAAO,GAAG;AAAA,EAGZ;AAAA;",
+  "debugId": "805B838B0A7777DF64756E2164756E21",
+  "names": []
+}

package/dist/mjs/types.mjs

@@ -0,0 +1,3 @@
+// @bun
+
+//# debugId=F59060BB582B451E64756E2164756E21

package/dist/mjs/types.mjs.map

@@ -0,0 +1,9 @@
+{
+  "version": 3,
+  "sources": [],
+  "sourcesContent": [
+  ],
+  "mappings": "",
+  "debugId": "F59060BB582B451E64756E2164756E21",
+  "names": []
+}

package/dist/types/base64.d.ts

@@ -0,0 +1,18 @@
+import type { QuickJSContext, QuickJSHandle } from "quickjs-emscripten";
+/**
+ * Create the atob function for QuickJS
+ *
+ * Decodes a Base64-encoded string.
+ *
+ * @throws DOMException with "InvalidCharacterError" if the input is invalid Base64
+ */
+export declare function createAtobFunction(context: QuickJSContext): QuickJSHandle;
+/**
+ * Create the btoa function for QuickJS
+ *
+ * Encodes a string to Base64.
+ *
+ * @throws DOMException with "InvalidCharacterError" if the string contains
+ *         characters outside the Latin1 range (0-255)
+ */
+export declare function createBtoaFunction(context: QuickJSContext): QuickJSHandle;

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types.ts";
+export { setupEncoding } from "./setup.ts";

package/dist/types/setup.d.ts

@@ -0,0 +1,24 @@
+import type { QuickJSContext } from "quickjs-emscripten";
+import type { SetupEncodingOptions, EncodingHandle } from "./types.ts";
+/**
+ * Setup encoding globals in a QuickJS context
+ *
+ * Provides: atob, btoa
+ *
+ * @example
+ * ```typescript
+ * const handle = setupEncoding(context);
+ *
+ * context.evalCode(`
+ *   const encoded = btoa("Hello");
+ *   const decoded = atob(encoded);
+ * `);
+ *
+ * handle.dispose();
+ * ```
+ *
+ * @param context - QuickJS context
+ * @param options - Setup options
+ * @returns EncodingHandle for cleanup
+ */
+export declare function setupEncoding(context: QuickJSContext, options?: SetupEncodingOptions): EncodingHandle;

package/dist/types/types.d.ts

@@ -0,0 +1,20 @@
+import type { StateMap, CoreHandle } from "@ricsam/quickjs-core";
+export type { StateMap, CoreHandle };
+/**
+ * Options for setupEncoding
+ */
+export interface SetupEncodingOptions {
+    /** Shared state map (optional, created if not provided) */
+    stateMap?: StateMap;
+    /** Existing core handle (optional, setupCore called if not provided) */
+    coreHandle?: CoreHandle;
+}
+/**
+ * Handle returned from setupEncoding
+ */
+export interface EncodingHandle {
+    /** Shared state map */
+    readonly stateMap: StateMap;
+    /** Dispose all handles and cleanup */
+    dispose(): void;
+}

package/package.json

@@ -1,10 +1,55 @@
 {
   "name": "@ricsam/quickjs-encoding",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/quickjs-encoding",
+  "version": "0.2.5",
+  "main": "./dist/cjs/index.cjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "require": "./dist/cjs/index.cjs",
+      "import": "./dist/mjs/index.mjs"
+    }
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@ricsam/quickjs-core": "^0.2.5",
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "peerDependencies": {
+    "quickjs-emscripten": "^0.31.0"
+  },
+  "author": "Richard Samuelsson",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/richie-qjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ricsam/richie-qjs/issues"
+  },
+  "homepage": "https://github.com/ricsam/richie-qjs#readme",
   "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
+    "quickjs",
+    "sandbox",
+    "javascript",
+    "runtime",
+    "fetch",
+    "filesystem",
+    "streams",
+    "wasm",
+    "emscripten"
+  ],
+  "description": "Base64 encoding APIs (atob, btoa) for QuickJS runtime",
+  "module": "./dist/mjs/index.mjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md"
   ]
-}
+}