akamai-edge-delivery-polyfill 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Istiak Mahmod
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,320 @@
+# Akamai Edge Delivery Polyfill
+
+A comprehensive polyfill that makes Akamai EdgeWorkers compatible with Cloudflare Workers API, enabling the use of Optimizely Edge Delivery SDK and other Cloudflare-compatible libraries on Akamai's edge platform.
+
+## Features
+
+- **Request/Response API**: Full Fetch API compatibility for handling HTTP requests and responses
+- **Headers API**: Complete Headers implementation matching Web standards
+- **KVNamespace**: Maps Cloudflare KV operations to Akamai EdgeKV
+- **Crypto API**: Web Crypto API polyfill for cryptographic operations
+- **TextEncoder/TextDecoder**: Text encoding/decoding utilities
+- **ReadableStream**: Basic stream implementation for body handling
+
+## Installation
+
+```bash
+npm install akamai-edge-delivery-polyfill
+```
+
+## Building
+
+### Build the Package
+
+```bash
+# Install dependencies
+npm install
+
+# Build all bundles
+npm run build
+```
+
+This creates:
+- `dist/index.js` - ESM bundle for module imports
+- `dist/polyfill.global.js` - Global IIFE bundle that auto-installs polyfills
+- `dist/request.js`, `dist/response.js`, etc. - Individual module bundles
+- TypeScript declarations in `dist/*.d.ts`
+
+### Build Output
+
+```
+dist/
+├── index.js              # ESM bundle (main)
+├── polyfill.global.js    # Global bundle (auto-installs APIs)
+├── request.js            # Individual modules
+├── response.js
+├── kv-namespace.js
+├── crypto.js
+└── *.d.ts                # TypeScript declarations
+```
+
+## Usage
+
+### Option 1: Global Bundle (Easiest - Recommended)
+
+The global bundle automatically installs all polyfills when loaded, making them available globally.
+
+```typescript
+// Import the global bundle first (auto-installs all APIs)
+import './node_modules/akamai-edge-delivery-polyfill/dist/polyfill.global.js';
+
+// Now Request, Response, Headers, crypto, etc. are global
+export async function onClientRequest(request) {
+  const cfRequest = new Request(request);
+
+  const response = Response.json({
+    message: 'Hello from Akamai!',
+    url: cfRequest.url
+  });
+
+  return {
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: await response.text()
+  };
+}
+```
+
+### Option 2: ES Modules
+
+Use the ESM bundle for module imports:
+
+```typescript
+import { Request, Response, installGlobalPolyfills } from 'akamai-edge-delivery-polyfill';
+
+// Use classes directly
+export async function onClientRequest(request) {
+  const cfRequest = new Request(request);
+
+  const response = new Response(JSON.stringify({ message: 'Hello from Akamai!' }), {
+    status: 200,
+    headers: {
+      'Content-Type': 'application/json'
+    }
+  });
+
+  return {
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: await response.text()
+  };
+}
+
+// Option 2: Install global polyfills (useful for libraries expecting global APIs)
+installGlobalPolyfills();
+```
+
+### Using with Optimizely Edge Delivery SDK
+
+```typescript
+import { installGlobalPolyfills, KVNamespace } from 'akamai-edge-delivery-polyfill';
+import { createInstance } from '@optimizely/edge-delivery-sdk';
+
+// Install global polyfills for Optimizely SDK compatibility
+installGlobalPolyfills();
+
+// Create KV namespace for Optimizely data
+const optimizelyKV = new KVNamespace('optimizely', 'config');
+
+// Initialize Optimizely
+const optimizely = createInstance({
+  sdkKey: 'your-sdk-key',
+  // ... other config
+});
+
+export async function onClientRequest(request) {
+  const cfRequest = new Request(request);
+
+  // Use Optimizely for decision making
+  const user = {
+    id: cfRequest.headers.get('user-id') || 'anonymous',
+  };
+
+  const decision = optimizely.decide(user, 'feature-flag-key');
+
+  // Return personalized response
+  const response = new Response(JSON.stringify({
+    enabled: decision.enabled,
+    variables: decision.variables,
+  }), {
+    status: 200,
+    headers: { 'Content-Type': 'application/json' }
+  });
+
+  return {
+    status: response.status,
+    headers: Object.fromEntries(response.headers.entries()),
+    body: await response.text()
+  };
+}
+```
+
+### KVNamespace (EdgeKV Integration)
+
+```typescript
+import { KVNamespace } from 'akamai-edge-delivery-polyfill';
+
+// Create a KV namespace (maps to Akamai EdgeKV)
+const myKV = new KVNamespace('my-namespace', 'production');
+
+// Get a value
+const value = await myKV.get('key');
+const jsonValue = await myKV.get('key', 'json');
+
+// Put a value
+await myKV.put('key', 'value');
+await myKV.put('key', JSON.stringify({ data: 'value' }));
+
+// Delete a value
+await myKV.delete('key');
+```
+
+### Crypto API
+
+```typescript
+import { Crypto } from 'akamai-edge-delivery-polyfill';
+
+const crypto = new Crypto();
+
+// Generate random UUID
+const uuid = crypto.randomUUID();
+
+// Generate random values
+const array = new Uint8Array(16);
+crypto.getRandomValues(array);
+
+// Use SubtleCrypto for hashing (if supported by runtime)
+const data = new TextEncoder().encode('Hello World');
+const hash = await crypto.subtle.digest('SHA-256', data);
+```
+
+### Helper Functions
+
+```typescript
+import { toEdgeWorkerResponse } from 'akamai-edge-delivery-polyfill';
+
+// Convert Cloudflare-style Response to Akamai EdgeWorker format
+const cfResponse = new Response('Hello', { status: 200 });
+const ewResponse = await toEdgeWorkerResponse(cfResponse);
+
+// Returns: { status: 200, headers: {...}, body: 'Hello' }
+```
+
+## API Reference
+
+### Request
+
+Wraps Akamai EdgeWorker requests to provide Cloudflare-compatible Request interface.
+
+**Constructor:**
+```typescript
+new Request(input: string | Request | AkamaiRequest, init?: RequestInit)
+```
+
+**Properties:**
+- `url: string` - The request URL
+- `method: string` - HTTP method
+- `headers: Headers` - Request headers
+- `bodyUsed: boolean` - Whether body has been consumed
+
+**Methods:**
+- `text(): Promise<string>` - Read body as text
+- `json(): Promise<any>` - Read body as JSON
+- `arrayBuffer(): Promise<ArrayBuffer>` - Read body as ArrayBuffer
+- `clone(): Request` - Clone the request
+
+### Response
+
+Creates Cloudflare-compatible Response objects.
+
+**Constructor:**
+```typescript
+new Response(body?: BodyInit | null, init?: ResponseInit)
+```
+
+**Properties:**
+- `status: number` - HTTP status code
+- `statusText: string` - HTTP status text
+- `ok: boolean` - True if status is 2xx
+- `headers: Headers` - Response headers
+- `body: ReadableStream | null` - Response body stream
+- `bodyUsed: boolean` - Whether body has been consumed
+
+**Methods:**
+- `text(): Promise<string>` - Read body as text
+- `json(): Promise<any>` - Read body as JSON
+- `arrayBuffer(): Promise<ArrayBuffer>` - Read body as ArrayBuffer
+- `clone(): Response` - Clone the response
+
+**Static Methods:**
+- `Response.json(data: any, init?: ResponseInit): Response` - Create JSON response
+- `Response.redirect(url: string, status?: number): Response` - Create redirect response
+
+### KVNamespace
+
+Maps Cloudflare KV operations to Akamai EdgeKV.
+
+**Constructor:**
+```typescript
+new KVNamespace(namespace: string, group?: string)
+```
+
+**Methods:**
+- `get(key: string, type?: 'text' | 'json' | 'arrayBuffer' | 'stream'): Promise<any>` - Get value
+- `getWithMetadata<T>(key: string, type?): Promise<{ value: any, metadata: T }>` - Get with metadata
+- `put(key: string, value: string | ArrayBuffer | ReadableStream): Promise<void>` - Put value
+- `delete(key: string): Promise<void>` - Delete value
+- `list(options?: KVListOptions): Promise<KVListResult>` - List keys (limited support)
+
+### Crypto
+
+Web Crypto API polyfill.
+
+**Methods:**
+- `getRandomValues<T extends ArrayBufferView>(array: T): T` - Fill array with random values
+- `randomUUID(): string` - Generate random UUID
+- `subtle: SubtleCrypto` - Access SubtleCrypto API
+
+## Important Notes
+
+### EdgeKV Setup
+
+To use `KVNamespace`, you need to have Akamai EdgeKV configured and the `edgekv.js` helper library available in your EdgeWorker bundle. The polyfill expects to require it as:
+
+```javascript
+const { EdgeKV } = require('./edgekv.js');
+```
+
+### Limitations
+
+1. **KVNamespace.list()**: EdgeKV doesn't natively support listing keys, so this method has limited functionality
+2. **ReadableStream**: Basic implementation provided; may not support all stream features
+3. **Crypto.subtle**: Some operations may not be available depending on Akamai runtime capabilities
+
+### TypeScript Support
+
+The polyfill includes full TypeScript definitions. No additional `@types` packages needed.
+
+## Examples
+
+See the `examples/` directory for complete working examples:
+
+- `basic-usage.ts` - Basic request/response handling
+- `optimizely-integration.ts` - Using with Optimizely Edge Delivery SDK
+- `kv-storage.ts` - EdgeKV integration examples
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a pull request.
+
+## Support
+
+For issues specific to this polyfill, please open a GitHub issue.
+
+For Akamai EdgeWorkers support, see [Akamai EdgeWorkers documentation](https://techdocs.akamai.com/edgeworkers/docs)
+
+For Optimizely Edge Delivery SDK support, see [Optimizely documentation](https://docs.developers.optimizely.com/)

package/dist/crypto.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Crypto polyfill for Akamai EdgeWorkers to match Cloudflare Workers Web Crypto API
+ * Provides a subset of the Web Crypto API using Akamai's crypto module
+ */
+export declare class Crypto {
+    /**
+     * Generate cryptographically strong random values
+     */
+    getRandomValues<T extends ArrayBufferView>(array: T): T;
+    /**
+     * Generate a random UUID
+     */
+    randomUUID(): string;
+    /**
+     * SubtleCrypto API for cryptographic operations
+     */
+    get subtle(): SubtleCrypto;
+}
+export declare class SubtleCrypto {
+    /**
+     * Generate a digest (hash) of the data
+     */
+    digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer>;
+    /**
+     * Sign data with a key
+     */
+    sign(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+    /**
+     * Verify a signature
+     */
+    verify(algorithm: AlgorithmIdentifier, key: CryptoKey, signature: BufferSource, data: BufferSource): Promise<boolean>;
+    /**
+     * Encrypt data
+     */
+    encrypt(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+    /**
+     * Decrypt data
+     */
+    decrypt(algorithm: AlgorithmIdentifier, key: CryptoKey, data: BufferSource): Promise<ArrayBuffer>;
+    /**
+     * Generate a key
+     */
+    generateKey(algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey | CryptoKeyPair>;
+    /**
+     * Derive bits from a key
+     */
+    deriveBits(algorithm: AlgorithmIdentifier, baseKey: CryptoKey, length: number): Promise<ArrayBuffer>;
+    /**
+     * Derive a key from another key
+     */
+    deriveKey(algorithm: AlgorithmIdentifier, baseKey: CryptoKey, derivedKeyAlgorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    /**
+     * Import a key
+     */
+    importKey(format: KeyFormat, keyData: BufferSource | JsonWebKey, algorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+    /**
+     * Export a key
+     */
+    exportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
+    /**
+     * Wrap a key
+     */
+    wrapKey(format: KeyFormat, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: AlgorithmIdentifier): Promise<ArrayBuffer>;
+    /**
+     * Unwrap a key
+     */
+    unwrapKey(format: KeyFormat, wrappedKey: BufferSource, unwrappingKey: CryptoKey, unwrapAlgorithm: AlgorithmIdentifier, unwrappedKeyAlgorithm: AlgorithmIdentifier, extractable: boolean, keyUsages: KeyUsage[]): Promise<CryptoKey>;
+}
+//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../src/crypto.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,qBAAa,MAAM;IACjB;;OAEG;IACH,eAAe,CAAC,CAAC,SAAS,eAAe,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC;IAgBvD;;OAEG;IACH,UAAU,IAAI,MAAM;IAqBpB;;OAEG;IACH,IAAI,MAAM,IAAI,YAAY,CAEzB;CACF;AAED,qBAAa,YAAY;IACvB;;OAEG;IACG,MAAM,CAAC,SAAS,EAAE,mBAAmB,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,WAAW,CAAC;IActF;;OAEG;IACG,IAAI,CACR,SAAS,EAAE,mBAAmB,EAC9B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,WAAW,CAAC;IAUvB;;OAEG;IACG,MAAM,CACV,SAAS,EAAE,mBAAmB,EAC9B,GAAG,EAAE,SAAS,EACd,SAAS,EAAE,YAAY,EACvB,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,OAAO,CAAC;IAUnB;;OAEG;IACG,OAAO,CACX,SAAS,EAAE,mBAAmB,EAC9B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,WAAW,CAAC;IAUvB;;OAEG;IACG,OAAO,CACX,SAAS,EAAE,mBAAmB,EAC9B,GAAG,EAAE,SAAS,EACd,IAAI,EAAE,YAAY,GACjB,OAAO,CAAC,WAAW,CAAC;IAUvB;;OAEG;IACG,WAAW,CACf,SAAS,EAAE,mBAAmB,EAC9B,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,SAAS,GAAG,aAAa,CAAC;IAUrC;;OAEG;IACG,UAAU,CACd,SAAS,EAAE,mBAAmB,EAC9B,OAAO,EAAE,SAAS,EAClB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,WAAW,CAAC;IAUvB;;OAEG;IACG,SAAS,CACb,SAAS,EAAE,mBAAmB,EAC9B,OAAO,EAAE,SAAS,EAClB,mBAAmB,EAAE,mBAAmB,EACxC,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,SAAS,CAAC;IAUrB;;OAEG;IACG,SAAS,CACb,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,YAAY,GAAG,UAAU,EAClC,SAAS,EAAE,mBAAmB,EAC9B,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,SAAS,CAAC;IAUrB;;OAEG;IACG,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,WAAW,GAAG,UAAU,CAAC;IAUrF;;OAEG;IACG,OAAO,CACX,MAAM,EAAE,SAAS,EACjB,GAAG,EAAE,SAAS,EACd,WAAW,EAAE,SAAS,EACtB,aAAa,EAAE,mBAAmB,GACjC,OAAO,CAAC,WAAW,CAAC;IAUvB;;OAEG;IACG,SAAS,CACb,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,YAAY,EACxB,aAAa,EAAE,SAAS,EACxB,eAAe,EAAE,mBAAmB,EACpC,qBAAqB,EAAE,mBAAmB,EAC1C,WAAW,EAAE,OAAO,EACpB,SAAS,EAAE,QAAQ,EAAE,GACpB,OAAO,CAAC,SAAS,CAAC;CAiBtB"}

package/dist/crypto.js

@@ -0,0 +1,161 @@
+// src/crypto.ts
+var Crypto = class {
+  /**
+   * Generate cryptographically strong random values
+   */
+  getRandomValues(array) {
+    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+      return crypto.getRandomValues(array);
+    }
+    console.warn("Using fallback random number generation - not cryptographically secure");
+    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return array;
+  }
+  /**
+   * Generate a random UUID
+   */
+  randomUUID() {
+    if (typeof crypto !== "undefined" && crypto.randomUUID) {
+      return crypto.randomUUID();
+    }
+    const bytes = new Uint8Array(16);
+    this.getRandomValues(bytes);
+    bytes[6] = bytes[6] & 15 | 64;
+    bytes[8] = bytes[8] & 63 | 128;
+    const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+  }
+  /**
+   * SubtleCrypto API for cryptographic operations
+   */
+  get subtle() {
+    return new SubtleCrypto();
+  }
+};
+var SubtleCrypto = class {
+  /**
+   * Generate a digest (hash) of the data
+   */
+  async digest(algorithm, data) {
+    const algName = typeof algorithm === "string" ? algorithm : algorithm.name;
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.digest) {
+      return crypto.subtle.digest(algorithm, data);
+    }
+    throw new Error(`Digest algorithm ${algName} not supported in this environment`);
+  }
+  /**
+   * Sign data with a key
+   */
+  async sign(algorithm, key, data) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.sign) {
+      return crypto.subtle.sign(algorithm, key, data);
+    }
+    throw new Error("Sign operation not supported in this environment");
+  }
+  /**
+   * Verify a signature
+   */
+  async verify(algorithm, key, signature, data) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.verify) {
+      return crypto.subtle.verify(algorithm, key, signature, data);
+    }
+    throw new Error("Verify operation not supported in this environment");
+  }
+  /**
+   * Encrypt data
+   */
+  async encrypt(algorithm, key, data) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.encrypt) {
+      return crypto.subtle.encrypt(algorithm, key, data);
+    }
+    throw new Error("Encrypt operation not supported in this environment");
+  }
+  /**
+   * Decrypt data
+   */
+  async decrypt(algorithm, key, data) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.decrypt) {
+      return crypto.subtle.decrypt(algorithm, key, data);
+    }
+    throw new Error("Decrypt operation not supported in this environment");
+  }
+  /**
+   * Generate a key
+   */
+  async generateKey(algorithm, extractable, keyUsages) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.generateKey) {
+      return crypto.subtle.generateKey(algorithm, extractable, keyUsages);
+    }
+    throw new Error("GenerateKey operation not supported in this environment");
+  }
+  /**
+   * Derive bits from a key
+   */
+  async deriveBits(algorithm, baseKey, length) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.deriveBits) {
+      return crypto.subtle.deriveBits(algorithm, baseKey, length);
+    }
+    throw new Error("DeriveBits operation not supported in this environment");
+  }
+  /**
+   * Derive a key from another key
+   */
+  async deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.deriveKey) {
+      return crypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages);
+    }
+    throw new Error("DeriveKey operation not supported in this environment");
+  }
+  /**
+   * Import a key
+   */
+  async importKey(format, keyData, algorithm, extractable, keyUsages) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.importKey) {
+      return crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages);
+    }
+    throw new Error("ImportKey operation not supported in this environment");
+  }
+  /**
+   * Export a key
+   */
+  async exportKey(format, key) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.exportKey) {
+      return crypto.subtle.exportKey(format, key);
+    }
+    throw new Error("ExportKey operation not supported in this environment");
+  }
+  /**
+   * Wrap a key
+   */
+  async wrapKey(format, key, wrappingKey, wrapAlgorithm) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.wrapKey) {
+      return crypto.subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm);
+    }
+    throw new Error("WrapKey operation not supported in this environment");
+  }
+  /**
+   * Unwrap a key
+   */
+  async unwrapKey(format, wrappedKey, unwrappingKey, unwrapAlgorithm, unwrappedKeyAlgorithm, extractable, keyUsages) {
+    if (typeof crypto !== "undefined" && crypto.subtle && crypto.subtle.unwrapKey) {
+      return crypto.subtle.unwrapKey(
+        format,
+        wrappedKey,
+        unwrappingKey,
+        unwrapAlgorithm,
+        unwrappedKeyAlgorithm,
+        extractable,
+        keyUsages
+      );
+    }
+    throw new Error("UnwrapKey operation not supported in this environment");
+  }
+};
+export {
+  Crypto,
+  SubtleCrypto
+};
+//# sourceMappingURL=crypto.js.map

