@streamlayer/web-os 0.7.4 → 0.8.0

package/lib/cjs/polyfills.js

@@ -0,0 +1,212 @@
+require('core-js/stable');
+require('regenerator-runtime/runtime');
+// TextEncoder/TextDecoder pure JS polyfill (Chrome 38)
+// The package only exports classes; must assign globals for SDK compatibility
+var _textEncoding = require('text-encoding-utf-8');
+if (typeof window.TextEncoder === 'undefined') window.TextEncoder = _textEncoding.TextEncoder;
+if (typeof window.TextDecoder === 'undefined') window.TextDecoder = _textEncoding.TextDecoder;
+require('intersection-observer'); // IntersectionObserver polyfill (Chrome 51)
+// Web Crypto SubtleCrypto polyfill (Chrome 37)
+// Chrome 32 has crypto.getRandomValues but no crypto.subtle.
+// webcrypto-liner provides a full SubtleCrypto implementation in pure JS.
+// window.crypto is a read-only accessor on many browsers, so direct assignment
+// silently fails. Instead, define/overwrite the property or patch subtle in-place.
+if (!window.crypto || !window.crypto.subtle) {
+  var _liner = require('webcrypto-liner');
+  if (window.crypto && !window.crypto.subtle) {
+    // Native crypto exists (getRandomValues) but no subtle — patch subtle in
+    Object.defineProperty(window.crypto, 'subtle', {
+      value: _liner.crypto.subtle,
+      writable: true,
+      configurable: true
+    });
+  } else {
+    // No native crypto at all — replace entirely
+    Object.defineProperty(window, 'crypto', {
+      value: _liner.crypto,
+      writable: true,
+      configurable: true
+    });
+  }
+  // CryptoKey global (Chrome 37) — used by SDK's JOSE library for instanceof checks
+  if (typeof window.CryptoKey === 'undefined') window.CryptoKey = _liner.CryptoKey;
+  // webcrypto-liner leaves AES-KW onImportKey/onExportKey/onGenerateKey as
+  // "not implemented" stubs (it expects native SubtleCrypto for these).
+  // Chrome 32 has no native SubtleCrypto, so patch them from AES-CBC provider
+  // which shares the same AesCrypto key import/export/generate logic.
+  var _subtle = _liner.crypto.subtle;
+  var _aesKw = _subtle.providers && _subtle.providers.get('AES-KW');
+  var _aesCbc = _subtle.providers && _subtle.providers.get('AES-CBC');
+  if (_aesKw && _aesCbc) {
+    _aesKw.onImportKey = _aesCbc.onImportKey;
+    _aesKw.onExportKey = _aesCbc.onExportKey;
+    _aesKw.onGenerateKey = _aesCbc.onGenerateKey;
+  }
+  // AES-KW wrap/unwrap (RFC 3394) implementation using AES-ECB from asmcrypto.js.
+  // webcrypto-liner stubs onEncrypt/onDecrypt as "not implemented" because it
+  // expects a native SubtleCrypto fallback, which Chrome 32 doesn't have.
+  var _AES_ECB = require('asmcrypto.js/asmcrypto.all.js').AES_ECB;
+  if (_aesKw && _AES_ECB) {
+    // RFC 3394 §2.2.1 — Key Wrap
+    _aesKw.onEncrypt = function(_algorithm, key, data) {
+      return Promise.resolve().then(function() {
+        var keyData = new Uint8Array(key.raw);
+        var P = new Uint8Array(data);
+        var n = P.length / 8; // number of 64-bit blocks
+        if (P.length % 8 !== 0) throw new Error('AES-KW: data must be a multiple of 8 bytes');
+        // Initial value (IV) per RFC 3394
+        var A = new Uint8Array([0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6]);
+        // R[1..n] = plaintext blocks
+        var R = [];
+        for (var i = 0; i < n; i++) {
+          R[i] = P.slice(i * 8, i * 8 + 8);
+        }
+        var ecb = new _AES_ECB(keyData);
+        var B = new Uint8Array(16);
+        for (var j = 0; j < 6; j++) {
+          for (var i = 0; i < n; i++) {
+            // B = AES(K, A | R[i])
+            B.set(A, 0);
+            B.set(R[i], 8);
+            var encrypted = ecb.encrypt(B);
+            // t = n*j + i + 1 (MSB first XOR into A)
+            var t = n * j + i + 1;
+            // A = MSB(64, B) ^ t
+            A = new Uint8Array(encrypted.slice(0, 8));
+            A[7] ^= t & 0xff;
+            A[6] ^= (t >> 8) & 0xff;
+            A[5] ^= (t >> 16) & 0xff;
+            A[4] ^= (t >> 24) & 0xff;
+            // R[i] = LSB(64, B)
+            R[i] = new Uint8Array(encrypted.slice(8, 16));
+          }
+        }
+        // Output: A | R[1] | R[2] | ... | R[n]
+        var C = new Uint8Array(8 + n * 8);
+        C.set(A, 0);
+        for (var i = 0; i < n; i++) {
+          C.set(R[i], 8 + i * 8);
+        }
+        return C.buffer;
+      });
+    };
+    // RFC 3394 §2.2.2 — Key Unwrap
+    _aesKw.onDecrypt = function(_algorithm, key, data) {
+      return Promise.resolve().then(function() {
+        var keyData = new Uint8Array(key.raw);
+        var C = new Uint8Array(data);
+        var n = C.length / 8 - 1; // number of 64-bit blocks (minus IV)
+        if (C.length % 8 !== 0) throw new Error('AES-KW: data must be a multiple of 8 bytes');
+        // A = C[0]
+        var A = C.slice(0, 8);
+        var R = [];
+        for (var i = 0; i < n; i++) {
+          R[i] = C.slice(8 + i * 8, 16 + i * 8);
+        }
+        var ecb = new _AES_ECB(keyData);
+        var B = new Uint8Array(16);
+        for (var j = 5; j >= 0; j--) {
+          for (var i = n - 1; i >= 0; i--) {
+            var t = n * j + i + 1;
+            // A ^ t
+            var Ax = new Uint8Array(A);
+            Ax[7] ^= t & 0xff;
+            Ax[6] ^= (t >> 8) & 0xff;
+            Ax[5] ^= (t >> 16) & 0xff;
+            Ax[4] ^= (t >> 24) & 0xff;
+            // B = AES-1(K, (A ^ t) | R[i])
+            B.set(Ax, 0);
+            B.set(R[i], 8);
+            var decrypted = ecb.decrypt(B);
+            A = new Uint8Array(decrypted.slice(0, 8));
+            R[i] = new Uint8Array(decrypted.slice(8, 16));
+          }
+        }
+        // Verify IV
+        var IV = [0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6, 0xA6];
+        for (var i = 0; i < 8; i++) {
+          if (A[i] !== IV[i]) throw new Error('AES-KW: integrity check failed');
+        }
+        var P = new Uint8Array(n * 8);
+        for (var i = 0; i < n; i++) {
+          P.set(R[i], i * 8);
+        }
+        return P.buffer;
+      });
+    };
+  }
+}
+// crypto.randomUUID() polyfill (Chrome 92)
+if (typeof window.crypto.randomUUID !== 'function') {
+  window.crypto.randomUUID = function() {
+    var b = new Uint8Array(16);
+    window.crypto.getRandomValues(b);
+    b[6] = (b[6] & 0x0f) | 0x40; // version 4
+    b[8] = (b[8] & 0x3f) | 0x80; // variant 10
+    var h = '';
+    for (var i = 0; i < 16; i++) {
+      if (i === 4 || i === 6 || i === 8 || i === 10) h += '-';
+      h += (b[i] < 16 ? '0' : '') + b[i].toString(16);
+    }
+    return h;
+  };
+}
+if (typeof window.ResizeObserver === 'undefined') { // ResizeObserver polyfill (Chrome 64)
+  var _RO = require('resize-observer-polyfill');
+  window.ResizeObserver = _RO.default || _RO;
+}
+var _streams = require('web-streams-polyfill');
+if (typeof window.ReadableStream === 'undefined') window.ReadableStream = _streams.ReadableStream;
+if (typeof window.WritableStream === 'undefined') window.WritableStream = _streams.WritableStream;
+if (typeof window.TransformStream === 'undefined') window.TransformStream = _streams.TransformStream;
+require('whatwg-fetch'); // fetch/Response/Headers/Request polyfill (Chrome 42)
+require('abortcontroller-polyfill/dist/polyfill-patch-fetch'); // AbortController + patched fetch (Chrome 66)
+
+// whatwg-fetch does not implement Response.body (ReadableStream).
+// ConnectRPC requires response.body to parse gRPC-Web frames.
+// Wrap fetch to synthesize .body from .arrayBuffer().
+(function() {
+  var origFetch = window.fetch;
+  window.fetch = function(input, init) {
+    return origFetch.apply(this, arguments).then(function(response) {
+      if (response.body) return response;
+      var _stream = null;
+      Object.defineProperty(response, 'body', {
+        get: function() {
+          if (!_stream) {
+            var clone = response.clone();
+            _stream = new ReadableStream({
+              start: function(controller) {
+                clone.arrayBuffer().then(function(buf) {
+                  controller.enqueue(new Uint8Array(buf));
+                  controller.close();
+                }, function(err) {
+                  controller.error(err);
+                });
+              }
+            });
+          }
+          return _stream;
+        }
+      });
+      return response;
+    });
+  };
+})();
+
+// MediaQueryList.addEventListener/removeEventListener polyfill (Chrome 50)
+// Chrome 32 only has the legacy addListener/removeListener API.
+// MediaQueryList is not exposed as a global constructor in Chrome 32,
+// so we obtain the prototype from an actual instance via matchMedia.
+if (typeof window.matchMedia === 'function') {
+  var _mql = window.matchMedia('(min-width:0)');
+  if (_mql && !_mql.addEventListener) {
+    var _mqlProto = Object.getPrototypeOf(_mql);
+    _mqlProto.addEventListener = function (type, listener) {
+      if (type === 'change') this.addListener(listener);
+    };
+    _mqlProto.removeEventListener = function (type, listener) {
+      if (type === 'change') this.removeListener(listener);
+    };
+  }
+}