akamai-edge-delivery-polyfill 1.0.0

package/dist/index.js

@@ -0,0 +1,817 @@
+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');
+});
+
+// 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: () => {
+          }
+        };
+      }
+    };
+  }
+}
+var src_default = {
+  Request,
+  Response,
+  Headers,
+  KVNamespace,
+  Crypto,
+  SubtleCrypto,
+  toEdgeWorkerResponse,
+  installGlobalPolyfills
+};
+export {
+  Crypto,
+  Headers,
+  KVNamespace,
+  Request,
+  Response,
+  SubtleCrypto,
+  src_default as default,
+  installGlobalPolyfills,
+  toEdgeWorkerResponse
+};
+//# sourceMappingURL=index.js.map