package/dist/crypto.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/crypto.ts"],
+  "sourcesContent": ["/**\n * Crypto polyfill for Akamai EdgeWorkers to match Cloudflare Workers Web Crypto API\n * Provides a subset of the Web Crypto API using Akamai's crypto module\n */\n\nexport class Crypto {\n  /**\n   * Generate cryptographically strong random values\n   */\n  getRandomValues<T extends ArrayBufferView>(array: T): T {\n    // In Akamai EdgeWorkers, we can use the crypto module\n    // @ts-ignore - crypto is available in Akamai runtime\n    if (typeof crypto !== 'undefined' && crypto.getRandomValues) {\n      return crypto.getRandomValues(array);\n    }\n\n    // Fallback implementation (not cryptographically secure, for development only)\n    console.warn('Using fallback random number generation - not cryptographically secure');\n    const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);\n    for (let i = 0; i < bytes.length; i++) {\n      bytes[i] = Math.floor(Math.random() * 256);\n    }\n    return array;\n  }\n\n  /**\n   * Generate a random UUID\n   */\n  randomUUID(): string {\n    // @ts-ignore - crypto is available in Akamai runtime\n    if (typeof crypto !== 'undefined' && crypto.randomUUID) {\n      return crypto.randomUUID();\n    }\n\n    // Fallback UUID v4 generation\n    const bytes = new Uint8Array(16);\n    this.getRandomValues(bytes);\n\n    // Set version (4) and variant bits\n    bytes[6] = (bytes[6] & 0x0f) | 0x40;\n    bytes[8] = (bytes[8] & 0x3f) | 0x80;\n\n    const hex = Array.from(bytes)\n      .map(b => b.toString(16).padStart(2, '0'))\n      .join('');\n\n    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n  }\n\n  /**\n   * SubtleCrypto API for cryptographic operations\n   */\n  get subtle(): SubtleCrypto {\n    return new SubtleCrypto();\n  }\n}\n\nexport class SubtleCrypto {\n  /**\n   * Generate a digest (hash) of the data\n   */\n  async digest(algorithm: AlgorithmIdentifier, data: BufferSource): Promise<ArrayBuffer> {\n    const algName = typeof algorithm === 'string' ? algorithm : algorithm.name;\n\n    // @ts-ignore - crypto is available in Akamai runtime\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.digest) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.digest(algorithm, data);\n    }\n\n    // For Akamai EdgeWorkers without native crypto.subtle\n    // You would need to use the crypto module's createHash or similar\n    throw new Error(`Digest algorithm ${algName} not supported in this environment`);\n  }\n\n  /**\n   * Sign data with a key\n   */\n  async sign(\n    algorithm: AlgorithmIdentifier,\n    key: CryptoKey,\n    data: BufferSource\n  ): Promise<ArrayBuffer> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.sign) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.sign(algorithm, key, data);\n    }\n\n    throw new Error('Sign operation not supported in this environment');\n  }\n\n  /**\n   * Verify a signature\n   */\n  async verify(\n    algorithm: AlgorithmIdentifier,\n    key: CryptoKey,\n    signature: BufferSource,\n    data: BufferSource\n  ): Promise<boolean> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.verify) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.verify(algorithm, key, signature, data);\n    }\n\n    throw new Error('Verify operation not supported in this environment');\n  }\n\n  /**\n   * Encrypt data\n   */\n  async encrypt(\n    algorithm: AlgorithmIdentifier,\n    key: CryptoKey,\n    data: BufferSource\n  ): Promise<ArrayBuffer> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.encrypt) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.encrypt(algorithm, key, data);\n    }\n\n    throw new Error('Encrypt operation not supported in this environment');\n  }\n\n  /**\n   * Decrypt data\n   */\n  async decrypt(\n    algorithm: AlgorithmIdentifier,\n    key: CryptoKey,\n    data: BufferSource\n  ): Promise<ArrayBuffer> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.decrypt) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.decrypt(algorithm, key, data);\n    }\n\n    throw new Error('Decrypt operation not supported in this environment');\n  }\n\n  /**\n   * Generate a key\n   */\n  async generateKey(\n    algorithm: AlgorithmIdentifier,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CryptoKey | CryptoKeyPair> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.generateKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.generateKey(algorithm, extractable, keyUsages);\n    }\n\n    throw new Error('GenerateKey operation not supported in this environment');\n  }\n\n  /**\n   * Derive bits from a key\n   */\n  async deriveBits(\n    algorithm: AlgorithmIdentifier,\n    baseKey: CryptoKey,\n    length: number\n  ): Promise<ArrayBuffer> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.deriveBits) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.deriveBits(algorithm, baseKey, length);\n    }\n\n    throw new Error('DeriveBits operation not supported in this environment');\n  }\n\n  /**\n   * Derive a key from another key\n   */\n  async deriveKey(\n    algorithm: AlgorithmIdentifier,\n    baseKey: CryptoKey,\n    derivedKeyAlgorithm: AlgorithmIdentifier,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CryptoKey> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.deriveKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages);\n    }\n\n    throw new Error('DeriveKey operation not supported in this environment');\n  }\n\n  /**\n   * Import a key\n   */\n  async importKey(\n    format: KeyFormat,\n    keyData: BufferSource | JsonWebKey,\n    algorithm: AlgorithmIdentifier,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CryptoKey> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.importKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.importKey(format, keyData, algorithm, extractable, keyUsages);\n    }\n\n    throw new Error('ImportKey operation not supported in this environment');\n  }\n\n  /**\n   * Export a key\n   */\n  async exportKey(format: KeyFormat, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.exportKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.exportKey(format, key);\n    }\n\n    throw new Error('ExportKey operation not supported in this environment');\n  }\n\n  /**\n   * Wrap a key\n   */\n  async wrapKey(\n    format: KeyFormat,\n    key: CryptoKey,\n    wrappingKey: CryptoKey,\n    wrapAlgorithm: AlgorithmIdentifier\n  ): Promise<ArrayBuffer> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.wrapKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.wrapKey(format, key, wrappingKey, wrapAlgorithm);\n    }\n\n    throw new Error('WrapKey operation not supported in this environment');\n  }\n\n  /**\n   * Unwrap a key\n   */\n  async unwrapKey(\n    format: KeyFormat,\n    wrappedKey: BufferSource,\n    unwrappingKey: CryptoKey,\n    unwrapAlgorithm: AlgorithmIdentifier,\n    unwrappedKeyAlgorithm: AlgorithmIdentifier,\n    extractable: boolean,\n    keyUsages: KeyUsage[]\n  ): Promise<CryptoKey> {\n    // @ts-ignore\n    if (typeof crypto !== 'undefined' && crypto.subtle && crypto.subtle.unwrapKey) {\n      // @ts-ignore - type compatibility with native crypto\n      return crypto.subtle.unwrapKey(\n        format,\n        wrappedKey,\n        unwrappingKey,\n        unwrapAlgorithm,\n        unwrappedKeyAlgorithm,\n        extractable,\n        keyUsages\n      );\n    }\n\n    throw new Error('UnwrapKey operation not supported in this environment');\n  }\n}\n\n// Type definitions are provided by lib.dom.d.ts\n// We don't need to redefine them here since tsconfig includes \"DOM\" lib\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/global.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Global entry point - exposes all polyfills as global variables
+ * This file is used for the IIFE build that automatically installs polyfills
+ */
+import { Request, Headers } from './request';
+import { Response } from './response';
+import { KVNamespace } from './kv-namespace';
+import { Crypto, SubtleCrypto } from './crypto';
+import { installGlobalPolyfills, toEdgeWorkerResponse } from './index';
+export { Request, Response, Headers, KVNamespace, Crypto, SubtleCrypto, installGlobalPolyfills, toEdgeWorkerResponse, };
+declare const _default: {
+    Request: typeof Request;
+    Response: typeof Response;
+    Headers: typeof Headers;
+    KVNamespace: typeof KVNamespace;
+    Crypto: typeof Crypto;
+    SubtleCrypto: typeof SubtleCrypto;
+    installGlobalPolyfills: typeof installGlobalPolyfills;
+    toEdgeWorkerResponse: typeof toEdgeWorkerResponse;
+};
+export default _default;
+//# sourceMappingURL=global.d.ts.map

package/dist/global.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.d.ts","sourceRoot":"","sources":["../src/global.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAChD,OAAO,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAGvE,OAAO,EACL,OAAO,EACP,QAAQ,EACR,OAAO,EACP,WAAW,EACX,MAAM,EACN,YAAY,EACZ,sBAAsB,EACtB,oBAAoB,GACrB,CAAC;;;;;;;;;;;AAGF,wBASE"}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Akamai EdgeWorkers to Cloudflare Workers API Polyfill
+ *
+ * This polyfill makes Akamai EdgeWorkers compatible with Cloudflare Workers API,
+ * enabling the use of Optimizely Edge Delivery SDK and other Cloudflare-compatible
+ * libraries on Akamai's edge platform.
+ *
+ * @example
+ * ```typescript
+ * import { Request, Response, KVNamespace, Crypto } from 'akamai-edge-delivery-polyfill';
+ *
+ * // Use in your EdgeWorker
+ * export async function onClientRequest(request) {
+ *   const cfRequest = new Request(request);
+ *   const response = new Response('Hello World', { status: 200 });
+ *   return response;
+ * }
+ * ```
+ */
+import { Request, Headers } from './request';
+import { Response } from './response';
+import { KVNamespace } from './kv-namespace';
+import { Crypto, SubtleCrypto } from './crypto';
+export { Request, Headers } from './request';
+export { Response } from './response';
+export { KVNamespace } from './kv-namespace';
+export { Crypto, SubtleCrypto } from './crypto';
+/**
+ * Helper function to convert Akamai EdgeWorker Response to a format
+ * that can be returned from EdgeWorker event handlers
+ */
+export declare function toEdgeWorkerResponse(response: any): Promise<any>;
+/**
+ * Create a global polyfill that injects Cloudflare-compatible APIs into the global scope
+ * This is useful when using libraries that expect these APIs to be globally available
+ */
+export declare function installGlobalPolyfills(): void;
+declare const _default: {
+    Request: typeof Request;
+    Response: typeof Response;
+    Headers: typeof Headers;
+    KVNamespace: typeof KVNamespace;
+    Crypto: typeof Crypto;
+    SubtleCrypto: typeof SubtleCrypto;
+    toEdgeWorkerResponse: typeof toEdgeWorkerResponse;
+    installGlobalPolyfills: typeof installGlobalPolyfills;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map