akamai-edge-delivery-polyfill 1.0.0

package/dist/polyfill.global.js

@@ -0,0 +1,846 @@
+var AkamaiPolyfill = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/global.ts
+  var global_exports = {};
+  __export(global_exports, {
+    Crypto: () => Crypto,
+    Headers: () => Headers,
+    KVNamespace: () => KVNamespace,
+    Request: () => Request,
+    Response: () => Response,
+    SubtleCrypto: () => SubtleCrypto,
+    default: () => global_default,
+    installGlobalPolyfills: () => installGlobalPolyfills,
+    toEdgeWorkerResponse: () => toEdgeWorkerResponse
+  });
+
+  // src/request.ts
+  var Request = class _Request {
+    constructor(input, init) {
+      this._bodyUsed = false;
+      if (typeof input === "string") {
+        this._url = input;
+        this._method = init?.method?.toUpperCase() || "GET";
+        this._headers = new Headers(init?.headers);
+        this._body = init?.body ? this.createReadableStream(init.body) : null;
+      } else if (input instanceof _Request) {
+        this._url = input.url;
+        this._method = input.method;
+        this._headers = new Headers(input.headers);
+        this._body = input._body;
+        this.ewRequest = input.ewRequest;
+      } else {
+        this.ewRequest = input;
+        this._url = this.buildUrl(input);
+        this._method = input.method?.toUpperCase() || "GET";
+        this._headers = this.convertHeaders(input);
+        this._body = this.createBodyStream(input);
+      }
+    }
+    buildUrl(ewRequest) {
+      const scheme = ewRequest.scheme || "https";
+      const host = ewRequest.host || ewRequest.getHeader("host") || "localhost";
+      const path = ewRequest.path || "/";
+      const query = ewRequest.query || "";
+      return `${scheme}://${host}${path}${query ? "?" + query : ""}`;
+    }
+    convertHeaders(ewRequest) {
+      const headers = new Headers();
+      if (ewRequest.getHeaders) {
+        const ewHeaders = ewRequest.getHeaders();
+        for (const [name, values] of Object.entries(ewHeaders)) {
+          if (Array.isArray(values)) {
+            values.forEach((value) => headers.append(name, value));
+          } else {
+            headers.set(name, values);
+          }
+        }
+      }
+      return headers;
+    }
+    createBodyStream(ewRequest) {
+      if (!ewRequest.body) {
+        return null;
+      }
+      return new ReadableStream({
+        start(controller) {
+          if (typeof ewRequest.body === "string") {
+            controller.enqueue(new TextEncoder().encode(ewRequest.body));
+          } else if (ewRequest.body instanceof Uint8Array) {
+            controller.enqueue(ewRequest.body);
+          }
+          controller.close();
+        }
+      });
+    }
+    createReadableStream(body) {
+      return new ReadableStream({
+        start(controller) {
+          if (typeof body === "string") {
+            controller.enqueue(new TextEncoder().encode(body));
+          } else if (body instanceof Uint8Array) {
+            controller.enqueue(body);
+          } else if (body instanceof ArrayBuffer) {
+            controller.enqueue(new Uint8Array(body));
+          }
+          controller.close();
+        }
+      });
+    }
+    get url() {
+      return this._url;
+    }
+    get method() {
+      return this._method;
+    }
+    get headers() {
+      return this._headers;
+    }
+    get bodyUsed() {
+      return this._bodyUsed;
+    }
+    async text() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      this._bodyUsed = true;
+      if (!this._body) {
+        return "";
+      }
+      const reader = this._body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return new TextDecoder().decode(result);
+    }
+    async json() {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+    async arrayBuffer() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      this._bodyUsed = true;
+      if (!this._body) {
+        return new ArrayBuffer(0);
+      }
+      const reader = this._body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return result.buffer;
+    }
+    clone() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      const cloned = new _Request(this._url, {
+        method: this._method,
+        headers: this._headers
+      });
+      cloned.ewRequest = this.ewRequest;
+      return cloned;
+    }
+  };
+  var Headers = class _Headers {
+    constructor(init) {
+      this.headers = /* @__PURE__ */ new Map();
+      if (init) {
+        if (init instanceof _Headers) {
+          init.forEach((value, key) => {
+            this.append(key, value);
+          });
+        } else if (Array.isArray(init)) {
+          init.forEach(([key, value]) => {
+            this.append(key, value);
+          });
+        } else {
+          Object.entries(init).forEach(([key, value]) => {
+            this.append(key, value);
+          });
+        }
+      }
+    }
+    append(name, value) {
+      const normalizedName = name.toLowerCase();
+      const existing = this.headers.get(normalizedName) || [];
+      existing.push(value);
+      this.headers.set(normalizedName, existing);
+    }
+    delete(name) {
+      this.headers.delete(name.toLowerCase());
+    }
+    get(name) {
+      const values = this.headers.get(name.toLowerCase());
+      return values ? values[0] : null;
+    }
+    has(name) {
+      return this.headers.has(name.toLowerCase());
+    }
+    set(name, value) {
+      this.headers.set(name.toLowerCase(), [value]);
+    }
+    forEach(callback) {
+      this.headers.forEach((values, key) => {
+        values.forEach((value) => callback(value, key, this));
+      });
+    }
+    entries() {
+      const entries = [];
+      this.forEach((value, key) => {
+        entries.push([key, value]);
+      });
+      return entries[Symbol.iterator]();
+    }
+    keys() {
+      return this.headers.keys();
+    }
+    values() {
+      const values = [];
+      this.forEach((value) => {
+        values.push(value);
+      });
+      return values[Symbol.iterator]();
+    }
+    [Symbol.iterator]() {
+      return this.entries();
+    }
+  };
+
+  // src/response.ts
+  var Response = class _Response {
+    constructor(body, init) {
+      this._bodyUsed = false;
+      this._status = init?.status || 200;
+      this._statusText = init?.statusText || this.getStatusText(this._status);
+      this._headers = new Headers(init?.headers);
+      this._ok = this._status >= 200 && this._status < 300;
+      if (body !== null && body !== void 0) {
+        this._body = this.createReadableStream(body);
+      } else {
+        this._body = null;
+      }
+    }
+    getStatusText(status) {
+      const statusTexts = {
+        200: "OK",
+        201: "Created",
+        204: "No Content",
+        301: "Moved Permanently",
+        302: "Found",
+        304: "Not Modified",
+        400: "Bad Request",
+        401: "Unauthorized",
+        403: "Forbidden",
+        404: "Not Found",
+        500: "Internal Server Error",
+        502: "Bad Gateway",
+        503: "Service Unavailable"
+      };
+      return statusTexts[status] || "";
+    }
+    createReadableStream(body) {
+      return new ReadableStream({
+        start(controller) {
+          if (typeof body === "string") {
+            controller.enqueue(new TextEncoder().encode(body));
+          } else if (body instanceof Uint8Array) {
+            controller.enqueue(body);
+          } else if (body instanceof ArrayBuffer) {
+            controller.enqueue(new Uint8Array(body));
+          } else if (body instanceof ReadableStream) {
+            let push = function() {
+              reader.read().then(({ done, value }) => {
+                if (done) {
+                  controller.close();
+                  return;
+                }
+                controller.enqueue(value);
+                push();
+              });
+            };
+            const reader = body.getReader();
+            push();
+            return;
+          }
+          controller.close();
+        }
+      });
+    }
+    get body() {
+      return this._body;
+    }
+    get bodyUsed() {
+      return this._bodyUsed;
+    }
+    get ok() {
+      return this._ok;
+    }
+    get status() {
+      return this._status;
+    }
+    get statusText() {
+      return this._statusText;
+    }
+    get headers() {
+      return this._headers;
+    }
+    async text() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      this._bodyUsed = true;
+      if (!this._body) {
+        return "";
+      }
+      const reader = this._body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return new TextDecoder().decode(result);
+    }
+    async json() {
+      const text = await this.text();
+      return JSON.parse(text);
+    }
+    async arrayBuffer() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      this._bodyUsed = true;
+      if (!this._body) {
+        return new ArrayBuffer(0);
+      }
+      const reader = this._body.getReader();
+      const chunks = [];
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        chunks.push(value);
+      }
+      const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+      const result = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return result.buffer;
+    }
+    clone() {
+      if (this._bodyUsed) {
+        throw new TypeError("Body has already been consumed");
+      }
+      return new _Response(this._body, {
+        status: this._status,
+        statusText: this._statusText,
+        headers: this._headers
+      });
+    }
+    static redirect(url, status) {
+      const redirectStatus = status || 302;
+      return new _Response(null, {
+        status: redirectStatus,
+        headers: {
+          Location: url
+        }
+      });
+    }
+    static json(data, init) {
+      const body = JSON.stringify(data);
+      const headers = new Headers(init?.headers);
+      if (!headers.has("content-type")) {
+        headers.set("content-type", "application/json");
+      }
+      return new _Response(body, {
+        ...init,
+        headers
+      });
+    }
+  };
+
+  // src/kv-namespace.ts
+  var KVNamespace = class {
+    constructor(namespace, group = "default") {
+      this.namespace = namespace;
+      this.group = group;
+      try {
+        const { EdgeKV } = __require("./edgekv.js");
+        this.edgeKV = new EdgeKV({ namespace: this.namespace, group: this.group });
+      } catch (e) {
+        console.warn("EdgeKV not available, KVNamespace will not function properly");
+      }
+    }
+    async get(key, optionsOrType) {
+      if (!this.edgeKV) {
+        throw new Error("EdgeKV not initialized");
+      }
+      try {
+        const response = await this.edgeKV.getText({ item: key });
+        if (response === null || response === void 0) {
+          return null;
+        }
+        let type = "text";
+        if (typeof optionsOrType === "string") {
+          type = optionsOrType;
+        } else if (optionsOrType && "type" in optionsOrType) {
+          type = optionsOrType.type || "text";
+        }
+        switch (type) {
+          case "json":
+            return JSON.parse(response);
+          case "arrayBuffer":
+            return new TextEncoder().encode(response).buffer;
+          case "stream":
+            return new ReadableStream({
+              start(controller) {
+                controller.enqueue(new TextEncoder().encode(response));
+                controller.close();
+              }
+            });
+          case "text":
+          default:
+            return response;
+        }
+      } catch (error) {
+        if (error.status === 404 || error.message?.includes("not found")) {
+          return null;
+        }
+        throw error;
+      }
+    }
+    async getWithMetadata(key, optionsOrType) {
+      const value = await this.get(key, optionsOrType);
+      return {
+        value,
+        metadata: null
+      };
+    }
+    /**
+     * Put a value into EdgeKV (maps to Cloudflare KV put)
+     */
+    async put(key, value, options) {
+      if (!this.edgeKV) {
+        throw new Error("EdgeKV not initialized");
+      }
+      let stringValue;
+      if (typeof value === "string") {
+        stringValue = value;
+      } else if (value instanceof ArrayBuffer) {
+        stringValue = new TextDecoder().decode(value);
+      } else if (value instanceof ReadableStream) {
+        const reader = value.getReader();
+        const chunks = [];
+        while (true) {
+          const { done, value: value2 } = await reader.read();
+          if (done)
+            break;
+          chunks.push(value2);
+        }
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          result.set(chunk, offset);
+          offset += chunk.length;
+        }
+        stringValue = new TextDecoder().decode(result);
+      } else {
+        throw new TypeError("Invalid value type");
+      }
+      await this.edgeKV.putText({ item: key, value: stringValue });
+    }
+    /**
+     * Delete a value from EdgeKV (maps to Cloudflare KV delete)
+     */
+    async delete(key) {
+      if (!this.edgeKV) {
+        throw new Error("EdgeKV not initialized");
+      }
+      try {
+        await this.edgeKV.delete({ item: key });
+      } catch (error) {
+        if (error.status === 404 || error.message?.includes("not found")) {
+          return;
+        }
+        throw error;
+      }
+    }
+    /**
+     * List keys in the namespace
+     * Note: EdgeKV doesn't support listing keys, so this is a limited implementation
+     */
+    async list(options) {
+      console.warn("KVNamespace.list() is not fully supported with Akamai EdgeKV");
+      return {
+        keys: [],
+        list_complete: true,
+        cursor: void 0
+      };
+    }
+  };
+
+  // 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");
+    }
+  };
+
+  // src/index.ts
+  async function toEdgeWorkerResponse(response) {
+    const body = await response.text();
+    const headers = {};
+    response.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    return {
+      status: response.status,
+      headers,
+      body
+    };
+  }
+  function installGlobalPolyfills() {
+    const g = globalThis;
+    if (!g.Request) {
+      g.Request = Request;
+    }
+    if (!g.Response) {
+      g.Response = Response;
+    }
+    if (!g.Headers) {
+      g.Headers = Headers;
+    }
+    if (!g.crypto) {
+      g.crypto = new Crypto();
+    }
+    if (!g.TextEncoder) {
+      g.TextEncoder = class TextEncoder {
+        encode(input) {
+          const utf8 = [];
+          for (let i = 0; i < input.length; i++) {
+            let charCode = input.charCodeAt(i);
+            if (charCode < 128) {
+              utf8.push(charCode);
+            } else if (charCode < 2048) {
+              utf8.push(192 | charCode >> 6, 128 | charCode & 63);
+            } else if (charCode < 55296 || charCode >= 57344) {
+              utf8.push(224 | charCode >> 12, 128 | charCode >> 6 & 63, 128 | charCode & 63);
+            } else {
+              i++;
+              charCode = 65536 + ((charCode & 1023) << 10 | input.charCodeAt(i) & 1023);
+              utf8.push(
+                240 | charCode >> 18,
+                128 | charCode >> 12 & 63,
+                128 | charCode >> 6 & 63,
+                128 | charCode & 63
+              );
+            }
+          }
+          return new Uint8Array(utf8);
+        }
+      };
+    }
+    if (!g.TextDecoder) {
+      g.TextDecoder = class TextDecoder {
+        decode(input) {
+          const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
+          let result = "";
+          let i = 0;
+          while (i < bytes.length) {
+            const byte1 = bytes[i++];
+            if (byte1 < 128) {
+              result += String.fromCharCode(byte1);
+            } else if (byte1 < 224) {
+              const byte2 = bytes[i++];
+              result += String.fromCharCode((byte1 & 31) << 6 | byte2 & 63);
+            } else if (byte1 < 240) {
+              const byte2 = bytes[i++];
+              const byte3 = bytes[i++];
+              result += String.fromCharCode((byte1 & 15) << 12 | (byte2 & 63) << 6 | byte3 & 63);
+            } else {
+              const byte2 = bytes[i++];
+              const byte3 = bytes[i++];
+              const byte4 = bytes[i++];
+              let codePoint = (byte1 & 7) << 18 | (byte2 & 63) << 12 | (byte3 & 63) << 6 | byte4 & 63;
+              codePoint -= 65536;
+              result += String.fromCharCode(55296 + (codePoint >> 10), 56320 + (codePoint & 1023));
+            }
+          }
+          return result;
+        }
+      };
+    }
+    if (!g.ReadableStream) {
+      g.ReadableStream = class ReadableStream {
+        constructor(underlyingSource) {
+          this.started = false;
+          this.closed = false;
+          this.controller = {
+            enqueue: (chunk) => {
+              this.controller._queue = this.controller._queue || [];
+              this.controller._queue.push(chunk);
+            },
+            close: () => {
+              this.closed = true;
+            },
+            error: (e) => {
+              this.controller._error = e;
+            },
+            _queue: [],
+            _error: null
+          };
+          if (underlyingSource && underlyingSource.start) {
+            underlyingSource.start(this.controller);
+            this.started = true;
+          }
+        }
+        getReader() {
+          return {
+            read: async () => {
+              if (this.controller._error) {
+                throw this.controller._error;
+              }
+              if (this.controller._queue.length > 0) {
+                return { done: false, value: this.controller._queue.shift() };
+              }
+              if (this.closed) {
+                return { done: true, value: void 0 };
+              }
+              return { done: true, value: void 0 };
+            },
+            releaseLock: () => {
+            }
+          };
+        }
+      };
+    }
+  }
+
+  // src/global.ts
+  var global_default = {
+    Request,
+    Response,
+    Headers,
+    KVNamespace,
+    Crypto,
+    SubtleCrypto,
+    installGlobalPolyfills,
+    toEdgeWorkerResponse
+  };
+  return __toCommonJS(global_exports);
+})();
+// Auto-install polyfills when script is loaded
+if (typeof AkamaiPolyfill !== 'undefined' && AkamaiPolyfill.installGlobalPolyfills) {
+  AkamaiPolyfill.installGlobalPolyfills();
+}
+//# sourceMappingURL=polyfill.global.js.map