@supraio/client-daemon-js 0.0.0-mznacl.256 → 0.0.0-mznacl.262

package/screen.js

@@ -17069,6 +17069,637 @@
     exports.encode = exports.stringify = require_encode();
   });
 
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageListeners.js
+  var require_messageListeners = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.createMessageListeners = createMessageListeners;
+    function createMessageListeners() {
+      var messageListeners = new Set();
+      return messageListeners;
+    }
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageConvertor.js
+  var require_messageConvertor = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.convertMessageToArrayBuffer = convertMessageToArrayBuffer;
+    exports.convertArrayBufferToMessage = convertArrayBufferToMessage;
+    function convertMessageToArrayBuffer(message) {
+      var _a, _b;
+      var arrayBuffer = new ArrayBuffer(1 + ((_b = (_a = message.payload) === null || _a === void 0 ? void 0 : _a.byteLength) !== null && _b !== void 0 ? _b : 0));
+      var uint8Array = new Uint8Array(arrayBuffer);
+      uint8Array[0] = message.type;
+      if (message.payload) {
+        uint8Array.set(new Uint8Array(message.payload), 1);
+      }
+      return arrayBuffer;
+    }
+    function convertArrayBufferToMessage(arrayBuffer) {
+      var uint8Array = new Uint8Array(arrayBuffer);
+      var type = uint8Array[0];
+      var payload = arrayBuffer.slice(1);
+      return {type, payload};
+    }
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageReceiver.js
+  var require_messageReceiver = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.MessageReceiver = void 0;
+    var messageConvertor_1 = require_messageConvertor();
+    var MessageReceiver = function() {
+      function MessageReceiver2(messageListeners) {
+        this.messageListeners = messageListeners;
+      }
+      MessageReceiver2.prototype.handleMessage = function(event) {
+        if (!(event.data instanceof ArrayBuffer)) {
+          throw new Error("Unexpected message data type. Only ArrayBuffer is supported.");
+        }
+        var message = (0, messageConvertor_1.convertArrayBufferToMessage)(event.data);
+        this.messageListeners.forEach(function(listener) {
+          return listener(message);
+        });
+      };
+      return MessageReceiver2;
+    }();
+    exports.MessageReceiver = MessageReceiver;
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messageSender.js
+  var require_messageSender = __commonJS((exports) => {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = {label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: []}, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return {value: op[1], done: false};
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return {value: op[0] ? op[1] : void 0, done: true};
+      }
+    };
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.MessageSender = void 0;
+    var messageConvertor_1 = require_messageConvertor();
+    var MessageSender = function() {
+      function MessageSender2(naclModuleEl, messageListeners) {
+        this.naclModuleEl = naclModuleEl;
+        this.messageListeners = messageListeners;
+      }
+      MessageSender2.prototype.sendWithoutResult = function(message) {
+        this.naclModuleEl.postMessage((0, messageConvertor_1.convertMessageToArrayBuffer)(message));
+      };
+      MessageSender2.prototype.sendWithResult = function(message, resultMessageType) {
+        return __awaiter(this, void 0, void 0, function() {
+          var arrayBuffer;
+          var _this = this;
+          return __generator(this, function(_a) {
+            arrayBuffer = (0, messageConvertor_1.convertMessageToArrayBuffer)(message);
+            return [2, new Promise(function(resolve) {
+              var listener = function(message2) {
+                if (message2.type !== resultMessageType) {
+                  return;
+                }
+                _this.messageListeners.delete(listener);
+                resolve(message2);
+              };
+              _this.messageListeners.add(listener);
+              _this.naclModuleEl.postMessage(arrayBuffer);
+            })];
+          });
+        });
+      };
+      return MessageSender2;
+    }();
+    exports.MessageSender = MessageSender;
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/module.js
+  var require_module = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.createNaClModule = createNaClModule;
+    function handleLoad(event) {
+      console.log("nacl load", event);
+    }
+    function handleCrash(event) {
+      console.log("nacl crash", event);
+    }
+    function createNaClModule(handleMessage) {
+      var _a, _b;
+      var listenerEl = document.createElement("div");
+      listenerEl.setAttribute("id", "listener");
+      listenerEl.addEventListener("message", handleMessage, true);
+      listenerEl.addEventListener("load", handleLoad, true);
+      listenerEl.addEventListener("crash", handleCrash, true);
+      document.body.appendChild(listenerEl);
+      var baseHref = (_b = (_a = document.getElementsByTagName("base")[0]) === null || _a === void 0 ? void 0 : _a.href) !== null && _b !== void 0 ? _b : location.href;
+      var nmpPath = new URL("nacl-decoder.nmf", baseHref).href;
+      var naclModuleEl = document.createElement("embed");
+      naclModuleEl.setAttribute("width", "1920");
+      naclModuleEl.setAttribute("height", "1080");
+      naclModuleEl.setAttribute("src", nmpPath);
+      naclModuleEl.setAttribute("type", "application/x-nacl");
+      naclModuleEl.setAttribute("id", "nacl_module");
+      listenerEl.appendChild(naclModuleEl);
+      return naclModuleEl;
+    }
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/messages.js
+  var require_messages = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.NaClToJSMessageType = exports.JSToNaClMessageType = void 0;
+    var JSToNaClMessageType;
+    (function(JSToNaClMessageType2) {
+      JSToNaClMessageType2[JSToNaClMessageType2["Render"] = 0] = "Render";
+      JSToNaClMessageType2[JSToNaClMessageType2["Initialize"] = 1] = "Initialize";
+      JSToNaClMessageType2[JSToNaClMessageType2["Decode"] = 2] = "Decode";
+      JSToNaClMessageType2[JSToNaClMessageType2["GetPicture"] = 3] = "GetPicture";
+      JSToNaClMessageType2[JSToNaClMessageType2["Flush"] = 4] = "Flush";
+      JSToNaClMessageType2[JSToNaClMessageType2["Reset"] = 5] = "Reset";
+      JSToNaClMessageType2[JSToNaClMessageType2["RecyclePicture"] = 6] = "RecyclePicture";
+      JSToNaClMessageType2[JSToNaClMessageType2["DecodeAndRender"] = 7] = "DecodeAndRender";
+    })(JSToNaClMessageType || (exports.JSToNaClMessageType = JSToNaClMessageType = {}));
+    var NaClToJSMessageType;
+    (function(NaClToJSMessageType2) {
+      NaClToJSMessageType2[NaClToJSMessageType2["RenderResult"] = 0] = "RenderResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["InitializeResult"] = 1] = "InitializeResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["DecodeResult"] = 2] = "DecodeResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["GetPictureResult"] = 3] = "GetPictureResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["FlushResult"] = 4] = "FlushResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["ResetResult"] = 5] = "ResetResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["DecodeAndRenderResult"] = 7] = "DecodeAndRenderResult";
+      NaClToJSMessageType2[NaClToJSMessageType2["UnknownDataType"] = 254] = "UnknownDataType";
+      NaClToJSMessageType2[NaClToJSMessageType2["UnknownMessageType"] = 255] = "UnknownMessageType";
+    })(NaClToJSMessageType || (exports.NaClToJSMessageType = NaClToJSMessageType = {}));
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/NaClDecoder/naclDecoder.js
+  var require_naclDecoder = __commonJS((exports) => {
+    "use strict";
+    var __awaiter = exports && exports.__awaiter || function(thisArg, _arguments, P, generator) {
+      function adopt(value) {
+        return value instanceof P ? value : new P(function(resolve) {
+          resolve(value);
+        });
+      }
+      return new (P || (P = Promise))(function(resolve, reject) {
+        function fulfilled(value) {
+          try {
+            step(generator.next(value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function rejected(value) {
+          try {
+            step(generator["throw"](value));
+          } catch (e) {
+            reject(e);
+          }
+        }
+        function step(result) {
+          result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+        }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+      });
+    };
+    var __generator = exports && exports.__generator || function(thisArg, body) {
+      var _ = {label: 0, sent: function() {
+        if (t[0] & 1)
+          throw t[1];
+        return t[1];
+      }, trys: [], ops: []}, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+      }), g;
+      function verb(n) {
+        return function(v) {
+          return step([n, v]);
+        };
+      }
+      function step(op) {
+        if (f)
+          throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _)
+          try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done)
+              return t;
+            if (y = 0, t)
+              op = [op[0] & 2, t.value];
+            switch (op[0]) {
+              case 0:
+              case 1:
+                t = op;
+                break;
+              case 4:
+                _.label++;
+                return {value: op[1], done: false};
+              case 5:
+                _.label++;
+                y = op[1];
+                op = [0];
+                continue;
+              case 7:
+                op = _.ops.pop();
+                _.trys.pop();
+                continue;
+              default:
+                if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                  _ = 0;
+                  continue;
+                }
+                if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                  _.label = op[1];
+                  break;
+                }
+                if (op[0] === 6 && _.label < t[1]) {
+                  _.label = t[1];
+                  t = op;
+                  break;
+                }
+                if (t && _.label < t[2]) {
+                  _.label = t[2];
+                  _.ops.push(op);
+                  break;
+                }
+                if (t[2])
+                  _.ops.pop();
+                _.trys.pop();
+                continue;
+            }
+            op = body.call(thisArg, _);
+          } catch (e) {
+            op = [6, e];
+            y = 0;
+          } finally {
+            f = t = 0;
+          }
+        if (op[0] & 5)
+          throw op[1];
+        return {value: op[0] ? op[1] : void 0, done: true};
+      }
+    };
+    var __read = exports && exports.__read || function(o, n) {
+      var m = typeof Symbol === "function" && o[Symbol.iterator];
+      if (!m)
+        return o;
+      var i = m.call(o), r, ar = [], e;
+      try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done)
+          ar.push(r.value);
+      } catch (error) {
+        e = {error};
+      } finally {
+        try {
+          if (r && !r.done && (m = i["return"]))
+            m.call(i);
+        } finally {
+          if (e)
+            throw e.error;
+        }
+      }
+      return ar;
+    };
+    var __spreadArray = exports && exports.__spreadArray || function(to, from, pack) {
+      if (pack || arguments.length === 2)
+        for (var i = 0, l = from.length, ar; i < l; i++) {
+          if (ar || !(i in from)) {
+            if (!ar)
+              ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+          }
+        }
+      return to.concat(ar || Array.prototype.slice.call(from));
+    };
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.NaClDecoder = void 0;
+    var messages_1 = require_messages();
+    var NaClDecoder2 = function() {
+      function NaClDecoder3(messageSender) {
+        this.messageSender = messageSender;
+      }
+      NaClDecoder3.prototype.initialize = function(args) {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                message = {
+                  type: messages_1.JSToNaClMessageType.Initialize,
+                  payload: new Uint8Array(__spreadArray([
+                    args.profile,
+                    args.acceleration
+                  ], __read(new Uint8Array(new Uint32Array([args.minPictureCount]).buffer)), false)).buffer
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.InitializeResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.decodeAndRender = function(data) {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                if (!(data instanceof ArrayBuffer)) {
+                  throw new Error("Unexpected data type. Only ArrayBuffer is supported.");
+                }
+                message = {
+                  type: messages_1.JSToNaClMessageType.DecodeAndRender,
+                  payload: data
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.DecodeAndRenderResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.decode = function(args) {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                if (!(args.data instanceof ArrayBuffer)) {
+                  throw new Error("Unexpected data type. Only ArrayBuffer is supported.");
+                }
+                message = {
+                  type: messages_1.JSToNaClMessageType.Decode,
+                  payload: args.data
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.DecodeResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.getPicture = function() {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultFirstUInt32Array, resultSecondInt32Array, picture;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                message = {
+                  type: messages_1.JSToNaClMessageType.GetPicture
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.GetPictureResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultFirstUInt32Array = new Uint32Array(resultMessage.payload.slice(0, 12));
+                resultSecondInt32Array = new Int32Array(resultMessage.payload.slice(12, 24));
+                picture = {
+                  decodeId: resultFirstUInt32Array[0],
+                  textureId: resultFirstUInt32Array[1],
+                  textureTarget: resultFirstUInt32Array[2],
+                  textureSize: {
+                    width: resultSecondInt32Array[0],
+                    height: resultSecondInt32Array[1]
+                  },
+                  visibleRect: {
+                    x: resultSecondInt32Array[2],
+                    y: resultSecondInt32Array[3],
+                    width: resultSecondInt32Array[4],
+                    height: resultSecondInt32Array[5]
+                  }
+                };
+                return [2, picture];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.recyclePicture = function(picture) {
+        var firstUint32Array = new Uint32Array([
+          picture.decodeId,
+          picture.textureId,
+          picture.textureTarget
+        ]);
+        var secondInt32Array = new Int32Array([
+          picture.textureSize.width,
+          picture.textureSize.height,
+          picture.visibleRect.x,
+          picture.visibleRect.y,
+          picture.visibleRect.width,
+          picture.visibleRect.height
+        ]);
+        var message = {
+          type: messages_1.JSToNaClMessageType.RecyclePicture,
+          payload: new Uint8Array(__spreadArray(__spreadArray([], __read(new Uint8Array(firstUint32Array.buffer)), false), __read(new Uint8Array(secondInt32Array.buffer)), false)).buffer
+        };
+        this.messageSender.sendWithoutResult(message);
+      };
+      NaClDecoder3.prototype.flush = function() {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                message = {
+                  type: messages_1.JSToNaClMessageType.Flush
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.FlushResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.reset = function() {
+        return __awaiter(this, void 0, void 0, function() {
+          var message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                message = {
+                  type: messages_1.JSToNaClMessageType.Reset
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.ResetResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      NaClDecoder3.prototype.render = function(picture) {
+        return __awaiter(this, void 0, void 0, function() {
+          var firstUint32Array, secondInt32Array, message, resultMessage, resultStatus;
+          return __generator(this, function(_a) {
+            switch (_a.label) {
+              case 0:
+                firstUint32Array = new Uint32Array([
+                  picture.decodeId,
+                  picture.textureId,
+                  picture.textureTarget
+                ]);
+                secondInt32Array = new Int32Array([
+                  picture.textureSize.width,
+                  picture.textureSize.height,
+                  picture.visibleRect.x,
+                  picture.visibleRect.y,
+                  picture.visibleRect.width,
+                  picture.visibleRect.height
+                ]);
+                message = {
+                  type: messages_1.JSToNaClMessageType.Render,
+                  payload: new Uint8Array(__spreadArray(__spreadArray([], __read(new Uint8Array(firstUint32Array.buffer)), false), __read(new Uint8Array(secondInt32Array.buffer)), false)).buffer
+                };
+                return [4, this.messageSender.sendWithResult(message, messages_1.NaClToJSMessageType.RenderResult)];
+              case 1:
+                resultMessage = _a.sent();
+                resultStatus = new Int32Array(resultMessage.payload)[0];
+                return [2, resultStatus];
+            }
+          });
+        });
+      };
+      return NaClDecoder3;
+    }();
+    exports.NaClDecoder = NaClDecoder2;
+  });
+
+  // node_modules/@signageos/nacl-decoder/dist/index.js
+  var require_dist = __commonJS((exports) => {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", {value: true});
+    exports.NaClDecoder = void 0;
+    exports.isNaClSupported = isNaClSupported2;
+    exports.createNaClDecoder = createNaClDecoder2;
+    var messageListeners_1 = require_messageListeners();
+    var messageReceiver_1 = require_messageReceiver();
+    var messageSender_1 = require_messageSender();
+    var module_1 = require_module();
+    var naclDecoder_1 = require_naclDecoder();
+    Object.defineProperty(exports, "NaClDecoder", {enumerable: true, get: function() {
+      return naclDecoder_1.NaClDecoder;
+    }});
+    function isNaClSupported2() {
+      return navigator.mimeTypes["application/x-nacl"] !== void 0;
+    }
+    function createNaClDecoder2() {
+      if (!isNaClSupported2()) {
+        throw new Error("NaCl is not supported in this browser.");
+      }
+      var messageListeners = (0, messageListeners_1.createMessageListeners)();
+      var messageReceiver = new messageReceiver_1.MessageReceiver(messageListeners);
+      var naclModuleEl = (0, module_1.createNaClModule)(messageReceiver.handleMessage.bind(messageReceiver));
+      var messageSender = new messageSender_1.MessageSender(naclModuleEl, messageListeners);
+      return new naclDecoder_1.NaClDecoder(messageSender);
+    }
+  });
+
   // env/consts.ts
   var FORCE_PLAIN_KEY = "_forcePlain";
 
@@ -17338,24 +17969,20 @@
   }
 
   // screen/plain.ts
-  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-mznacl.256";
+  var import_nacl_decoder = __toModule(require_dist());
+  var SCREEN_JS_URL = "supra-client-screen.js?v=0.0.0-mznacl.262";
   async function startPlainScreen(options) {
     const screenOptions = options != null ? options : parseQueryOptions();
     const fs = await initBrowserFS();
     window.fs = fs;
-    window.naclDecoder = createNaClDecoder();
+    if ((0, import_nacl_decoder.isNaClSupported)()) {
+      window.naclDecoder = (0, import_nacl_decoder.createNaClDecoder)();
+    }
     process.argv = ["go", ...getGoArgv(SCREEN_JS_URL, screenOptions)];
     Object.assign(process.env, getGoEnv());
     await injectScript(SCREEN_JS_URL);
     await new Promise(() => void 0);
   }
-  function createNaClDecoder() {
-    if ("NaClDecoder" in window && window.NaClDecoder) {
-      const naclDecoder = new NaClDecoder();
-      return naclDecoder;
-    }
-    return void 0;
-  }
 
   // node_modules/h264decoder/dist/b64.js
   var key = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
@@ -17492,7 +18119,7 @@
   }
 
   // screen/wasm.ts
-  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-mznacl.256";
+  var SCREEN_WASM_URL = "supra-client-screen.wasm?v=0.0.0-mznacl.262";
   async function startWasmScreen(options) {
     const screenOptions = options != null ? options : parseQueryOptions();
     const h264Decoder = await createH264Decoder();