slides-viewer-8c2f5ec5.js

js filament.com collected 2026-09-25 14:02:29 UTC 84,625 bytes, 3,020 lines download raw bytes

1// ../../../viewers/slides/bindings/wasm/pkg/slides_wasm.js
2var SlideViewer = class {
3  __destroy_into_raw() {
4    const ptr = this.__wbg_ptr;
5    this.__wbg_ptr = 0;
6    SlideViewerFinalization.unregister(this);
7    return ptr;
8  }
9  free() {
10    const ptr = this.__destroy_into_raw();
11    wasm.__wbg_slideviewer_free(ptr, 0);
12  }
13  /**
14   * @returns {number}
15   */
16  frame_height() {
17    const ret = wasm.slideviewer_frame_height(this.__wbg_ptr);
18    return ret >>> 0;
19  }
20  /**
21   * @returns {number}
22   */
23  frame_len() {
24    const ret = wasm.slideviewer_frame_len(this.__wbg_ptr);
25    return ret >>> 0;
26  }
27  /**
28   * Returns the address of the last drawn frame in linear memory, as tightly packed RGBA8.
29   * @returns {number}
30   */
31  frame_ptr() {
32    const ret = wasm.slideviewer_frame_ptr(this.__wbg_ptr);
33    return ret >>> 0;
34  }
35  /**
36   * @returns {number}
37   */
38  frame_width() {
39    const ret = wasm.slideviewer_frame_width(this.__wbg_ptr);
40    return ret >>> 0;
41  }
42  /**
43   * @returns {boolean}
44   */
45  needs_redraw() {
46    const ret = wasm.slideviewer_needs_redraw(this.__wbg_ptr);
47    return ret !== 0;
48  }
49  /**
50   * Creates a viewer with nothing open.
51   */
52  constructor() {
53    const ret = wasm.slideviewer_new();
54    this.__wbg_ptr = ret;
55    SlideViewerFinalization.register(this, this.__wbg_ptr, this);
56    return this;
57  }
58  /**
59   * Drains queued events as an encoded `EventBatch`.
60   * @returns {Uint8Array}
61   */
62  poll_events() {
63    const ret = wasm.slideviewer_poll_events(this.__wbg_ptr);
64    var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
65    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
66    return v1;
67  }
68  /**
69   * Draws the current frame into linear memory.
70   *
71   * Read it with [`Self::frame_ptr`] and [`Self::frame_len`]. Rebuild the view first; see
72   * the crate docs.
73   */
74  render() {
75    wasm.slideviewer_render(this.__wbg_ptr);
76  }
77  /**
78   * Sets the surface size in device pixels.
79   * @param {number} width
80   * @param {number} height
81   */
82  set_size(width, height) {
83    wasm.slideviewer_set_size(this.__wbg_ptr, width, height);
84  }
85  /**
86   * Applies one encoded `Command` and returns an encoded `CommandResult`.
87   * @param {Uint8Array} command
88   * @returns {Uint8Array}
89   */
90  submit(command) {
91    const ptr0 = passArray8ToWasm0(command, wasm.__wbindgen_malloc);
92    const len0 = WASM_VECTOR_LEN;
93    const ret = wasm.slideviewer_submit(this.__wbg_ptr, ptr0, len0);
94    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
95    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
96    return v2;
97  }
98  /**
99   * Advances background reading by one frame's worth.
100   */
101  tick() {
102    wasm.slideviewer_tick(this.__wbg_ptr);
103  }
104};
105if (Symbol.dispose) SlideViewer.prototype[Symbol.dispose] = SlideViewer.prototype.free;
106function abi_version() {
107  const ret = wasm.abi_version();
108  return ret >>> 0;
109}
110function __wbg_get_imports() {
111  const import0 = {
112    __proto__: null,
113    __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
114      throw new Error(getStringFromWasm0(arg0, arg1));
115    },
116    __wbg_error_757e9472f8410341: function(arg0, arg1) {
117      let deferred0_0;
118      let deferred0_1;
119      try {
120        deferred0_0 = arg0;
121        deferred0_1 = arg1;
122        console.error(getStringFromWasm0(arg0, arg1));
123      } finally {
124        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
125      }
126    },
127    __wbg_new_227d7c05414eb861: function() {
128      const ret = new Error();
129      return ret;
130    },
131    __wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
132      const ret = arg1.stack;
133      const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
134      const len1 = WASM_VECTOR_LEN;
135      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
136      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
137    },
138    __wbindgen_init_externref_table: function() {
139      const table = wasm.__wbindgen_externrefs;
140      const offset = table.grow(4);
141      table.set(0, void 0);
142      table.set(offset + 0, void 0);
143      table.set(offset + 1, null);
144      table.set(offset + 2, true);
145      table.set(offset + 3, false);
146    }
147  };
148  return {
149    __proto__: null,
150    "./slides_wasm_bg.js": import0
151  };
152}
153var SlideViewerFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
154}, unregister: () => {
155} } : new FinalizationRegistry((ptr) =>

155 wasm.__wbg_slideviewer_free(ptr, 1));
156function getArrayU8FromWasm0(ptr, len) {
157  ptr = ptr >>> 0;
158  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
159}
160var cachedDataViewMemory0 = null;
161function getDataViewMemory0() {
162  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
163    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
164  }
165  return cachedDataViewMemory0;
166}
167function getStringFromWasm0(ptr, len) {
168  return decodeText(ptr >>> 0, len);
169}
170var cachedUint8ArrayMemory0 = null;
171function getUint8ArrayMemory0() {
172  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
173    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
174  }
175  return cachedUint8ArrayMemory0;
176}
177function passArray8ToWasm0(arg, malloc) {
178  const ptr = malloc(arg.length * 1, 1) >>> 0;
179  getUint8ArrayMemory0().set(arg, ptr / 1);
180  WASM_VECTOR_LEN = arg.length;
181  return ptr;
182}
183function passStringToWasm0(arg, malloc, realloc) {
184  if (realloc === void 0) {
185    const buf = cachedTextEncoder.encode(arg);
186    const ptr2 = malloc(buf.length, 1) >>> 0;
187    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
188    WASM_VECTOR_LEN = buf.length;
189    return ptr2;
190  }
191  let len = arg.length;
192  let ptr = malloc(len, 1) >>> 0;
193  const mem = getUint8ArrayMemory0();
194  let offset = 0;
195  for (; offset < len; offset++) {
196    const code = arg.charCodeAt(offset);
197    if (code > 127) break;
198    mem[ptr + offset] = code;
199  }
200  if (offset !== len) {
201    if (offset !== 0) {
202      arg = arg.slice(offset);
203    }
204    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
205    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
206    const ret = cachedTextEncoder.encodeInto(arg, view);
207    offset += ret.written;
208    ptr = realloc(ptr, len, offset, 1) >>> 0;
209  }
210  WASM_VECTOR_LEN = offset;
211  return ptr;
212}
213var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
214cachedTextDecoder.decode();
215var MAX_SAFARI_DECODE_BYTES = 2146435072;
216var numBytesDecoded = 0;
217function decodeText(ptr, len) {
218  numBytesDecoded += len;
219  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
220    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
221    cachedTextDecoder.decode();
222    numBytesDecoded = len;
223  }
224  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
225}
226var cachedTextEncoder = new TextEncoder();
227if (!("encodeInto" in cachedTextEncoder)) {
228  cachedTextEncoder.encodeInto = function(arg, view) {
229    const buf = cachedTextEncoder.encode(arg);
230    view.set(buf);
231    return {
232      read: arg.length,
233      written: buf.length
234    };
235  };
236}
237var WASM_VECTOR_LEN = 0;
238var wasmModule;
239var wasmInstance;
240var wasm;
241function __wbg_finalize_init(instance, module) {
242  wasmInstance = instance;
243  wasm = instance.exports;
244  wasmModule = module;
245  cachedDataViewMemory0 = null;
246  cachedUint8ArrayMemory0 = null;
247  wasm.__wbindgen_start();
248  return wasm;
249}
250async function __wbg_load(module, imports) {
251  if (typeof Response === "function" && module instanceof Response) {
252    if (!module.ok) {
253      throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
254    }
255    if (typeof WebAssembly.instantiateStreaming === "function") {
256      try {
257        return await WebAssembly.instantiateStreaming(module, imports);
258      } catch (e) {
259        const validResponse = expectedResponseType(module.type);
260        if (validResponse && module.headers.get("Content-Type") !== "application/wasm") {
261          console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
262        } else {
263          throw e;
264        }
265      }
266    }
267    const bytes = await module.arrayBuffer();
268    return await WebAssembly.instantiate(bytes, imports);
269  } else {
270    const instance = await WebAssembly.instantiate(module, imports);
271    if (instance instanceof WebAssembly.Instance) {
272      return { instance, module };
273    } else {
274      return instance;
275    }
276  }
277  function expectedResponseType(type) {
278    switch (type) {
279      case "basic":
280      case "cors":
281      case "default":
282        return true;
283    }
284    return false;

285  }
286}
287async function __wbg_init(module_or_path) {
288  if (wasm !== void 0) return wasm;
289  if (module_or_path !== void 0) {
290    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
291      ({ module_or_path } = module_or_path);
292    } else {
293      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
294    }
295  }
296  if (module_or_path === void 0) {
297    module_or_path = new URL("slides_wasm_bg.wasm", import.meta.url);
298  }
299  const imports = __wbg_get_imports();
300  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
301    module_or_path = fetch(module_or_path);
302  }
303  const { instance, module } = await __wbg_load(await module_or_path, imports);
304  return __wbg_finalize_init(instance, module);
305}
306

307// ../../../viewers/slides/proto/gen/slides_pb.js
308var encodeColorScheme = {
309  COLOR_SCHEME_UNSPECIFIED: 0,
310  COLOR_SCHEME_DARK: 1,
311  COLOR_SCHEME_LIGHT: 2
312};
313var decodeColorScheme = {
314  0: "COLOR_SCHEME_UNSPECIFIED",
315  1: "COLOR_SCHEME_DARK",
316  2: "COLOR_SCHEME_LIGHT"
317};
318var decodeDeckKind = {
319  0: "DECK_KIND_UNSPECIFIED",
320  1: "DECK_KIND_PRESENTATION",
321  2: "DECK_KIND_SLIDESHOW",
322  3: "DECK_KIND_TEMPLATE"
323};
324var encodeViewMode = {
325  VIEW_MODE_UNSPECIFIED: 0,
326  VIEW_MODE_SLIDES: 1,
327  VIEW_MODE_GRID: 2
328};
329var decodeViewMode = {
330  0: "VIEW_MODE_UNSPECIFIED",
331  1: "VIEW_MODE_SLIDES",
332  2: "VIEW_MODE_GRID"
333};
334var decodeUnrendered = {
335  0: "UNRENDERED_UNSPECIFIED",
336  1: "UNRENDERED_CHART",
337  2: "UNRENDERED_SMART_ART",
338  3: "UNRENDERED_OLE_OBJECT",
339  4: "UNRENDERED_EQUATION",
340  5: "UNRENDERED_PICTURE_FORMAT",
341  6: "UNRENDERED_MEDIA",
342  7: "UNRENDERED_INK",
343  8: "UNRENDERED_MODEL_3D",
344  9: "UNRENDERED_OTHER"
345};
346var encodeLane = {
347  LANE_UNSPECIFIED: 0,
348  LANE_BEFORE: 1,
349  LANE_AFTER: 2
350};
351var decodeLane = {
352  0: "LANE_UNSPECIFIED",
353  1: "LANE_BEFORE",
354  2: "LANE_AFTER"
355};
356var decodeSlideStatus = {
357  0: "SLIDE_STATUS_UNSPECIFIED",
358  1: "SLIDE_STATUS_SAME",
359  2: "SLIDE_STATUS_ADDED",
360  3: "SLIDE_STATUS_REMOVED",
361  4: "SLIDE_STATUS_CHANGED"
362};
363var decodeMatchBasis = {
364  0: "MATCH_BASIS_UNSPECIFIED",
365  1: "MATCH_BASIS_IDS",
366  2: "MATCH_BASIS_CREATION_ID",
367  3: "MATCH_BASIS_SLIDE_ID",
368  4: "MATCH_BASIS_CONTENT"
369};
370var decodeSlideAspect = {
371  0: "SLIDE_ASPECT_UNSPECIFIED",
372  1: "SLIDE_ASPECT_SHAPES",
373  2: "SLIDE_ASPECT_TEXT",
374  3: "SLIDE_ASPECT_PICTURES",
375  4: "SLIDE_ASPECT_NOTES",
376  5: "SLIDE_ASPECT_HIDDEN",
377  6: "SLIDE_ASPECT_INHERITED"
378};
379var decodeShapeAspect = {
380  0: "SHAPE_ASPECT_UNSPECIFIED",
381  1: "SHAPE_ASPECT_ADDED",
382  2: "SHAPE_ASPECT_REMOVED",
383  3: "SHAPE_ASPECT_MOVED",
384  4: "SHAPE_ASPECT_RESIZED",
385  5: "SHAPE_ASPECT_ROTATED",
386  6: "SHAPE_ASPECT_TEXT",
387  7: "SHAPE_ASPECT_FORMATTING",
388  8: "SHAPE_ASPECT_PICTURE"
389};
390var decodeTextSpanKind = {
391  0: "TEXT_SPAN_KIND_UNSPECIFIED",
392  1: "TEXT_SPAN_KIND_SAME",
393  2: "TEXT_SPAN_KIND_ADDED",
394  3: "TEXT_SPAN_KIND_REMOVED"
395};
396var encodeCompareMode = {
397  COMPARE_MODE_UNSPECIFIED: 0,
398  COMPARE_MODE_SIDE_BY_SIDE: 1,
399  COMPARE_MODE_SLIDER: 2,
400  COMPARE_MODE_ONIONSKIN: 3
401};
402var decodeCompareMode = {
403  0: "COMPARE_MODE_UNSPECIFIED",
404  1: "COMPARE_MODE_SIDE_BY_SIDE",
405  2: "COMPARE_MODE_SLIDER",
406  3: "COMPARE_MODE_ONIONSKIN"
407};
408function _decodeByteRange(bb) {
409  let message = {};
410  end_of_message: while (!isAtEnd(bb)) {
411    let tag = readVarint32(bb);
412    switch (tag >>> 3) {
413      case 0:
414        break end_of_message;
415      // optional uint64 offset = 1;
416      case 1: {
417        message.offset = readVarint64(
418          bb,
419          /* unsigned */
420          true
421        );
422        break;
423      }
424      // optional uint64 length = 2;
425      case 2: {
426        message.length = readVarint64(
427          bb,
428          /* unsigned */
429          true
430        );
431        break;
432      }
433      default:
434        skipUnknownField(bb, tag & 7);
435    }
436  }
437  return message;
438}
439function _decodeFontSubstitution(bb) {
440  let message = {};
441  end_of_message: while (!isAtEnd(bb)) {
442    let tag = readVarint32(bb);
443    switch (tag >>> 3) {
444      case 0:
445        break end_of_message;
446      // optional string requested = 1;
447      case 1: {
448        message.requested = readString(bb, readVarint32(bb));
449        break;
450      }
451      // optional string used = 2;
452      case 2: {
453        message.used = readString(bb, readVarint32(bb));
454        break;
455      }
456      // optional bool metric_compatible = 3;
457      case 3: {
458        message.metric_compatible = !!readByte(bb);
459        break;
460      }
461      default:
462        skipUnknownField(bb, tag & 7);
463    }
464  }
465  return message;
466}
467function _decodeUnrenderedCount(bb) {
468  let message = {};
469  end_of_message: while (!isAtEnd(bb)) {
470    let tag = readVarint32(bb);
471    switch (tag >>> 3) {
472      case 0:
473        break end_of_message;
474      // optional Unrendered kind = 1;
475      case 1: {
476        message.kind = decodeUnrendered[readVarint32(bb)];
477        break;
478      }
479      // optional uint32 count = 2;
480      case 2: {
481        message.count = readVarint32(bb) >>> 0;
482        break;
483      }
484      default:
485        skipUnknownField(bb, tag & 7);
486    }
487  }
488  return message;
489}
490function _decodeSlideSummary(bb) {
491  let message = {};
492  end_of_message: while (!isAtEnd(bb)) {
493    let tag = readVarint32(bb);
494    switch (tag >>> 3) {
495      case 0:
496        break end_of_message;
497      // optional uint32 number = 1;
498      case 1: {
499        message.number = readVarint32(bb) >>> 0;
500        break;
501      }
502      // optional bool hidden = 2;
503      case 2: {
504        message.hidden = !!readByte(bb);
505        break;
506      }
507      // optional string title = 3;
508      case 3: {
509        message.title = readString(bb, readVarint32(bb));
510        break;
511      }
512      // optional bool has_notes = 4;
513      case 4: {
514        message.has_notes = !!readByte(bb);
515        break;
516      }
517      // optional bool unreadable = 5;
518      case 5: {
519        message.unreadable = !!readByte(bb);
520        break;
521      }
522      default:
523        skipUnknownField(bb, tag & 7);
524    }
525  }
526  return message;
527}
528function _decodeDeckInfo(bb) {
529  let message = {};
530  end_of_message: while (!isAtEnd(bb)) {
531    let tag = readVarint32(bb);
532    switch (tag >>> 3) {
533      case 0:
534        break end_of_message;
535      // optional DeckKind kind = 1;
536      case 1: {
537        message.kind = decodeDeckKind[readVarint32(bb)];
538        break;
539      }
540      // optional bool macro_enabled = 2;
541      case 2: {
542        message.macro_enabled = !!readByte(bb);
543        break;
544      }
545      // optional uint64 slide_width = 3;
546      case 3: {
547        message.slide_width = readVarint64(
548          bb,
549          /* unsigned */
550          true
551        );
552        break;
553      }
554      // optional uint64 slide_height = 4;
555      case 4: {
556        message.slide_height = readVarint64(
557          bb,
558          /* unsigned */
559          true
560        );
561        break;
562      }
563      // repeated SlideSummary slides = 5;
564      case 5: {
565        let limit = pushTemporaryLength(bb);
566        let values = message.slides || (message.slides = []);
567        values.push(_decodeSlideSummary(bb));
568        bb.limit = limit;
569        break;
570      }
571      // optional string title = 6;
572      case 6: {
573        message.title = readString(bb, readVarint32(bb));
574        break;
575      }
576      // optional string application = 7;
577      case 7: {
578        message.application = readString(bb, readVarint32(bb));
579        break;
580      }
581      // repeated FontSubstitution fonts = 8;
582      case 8: {
583        let limit = pushTemporaryLength(bb);
584        let values = message.fonts || (message.fonts = []);
585        values.push(_decodeFontSubstitution(bb));
586        bb.limit = limit;
587        break;
588      }
589      // repeated UnrenderedCount unrendered = 9;
590      case 9: {
591        let limit = pushTemporaryLength(bb);
592        let values = message.unrendered || (message.unrendered = []);

593        values.push(_decodeUnrenderedCount(bb));
594        bb.limit = limit;
595        break;
596      }
597      // optional bool loading = 10;
598      case 10: {
599        message.loading = !!readByte(bb);
600        break;
601      }
602      default:
603        skipUnknownField(bb, tag & 7);
604    }
605  }
606  return message;
607}
608function _decodeSourceState(bb) {
609  let message = {};
610  end_of_message: while (!isAtEnd(bb)) {
611    let tag = readVarint32(bb);
612    switch (tag >>> 3) {
613      case 0:
614        break end_of_message;
615      // optional uint64 bytes_total = 1;
616      case 1: {
617        message.bytes_total = readVarint64(
618          bb,
619          /* unsigned */
620          true
621        );
622        break;
623      }
624      // optional uint64 bytes_have = 2;
625      case 2: {
626        message.bytes_have = readVarint64(
627          bb,
628          /* unsigned */
629          true
630        );
631        break;
632      }
633      // repeated ByteRange have = 3;
634      case 3: {
635        let limit = pushTemporaryLength(bb);
636        let values = message.have || (message.have = []);
637        values.push(_decodeByteRange(bb));
638        bb.limit = limit;
639        break;
640      }
641      // repeated ByteRange wanted = 4;
642      case 4: {
643        let limit = pushTemporaryLength(bb);
644        let values = message.wanted || (message.wanted = []);
645        values.push(_decodeByteRange(bb));
646        bb.limit = limit;
647        break;
648      }
649      // optional bool complete = 5;
650      case 5: {
651        message.complete = !!readByte(bb);
652        break;
653      }
654      // optional Lane lane = 6;
655      case 6: {
656        message.lane = decodeLane[readVarint32(bb)];
657        break;
658      }
659      default:
660        skipUnknownField(bb, tag & 7);
661    }
662  }
663  return message;
664}
665function _decodeViewState(bb) {
666  let message = {};
667  end_of_message: while (!isAtEnd(bb)) {
668    let tag = readVarint32(bb);
669    switch (tag >>> 3) {
670      case 0:
671        break end_of_message;
672      // optional ViewMode mode = 1;
673      case 1: {
674        message.mode = decodeViewMode[readVarint32(bb)];
675        break;
676      }
677      // optional uint32 current = 2;
678      case 2: {
679        message.current = readVarint32(bb) >>> 0;
680        break;
681      }
682      // optional uint32 first_visible = 3;
683      case 3: {
684        message.first_visible = readVarint32(bb) >>> 0;
685        break;
686      }
687      // optional uint32 last_visible = 4;
688      case 4: {
689        message.last_visible = readVarint32(bb) >>> 0;
690        break;
691      }
692      // optional uint32 columns = 5;
693      case 5: {
694        message.columns = readVarint32(bb) >>> 0;
695        break;
696      }
697      // optional float scroll_y = 6;
698      case 6: {
699        message.scroll_y = readFloat(bb);
700        break;
701      }
702      // optional float max_scroll_y = 7;
703      case 7: {
704        message.max_scroll_y = readFloat(bb);
705        break;
706      }
707      // optional float content_height = 8;
708      case 8: {
709        message.content_height = readFloat(bb);
710        break;
711      }
712      default:
713        skipUnknownField(bb, tag & 7);
714    }
715  }
716  return message;
717}
718function _decodeCurrentSlide(bb) {
719  let message = {};
720  end_of_message: while (!isAtEnd(bb)) {
721    let tag = readVarint32(bb);
722    switch (tag >>> 3) {
723      case 0:
724        break end_of_message;
725      // optional uint32 index = 1;
726      case 1: {
727        message.index = readVarint32(bb) >>> 0;
728        break;
729      }
730      // optional uint32 number = 7;
731      case 7: {
732        message.number = readVarint32(bb) >>> 0;
733        break;
734      }
735      // optional string title = 2;
736      case 2: {
737        message.title = readString(bb, readVarint32(bb));
738        break;
739      }
740      // optional string notes = 3;
741      case 3: {
742        message.notes = readString(bb, readVarint32(bb));
743        break;
744      }
745      // optional bool hidden = 4;
746      case 4: {
747        message.hidden = !!readByte(bb);
748        break;
749      }
750      // optional string layout = 5;
751      case 5: {
752        message.layout = readString(bb, readVarint32(bb));
753        break;
754      }
755      // repeated string links = 6;
756      case 6: {
757        let values = message.links || (message.links = []);
758        values.push(readString(bb, readVarint32(bb)));
759        break;
760      }
761      default:
762        skipUnknownField(bb, tag & 7);
763    }
764  }
765  return message;
766}
767function _decodeHoverState(bb) {
768  let message = {};
769  end_of_message: while (!isAtEnd(bb)) {
770    let tag = readVarint32(bb);
771    switch (tag >>> 3) {
772      case 0:
773        break end_of_message;
774      // optional uint32 slide = 1;
775      case 1: {
776        message.slide = readVarint32(bb) >>> 0;
777        break;
778      }
779      // optional float x = 2;
780      case 2: {
781        message.x = readFloat(bb);
782        break;
783      }
784      // optional float y = 3;
785      case 3: {
786        message.y = readFloat(bb);
787        break;
788      }
789      // optional float width = 4;
790      case 4: {
791        message.width = readFloat(bb);
792        break;
793      }
794      // optional float height = 5;
795      case 5: {
796        message.height = readFloat(bb);
797        break;
798      }
799      default:
800        skipUnknownField(bb, tag & 7);
801    }
802  }
803  return message;
804}
805function _decodeRenderOptions(bb) {
806  let message = {};
807  end_of_message: while (!isAtEnd(bb)) {
808    let tag = readVarint32(bb);
809    switch (tag >>> 3) {
810      case 0:
811        break end_of_message;
812      // optional ColorScheme color_scheme = 1;
813      case 1: {
814        message.color_scheme = decodeColorScheme[readVarint32(bb)];
815        break;
816      }
817      // optional float ui_scale = 2;
818      case 2: {
819        message.ui_scale = readFloat(bb);
820        break;
821      }
822      default:
823        skipUnknownField(bb, tag & 7);
824    }
825  }
826  return message;
827}
828function _decodeSlidePair(bb) {
829  let message = {};
830  end_of_message: while (!isAtEnd(bb)) {
831    let tag = readVarint32(bb);
832    switch (tag >>> 3) {
833      case 0:
834        break end_of_message;
835      // optional SlideStatus status = 1;
836      case 1: {
837        message.status = decodeSlideStatus[readVarint32(bb)];
838        break;
839      }
840      // optional uint32 before = 2;
841      case 2: {
842        message.before = readVarint32(bb) >>> 0;
843        break;
844      }
845      // optional uint32 after = 3;
846      case 3: {
847        message.after = readVarint32(bb) >>> 0;
848        break;
849      }
850      // optional bool moved = 4;
851      case 4: {
852        message.moved = !!readByte(bb);
853        break;
854      }
855      // optional MatchBasis basis = 5;
856      case 5: {
857        message.basis = decodeMatchBasis[readVarint32(bb)];
858        break;
859      }
860      // repeated SlideAspect aspects = 6;
861      case 6: {
862        let values = message.aspects || (message.aspects = []);
863        if ((tag & 7) === 2) {
864          let outerLimit = pushTemporaryLength(bb);
865          while (!isAtEnd(bb)) {
866            values.push(decodeSlideAspect[readVarint32(bb)]);
867          }
868          bb.limit = outerLimit;
869        } else {
870          values.push(decodeSlideAspect[readVarint32(bb)]);
871        }
872        break;
873      }
874      default:
875        skipUnknownField(bb, tag & 7);
876    }
877  }
878  return message;
879}
880function _decodeBasisCount(bb) {
881  let message = {};
882  end_of_message: while (!isAtEnd(bb)) {
883    let tag = readVarint32(bb);
884    switch (tag >>> 3) {
885      case 0:
886        break end_of_message;
887      // optional MatchBasis basis = 1;
888      case 1: {
889        message.basis = decodeMatchBasis[readVarint32(bb)];
890        break;
891      }
892      // optional uint32 count = 2;
893      case 2: {
894        message.count = readVarint32(bb) >>> 0;
895        break;
896      }
897      default:
898        skipUnknownField(bb, tag & 7);
899    }
900  }
901  return message;
902}
903function _decodeLaneError(bb) {
904  let message = {};
905  end_of_message: while (!isAtEnd(bb)) {
906    let tag = readVarint32(bb);
907    switch (tag >>> 3) {
908      case 0:
909        break end_of_message;
910      // optional Lane lane = 1;
911      case 1: {
912        message.lane = decodeLane[readVarint32(bb)];
913        break;
914      }
915      // optional uint32 code = 2;
916      case 2: {
917        message.code = readVarint32(bb) >>> 0;
918        break;
919      }
920      // optional string message = 3;
921      case 3: {
922        message.message = readString(bb, readVarint32(bb));
923        break;
924      }
925      default:
926        skipUnknownField(bb, tag & 7);
927    }
928  }
929  return message;
930}
931function _decodeStatusSwatch(bb) {
932  let message = {};
933  end_of_message: while (!isAtEnd(bb)) {
934    let tag = readVarint32(bb);
935    switch (tag >>> 3) {
936      case 0:
937        break end_of_message;
938      // optional SlideStatus status = 1;
939      case 1: {
940        message.status = decodeSlideStatus[readVarint32(bb)];
941        break;
942      }
943      // optional string color = 2;
944      case 2: {
945        message.color = readString(bb, readVarint32(bb));
946        break;
947      }
948      default:
949        skipUnknownField(bb, tag & 7);
950    }
951  }
952  return message;
953}

954function _decodeDiffState(bb) {
955  let message = {};
956  end_of_message: while (!isAtEnd(bb)) {
957    let tag = readVarint32(bb);
958    switch (tag >>> 3) {
959      case 0:
960        break end_of_message;
961      // optional bool complete = 1;
962      case 1: {
963        message.complete = !!readByte(bb);
964        break;
965      }
966      // optional DeckInfo before = 2;
967      case 2: {
968        let limit = pushTemporaryLength(bb);
969        message.before = _decodeDeckInfo(bb);
970        bb.limit = limit;
971        break;
972      }
973      // optional uint32 same = 3;
974      case 3: {
975        message.same = readVarint32(bb) >>> 0;
976        break;
977      }
978      // optional uint32 added = 4;
979      case 4: {
980        message.added = readVarint32(bb) >>> 0;
981        break;
982      }
983      // optional uint32 removed = 5;
984      case 5: {
985        message.removed = readVarint32(bb) >>> 0;
986        break;
987      }
988      // optional uint32 changed = 6;
989      case 6: {
990        message.changed = readVarint32(bb) >>> 0;
991        break;
992      }
993      // optional uint32 moved = 7;
994      case 7: {
995        message.moved = readVarint32(bb) >>> 0;
996        break;
997      }
998      // repeated SlidePair rows = 8;
999      case 8: {
1000        let limit = pushTemporaryLength(bb);
1001        let values = message.rows || (message.rows = []);
1002        values.push(_decodeSlidePair(bb));
1003        bb.limit = limit;
1004        break;
1005      }
1006      // repeated BasisCount matched_by = 9;
1007      case 9: {
1008        let limit = pushTemporaryLength(bb);
1009        let values = message.matched_by || (message.matched_by = []);
1010        values.push(_decodeBasisCount(bb));
1011        bb.limit = limit;
1012        break;
1013      }
1014      // optional bool slide_size_changed = 10;
1015      case 10: {
1016        message.slide_size_changed = !!readByte(bb);
1017        break;
1018      }
1019      // optional uint32 inherited = 11;
1020      case 11: {
1021        message.inherited = readVarint32(bb) >>> 0;
1022        break;
1023      }
1024      // repeated LaneError errors = 12;
1025      case 12: {
1026        let limit = pushTemporaryLength(bb);
1027        let values = message.errors || (message.errors = []);
1028        values.push(_decodeLaneError(bb));
1029        bb.limit = limit;
1030        break;
1031      }
1032      // optional bool before_absent = 13;
1033      case 13: {
1034        message.before_absent = !!readByte(bb);
1035        break;
1036      }
1037      // optional bool after_absent = 14;
1038      case 14: {
1039        message.after_absent = !!readByte(bb);
1040        break;
1041      }
1042      // repeated StatusSwatch legend = 15;
1043      case 15: {
1044        let limit = pushTemporaryLength(bb);
1045        let values = message.legend || (message.legend = []);
1046        values.push(_decodeStatusSwatch(bb));
1047        bb.limit = limit;
1048        break;
1049      }
1050      default:
1051        skipUnknownField(bb, tag & 7);
1052    }
1053  }
1054  return message;
1055}
1056function _decodeShapeBox(bb) {
1057  let message = {};
1058  end_of_message: while (!isAtEnd(bb)) {
1059    let tag = readVarint32(bb);
1060    switch (tag >>> 3) {
1061      case 0:
1062        break end_of_message;
1063      // optional double x = 1;
1064      case 1: {
1065        message.x = readDouble(bb);
1066        break;
1067      }
1068      // optional double y = 2;
1069      case 2: {
1070        message.y = readDouble(bb);
1071        break;
1072      }
1073      // optional double width = 3;
1074      case 3: {
1075        message.width = readDouble(bb);
1076        break;
1077      }
1078      // optional double height = 4;
1079      case 4: {
1080        message.height = readDouble(bb);
1081        break;
1082      }
1083      default:
1084        skipUnknownField(bb, tag & 7);
1085    }
1086  }
1087  return message;
1088}
1089function _decodeTextSpan(bb) {
1090  let message = {};
1091  end_of_message: while (!isAtEnd(bb)) {
1092    let tag = readVarint32(bb);
1093    switch (tag >>> 3) {
1094      case 0:
1095        break end_of_message;
1096      // optional TextSpanKind kind = 1;
1097      case 1: {
1098        message.kind = decodeTextSpanKind[readVarint32(bb)];
1099        break;
1100      }
1101      // optional string text = 2;
1102      case 2: {
1103        message.text = readString(bb, readVarint32(bb));
1104        break;
1105      }
1106      default:
1107        skipUnknownField(bb, tag & 7);
1108    }
1109  }
1110  return message;
1111}
1112function _decodeShapeChange(bb) {
1113  let message = {};
1114  end_of_message: while (!isAtEnd(bb)) {
1115    let tag = readVarint32(bb);
1116    switch (tag >>> 3) {
1117      case 0:
1118        break end_of_message;
1119      // optional string name = 1;
1120      case 1: {
1121        message.name = readString(bb, readVarint32(bb));
1122        break;
1123      }
1124      // repeated ShapeAspect aspects = 2;
1125      case 2: {
1126        let values = message.aspects || (message.aspects = []);
1127        if ((tag & 7) === 2) {
1128          let outerLimit = pushTemporaryLength(bb);
1129          while (!isAtEnd(bb)) {
1130            values.push(decodeShapeAspect[readVarint32(bb)]);
1131          }
1132          bb.limit = outerLimit;
1133        } else {
1134          values.push(decodeShapeAspect[readVarint32(bb)]);
1135        }
1136        break;
1137      }
1138      // optional ShapeBox before = 3;
1139      case 3: {
1140        let limit = pushTemporaryLength(bb);
1141        message.before = _decodeShapeBox(bb);
1142        bb.limit = limit;
1143        break;
1144      }
1145      // optional ShapeBox after = 4;

1146      case 4: {
1147        let limit = pushTemporaryLength(bb);
1148        message.after = _decodeShapeBox(bb);
1149        bb.limit = limit;
1150        break;
1151      }
1152      // repeated TextSpan text = 5;
1153      case 5: {
1154        let limit = pushTemporaryLength(bb);
1155        let values = message.text || (message.text = []);
1156        values.push(_decodeTextSpan(bb));
1157        bb.limit = limit;
1158        break;
1159      }
1160      default:
1161        skipUnknownField(bb, tag & 7);
1162    }
1163  }
1164  return message;
1165}
1166function _decodeComparedSlide(bb) {
1167  let message = {};
1168  end_of_message: while (!isAtEnd(bb)) {
1169    let tag = readVarint32(bb);
1170    switch (tag >>> 3) {
1171      case 0:
1172        break end_of_message;
1173      // optional uint32 row = 1;
1174      case 1: {
1175        message.row = readVarint32(bb) >>> 0;
1176        break;
1177      }
1178      // optional SlidePair pair = 2;
1179      case 2: {
1180        let limit = pushTemporaryLength(bb);
1181        message.pair = _decodeSlidePair(bb);
1182        bb.limit = limit;
1183        break;
1184      }
1185      // optional CurrentSlide before = 3;
1186      case 3: {
1187        let limit = pushTemporaryLength(bb);
1188        message.before = _decodeCurrentSlide(bb);
1189        bb.limit = limit;
1190        break;
1191      }
1192      // optional CurrentSlide after = 4;
1193      case 4: {
1194        let limit = pushTemporaryLength(bb);
1195        message.after = _decodeCurrentSlide(bb);
1196        bb.limit = limit;
1197        break;
1198      }
1199      // repeated ShapeChange shapes = 5;
1200      case 5: {
1201        let limit = pushTemporaryLength(bb);
1202        let values = message.shapes || (message.shapes = []);
1203        values.push(_decodeShapeChange(bb));
1204        bb.limit = limit;
1205        break;
1206      }
1207      // repeated TextSpan title = 6;
1208      case 6: {
1209        let limit = pushTemporaryLength(bb);
1210        let values = message.title || (message.title = []);
1211        values.push(_decodeTextSpan(bb));
1212        bb.limit = limit;
1213        break;
1214      }
1215      // repeated TextSpan notes = 7;
1216      case 7: {
1217        let limit = pushTemporaryLength(bb);
1218        let values = message.notes || (message.notes = []);
1219        values.push(_decodeTextSpan(bb));
1220        bb.limit = limit;
1221        break;
1222      }
1223      default:
1224        skipUnknownField(bb, tag & 7);
1225    }
1226  }
1227  return message;
1228}
1229function _decodeCompareState(bb) {
1230  let message = {};
1231  end_of_message: while (!isAtEnd(bb)) {
1232    let tag = readVarint32(bb);
1233    switch (tag >>> 3) {
1234      case 0:
1235        break end_of_message;
1236      // optional CompareMode mode = 1;
1237      case 1: {
1238        message.mode = decodeCompareMode[readVarint32(bb)];
1239        break;
1240      }
1241      // optional double slider_position = 2;
1242      case 2: {
1243        message.slider_position = readDouble(bb);
1244        break;
1245      }
1246      // optional double onion_opacity = 3;
1247      case 3: {
1248        message.onion_opacity = readDouble(bb);
1249        break;
1250      }
1251      // optional bool changes_only = 4;
1252      case 4: {
1253        message.changes_only = !!readByte(bb);
1254        break;
1255      }
1256      // optional bool mark_changes = 5;
1257      case 5: {
1258        message.mark_changes = !!readByte(bb);
1259        break;
1260      }
1261      default:
1262        skipUnknownField(bb, tag & 7);
1263    }
1264  }
1265  return message;
1266}
1267function _decodeViewerState(bb) {
1268  let message = {};
1269  end_of_message: while (!isAtEnd(bb)) {
1270    let tag = readVarint32(bb);
1271    switch (tag >>> 3) {
1272      case 0:
1273        break end_of_message;
1274      // optional DeckInfo deck = 1;
1275      case 1: {
1276        let limit = pushTemporaryLength(bb);
1277        message.deck = _decodeDeckInfo(bb);
1278        bb.limit = limit;
1279        break;
1280      }
1281      // optional SourceState source = 2;
1282      case 2: {
1283        let limit = pushTemporaryLength(bb);
1284        message.source = _decodeSourceState(bb);
1285        bb.limit = limit;
1286        break;
1287      }
1288      // optional ViewState view = 3;
1289      case 3: {
1290        let limit = pushTemporaryLength(bb);
1291        message.view = _decodeViewState(bb);
1292        bb.limit = limit;
1293        break;
1294      }
1295      // optional CurrentSlide current = 4;
1296      case 4: {
1297        let limit = pushTemporaryLength(bb);
1298        message.current = _decodeCurrentSlide(bb);
1299        bb.limit = limit;
1300        break;
1301      }
1302      // optional HoverState hover = 5;
1303      case 5: {
1304        let limit = pushTemporaryLength(bb);
1305        message.hover = _decodeHoverState(bb);
1306        bb.limit = limit;
1307        break;
1308      }
1309      // optional RenderOptions render = 6;
1310      case 6: {
1311        let limit = pushTemporaryLength(bb);
1312        message.render = _decodeRenderOptions(bb);
1313        bb.limit = limit;
1314        break;
1315      }
1316      // repeated SourceState sources = 7;
1317      case 7: {
1318        let limit = pushTemporaryLength(bb);
1319        let values = message.sources || (message.sources = []);
1320        values.push(_decodeSourceState(bb));
1321        bb.limit = limit;
1322        break;
1323      }
1324      // optional DiffState diff = 8;
1325      case 8: {
1326        let limit = pushTemporaryLength(bb);

1327        message.diff = _decodeDiffState(bb);
1328        bb.limit = limit;
1329        break;
1330      }
1331      // optional ComparedSlide compared = 9;
1332      case 9: {
1333        let limit = pushTemporaryLength(bb);
1334        message.compared = _decodeComparedSlide(bb);
1335        bb.limit = limit;
1336        break;
1337      }
1338      // optional CompareState compare = 10;
1339      case 10: {
1340        let limit = pushTemporaryLength(bb);
1341        message.compare = _decodeCompareState(bb);
1342        bb.limit = limit;
1343        break;
1344      }
1345      default:
1346        skipUnknownField(bb, tag & 7);
1347    }
1348  }
1349  return message;
1350}
1351function _encodeOpen(message, bb) {
1352  let $ext = message.ext;
1353  if ($ext !== void 0) {
1354    writeVarint32(bb, 10);
1355    writeString(bb, $ext);
1356  }
1357  let $total_bytes = message.total_bytes;
1358  if ($total_bytes !== void 0) {
1359    writeVarint32(bb, 16);
1360    writeVarint64(bb, $total_bytes);
1361  }
1362  let $initial = message.initial;
1363  if ($initial !== void 0) {
1364    writeVarint32(bb, 26);
1365    writeVarint32(bb, $initial.length), writeBytes(bb, $initial);
1366  }
1367}
1368function _encodeSupplyBytes(message, bb) {
1369  let $offset = message.offset;
1370  if ($offset !== void 0) {
1371    writeVarint32(bb, 8);
1372    writeVarint64(bb, $offset);
1373  }
1374  let $data = message.data;
1375  if ($data !== void 0) {
1376    writeVarint32(bb, 18);
1377    writeVarint32(bb, $data.length), writeBytes(bb, $data);
1378  }
1379  let $lane = message.lane;
1380  if ($lane !== void 0) {
1381    writeVarint32(bb, 24);
1382    writeVarint32(bb, encodeLane[$lane]);
1383  }
1384}
1385function _encodeLaneSource(message, bb) {
1386  let $ext = message.ext;
1387  if ($ext !== void 0) {
1388    writeVarint32(bb, 10);
1389    writeString(bb, $ext);
1390  }
1391  let $total_bytes = message.total_bytes;
1392  if ($total_bytes !== void 0) {
1393    writeVarint32(bb, 16);
1394    writeVarint64(bb, $total_bytes);
1395  }
1396  let $initial = message.initial;
1397  if ($initial !== void 0) {
1398    writeVarint32(bb, 26);
1399    writeVarint32(bb, $initial.length), writeBytes(bb, $initial);
1400  }
1401}
1402function _encodeOpenDiff(message, bb) {
1403  let $before = message.before;
1404  if ($before !== void 0) {
1405    writeVarint32(bb, 10);
1406    let nested = popByteBuffer();
1407    _encodeLaneSource($before, nested);
1408    writeVarint32(bb, nested.limit);
1409    writeByteBuffer(bb, nested);
1410    pushByteBuffer(nested);
1411  }
1412  let $after = message.after;
1413  if ($after !== void 0) {
1414    writeVarint32(bb, 18);
1415    let nested = popByteBuffer();
1416    _encodeLaneSource($after, nested);
1417    writeVarint32(bb, nested.limit);
1418    writeByteBuffer(bb, nested);
1419    pushByteBuffer(nested);
1420  }
1421}
1422function _encodeSetCompareOptions(message, bb) {
1423  let $mode = message.mode;
1424  if ($mode !== void 0) {
1425    writeVarint32(bb, 8);
1426    writeVarint32(bb, encodeCompareMode[$mode]);
1427  }
1428  let $slider_position = message.slider_position;
1429  if ($slider_position !== void 0) {
1430    writeVarint32(bb, 17);
1431    writeDouble(bb, $slider_position);
1432  }
1433  let $onion_opacity = message.onion_opacity;
1434  if ($onion_opacity !== void 0) {
1435    writeVarint32(bb, 25);
1436    writeDouble(bb, $onion_opacity);
1437  }
1438  let $changes_only = message.changes_only;
1439  if ($changes_only !== void 0) {
1440    writeVarint32(bb, 32);
1441    writeByte(bb, $changes_only ? 1 : 0);
1442  }
1443  let $mark_changes = message.mark_changes;
1444  if ($mark_changes !== void 0) {
1445    writeVarint32(bb, 40);
1446    writeByte(bb, $mark_changes ? 1 : 0);
1447  }
1448}
1449function _encodeUnload(message, bb) {
1450}
1451function _encodeSetView(message, bb) {
1452  let $mode = message.mode;
1453  if ($mode !== void 0) {
1454    writeVarint32(bb, 8);
1455    writeVarint32(bb, encodeViewMode[$mode]);
1456  }
1457  let $slide = message.slide;
1458  if ($slide !== void 0) {
1459    writeVarint32(bb, 16);
1460    writeVarint32(bb, $slide);
1461  }
1462  let $scroll_y = message.scroll_y;
1463  if ($scroll_y !== void 0) {
1464    writeVarint32(bb, 29);
1465    writeFloat(bb, $scroll_y);
1466  }
1467}
1468function _encodeStep(message, bb) {
1469  let $slides = message.slides;
1470  if ($slides !== void 0) {
1471    writeVarint32(bb, 8);
1472    writeVarint32ZigZag(bb, $slides);
1473  }
1474  let $rows = message.rows;
1475  if ($rows !== void 0) {
1476    writeVarint32(bb, 16);
1477    writeVarint32ZigZag(bb, $rows);
1478  }
1479  let $changes = message.changes;
1480  if ($changes !== void 0) {
1481    writeVarint32(bb, 24);
1482    writeVarint32ZigZag(bb, $changes);
1483  }
1484}
1485function _encodeSetRenderOptions(message, bb) {
1486  let $color_scheme = message.color_scheme;
1487  if ($color_scheme !== void 0) {
1488    writeVarint32(bb, 8);
1489    writeVarint32(bb, encodeColorScheme[$color_scheme]);
1490  }
1491  let $ui_scale = message.ui_scale;
1492  if ($ui_scale !== void 0) {
1493    writeVarint32(bb, 21);
1494    writeFloat(bb, $ui_scale);
1495  }
1496}
1497function _encodeResize(message, bb) {
1498  let $width = message.width;
1499  if ($width !== void 0) {
1500    writeVarint32(bb, 8);
1501    writeVarint32(bb, $width);
1502  }
1503  let $height = message.height;
1504  if ($height !== void 0) {
1505    writeVarint32(bb, 16);
1506    writeVarint32(bb, $height);
1507  }
1508}
1509function _encodePointerMove(message, bb) {
1510  let $x = message.x;
1511  if ($x !== void 0) {
1512    writeVarint32(bb, 13);
1513    writeFloat(bb, $x);
1514  }
1515  let $y = message.y;
1516  if ($y !== void 0) {
1517    writeVarint32(bb, 21);
1518    writeFloat(bb, $y);
1519  }
1520}
1521function _encodePointerButton(message, bb) {
1522  let $button = message.button;
1523  if ($button !== void 0) {
1524    writeVarint32(bb, 8);
1525    writeVarint32(bb, $button);
1526  }
1527  let $x = message.x;
1528  if ($x !== void 0) {
1529    writeVarint32(bb, 21);
1530    writeFloat(bb, $x);
1531  }
1532  let $y = message.y;
1533  if ($y !== void 0) {
1534    writeVarint32(bb, 29);
1535    writeFloat(bb, $y);
1536  }
1537  let $pressed = message.pressed;
1538  if ($pressed !== void 0) {
1539    writeVarint32(bb, 32);
1540    writeByte(bb, $pressed ? 1 : 0);
1541  }
1542}
1543function _encodePointerLeave(message, bb) {
1544}
1545function _encodeWheel(message, bb) {
1546  let $dx = message.dx;
1547  if ($dx !== void 0) {
1548    writeVarint32(bb, 13);
1549    writeFloat(bb, $dx);
1550  }
1551  let $dy = message.dy;
1552  if ($dy !== void 0) {
1553    writeVarint32(bb, 21);
1554    writeFloat(bb, $dy);
1555  }
1556}
1557function _encodeInput(message, bb) {
1558  let $pointer_move = message.pointer_move;
1559  if ($pointer_move !== void 0) {
1560    writeVarint32(bb, 10);
1561    let nested = popByteBuffer();
1562    _encodePointerMove($pointer_move, nested);
1563    writeVarint32(bb, nested.limit);
1564    writeByteBuffer(bb, nested);
1565    pushByteBuffer(nested);
1566  }
1567  let $pointer_button = message.pointer_button;
1568  if ($pointer_button !== void 0) {
1569    writeVarint32(bb, 18);
1570    let nested = popByteBuffer();
1571    _encodePointerButton($pointer_button, nested);
1572    writeVarint32(bb, nested.limit);
1573    writeByteBuffer(bb, nested);
1574    pushByteBuffer(nested);
1575  }
1576  let $pointer_leave = message.pointer_leave;
1577  if ($pointer_leave !== void 0) {
1578    writeVarint32(bb, 26);
1579    let nested = popByteBuffer();
1580    _encodePointerLeave($pointer_leave, nested);
1581    writeVarint32(bb, nested.limit);
1582    writeByteBuffer(bb, nested);
1583    pushByteBuffer(nested);
1584  }
1585  let $wheel = message.wheel;
1586  if ($wheel !== void 0) {
1587    writeVarint32(bb, 34);
1588    let nested = popByteBuffer();
1589    _encodeWheel($wheel, nested);
1590    writeVarint32(bb, nested.limit);
1591    writeByteBuffer(bb, nested);
1592    pushByteBuffer(nested);
1593  }
1594}
1595function _encodeGetState(message, bb) {
1596}
1597function encodeCommand(message) {
1598  let bb = popByteBuffer();
1599  _encodeCommand(message, bb);
1600  return toUint8Array(bb);
1601}
1602function _encodeCommand(message, bb) {
1603  let $get_state = message.get_state;
1604  if ($get_state !== void 0) {
1605    writeVarint32(bb, 10);
1606    let nested = popByteBuffer();
1607    _encodeGetState($get_state, nested);
1608    writeVarint32(bb, nested.limit);
1609    writeByteBuffer(bb, nested);
1610    pushByteBuffer(nested);
1611  }
1612  let $open = message.open;
1613  if ($open !== void 0) {
1614    writeVarint32(bb, 18);
1615    let nested = popByteBuffer();
1616    _encodeOpen($open, nested);
1617    writeVarint32(bb, nested.limit);
1618    writeByteBuffer(bb, nested);
1619    pushByteBuffer(nested);
1620  }
1621  let $supply_bytes = message.supply_bytes;
1622  if ($supply_bytes !== void 0) {
1623    writeVarint32(bb, 26);
1624    let nested = popByteBuffer();
1625    _encodeSupplyBytes($supply_bytes, nested);
1626    writeVarint32(bb, nested.limit);
1627    writeByteBuffer(bb, nested);
1628    pushByteBuffer(nested);
1629  }
1630  let $unload = message.unload;
1631  if ($unload !== void 0) {
1632    writeVarint32(bb, 34);
1633    let nested = popByteBuffer();
1634    _encodeUnload($unload, nested);
1635    writeVarint32(bb, nested.limit);
1636    writeByteBuffer(bb, nested);
1637    pushByteBuffer(nested);
1638  }
1639  let $set_view = message.set_view;
1640  if ($set_view !== void 0) {
1641    writeVarint32(bb, 42);
1642    let nested = popByteBuffer();
1643    _encodeSetView($set_view, nested);
1644    writeVarint32(bb, nested.limit);
1645    writeByteBuffer(bb, nested);
1646    pushByteBuffer(nested);
1647  }
1648  let $set_render_options = message.set_render_options;
1649  if ($set_render_options !== void 0) {
1650    writeVarint32(bb, 50);
1651    let nested = popByteBuffer();
1652    _encodeSetRenderOptions($set_render_options, nested);
1653    writeVarint32(bb, nested.limit);
1654    writeByteBuffer(bb, nested);
1655    pushByteBuffer(nested);
1656  }
1657  let $resize = message.resize;
1658  if ($resize !== void 0) {
1659    writeVarint32(bb, 58);
1660    let nested = popByteBuffer();
1661    _encodeResize($resize, nested);
1662    writeVarint32(bb, nested.limit);
1663    writeByteBuffer(bb, nested);
1664    pushByteBuffer(nested);
1665  }
1666  let $input = message.input;
1667  if ($input !== void 0) {
1668    writeVarint32(bb, 66);
1669    let nested = popByteBuffer();
1670    _encodeInput($input, nested);
1671    writeVarint32(bb, nested.limit);
1672    writeByteBuffer(bb, nested);
1673    pushByteBuffer(nested);
1674  }
1675  let $step = message.step;
1676  if ($step !== void 0) {
1677    writeVarint32(bb, 74);
1678    let nested = popByteBuffer();
1679    _encodeStep($step, nested);
1680    writeVarint32(bb, nested.limit);
1681    writeByteBuffer(bb, nested);
1682    pushByteBuffer(nested);
1683  }
1684  let $open_diff = message.open_diff;
1685  if ($open_diff !== void 0) {
1686    writeVarint32(bb, 82);
1687    let nested = popByteBuffer();
1688    _encodeOpenDiff($open_diff, nested);
1689    writeVarint32(bb, nested.limit);
1690    writeByteBuffer(bb, nested);
1691    pushByteBuffer(nested);
1692  }
1693  let $set_compare_options = message.set_compare_options;
1694  if ($set_compare_options !== void 0) {
1695    writeVarint32(bb, 90);
1696    let nested = popByteBuffer();
1697    _encodeSetCompareOptions($set_compare_options, nested);
1698    writeVarint32(bb, nested.limit);
1699    writeByteBuffer(bb, nested);
1700    pushByteBuffer(nested);
1701  }
1702}
1703function _decodeOk(bb) {
1704  let message = {};
1705  end_of_message: while (!isAtEnd(bb)) {
1706    let tag = readVarint32(bb);
1707    switch (tag >>> 3) {
1708      case 0:
1709        break end_of_message;
1710      default:
1711        skipUnknownField(bb, tag & 7);
1712    }
1713  }
1714  return message;
1715}
1716function _decodeError(bb) {
1717  let message = {};
1718  end_of_message: while (!isAtEnd(bb)) {
1719    let tag = readVarint32(bb);
1720    switch (tag >>> 3) {
1721      case 0:
1722        break end_of_message;
1723      // optional uint32 code = 1;
1724      case 1: {
1725        message.code = readVarint32(bb) >>> 0;
1726        break;
1727      }
1728      // optional string message = 2;
1729      case 2: {
1730        message.message = readString(bb, readVarint32(bb));
1731        break;
1732      }
1733      default:
1734        skipUnknownField(bb, tag & 7);
1735    }
1736  }
1737  return message;
1738}
1739function decodeCommandResult(binary) {
1740  return _decodeCommandResult(wrapByteBuffer(binary));
1741}
1742function _decodeCommandResult(bb) {
1743  let message = {};
1744  end_of_message: while (!isAtEnd(bb)) {
1745    let tag = readVarint32(bb);
1746    switch (tag >>> 3) {
1747      case 0:
1748        break end_of_message;
1749      // optional Ok ok = 1;
1750      case 1: {
1751        let limit = pushTemporaryLength(bb);
1752        message.ok = _decodeOk(bb);
1753        bb.limit = limit;
1754        break;
1755      }
1756      // optional Error error = 2;
1757      case 2: {
1758        let limit = pushTemporaryLength(bb);
1759        message.error = _decodeError(bb);
1760        bb.limit = limit;
1761        break;
1762      }
1763      // optional ViewerState state = 3;
1764      case 3: {
1765        let limit = pushTemporaryLength(bb);
1766        message.state = _decodeViewerState(bb);
1767        bb.limit = limit;
1768        break;
1769      }
1770      default:
1771        skipUnknownField(bb, tag & 7);
1772    }
1773  }
1774  return message;
1775}
1776function _decodeReady(bb) {
1777  let message = {};
1778  end_of_message: while (!isAtEnd(bb)) {
1779    let tag = readVarint32(bb);
1780    switch (tag >>> 3) {
1781      case 0:
1782        break end_of_message;
1783      default:
1784        skipUnknownField(bb, tag & 7);
1785    }
1786  }
1787  return message;
1788}
1789function _decodeDeckChanged(bb) {
1790  let message = {};
1791  end_of_message: while (!isAtEnd(bb)) {
1792    let tag = readVarint32(bb);
1793    switch (tag >>> 3) {
1794      case 0:
1795        break end_of_message;
1796      // optional DeckInfo deck = 1;
1797      case 1: {
1798        let limit = pushTemporaryLength(bb);
1799        message.deck = _decodeDeckInfo(bb);
1800        bb.limit = limit;
1801        break;
1802      }
1803      default:
1804        skipUnknownField(bb, tag & 7);
1805    }
1806  }
1807  return message;
1808}
1809function _decodeSourceChanged(bb) {
1810  let message = {};
1811  end_of_message: while (!isAtEnd(bb)) {
1812    let tag = readVarint32(bb);
1813    switch (tag >>> 3) {
1814      case 0:
1815        break end_of_message;
1816      // optional SourceState source = 1;
1817      case 1: {
1818        let limit = pushTemporaryLength(bb);
1819        message.source = _decodeSourceState(bb);
1820        bb.limit = limit;
1821        break;
1822      }
1823      // repeated SourceState sources = 2;
1824      case 2: {
1825        let limit = pushTemporaryLength(bb);
1826        let values = message.sources || (message.sources = []);
1827        values.push(_decodeSourceState(bb));
1828        bb.limit = limit;
1829        break;
1830      }
1831      default:
1832        skipUnknownField(bb, tag & 7);
1833    }
1834  }
1835  return message;
1836}
1837function _decodeViewChanged(bb) {
1838  let message = {};
1839  end_of_message: while (!isAtEnd(bb)) {
1840    let tag = readVarint32(bb);
1841    switch (tag >>> 3) {
1842      case 0:
1843        break end_of_message;
1844      // optional ViewState view = 1;
1845      case 1: {
1846        let limit = pushTemporaryLength(bb);
1847        message.view = _decodeViewState(bb);
1848        bb.limit = limit;
1849        break;
1850      }
1851      default:
1852        skipUnknownField(bb, tag & 7);
1853    }
1854  }
1855  return message;
1856}
1857function _decodeCurrentChanged(bb) {
1858  let message = {};
1859  end_of_message: while (!isAtEnd(bb)) {
1860    let tag = readVarint32(bb);
1861    switch (tag >>> 3) {
1862      case 0:
1863        break end_of_message;
1864      // optional CurrentSlide current = 1;
1865      case 1: {
1866        let limit = pushTemporaryLength(bb);
1867        message.current = _decodeCurrentSlide(bb);
1868        bb.limit = limit;
1869        break;
1870      }
1871      default:
1872        skipUnknownField(bb, tag & 7);
1873    }
1874  }
1875  return message;
1876}
1877function _decodeHoverChanged(bb) {
1878  let message = {};
1879  end_of_message: while (!isAtEnd(bb)) {
1880    let tag = readVarint32(bb);
1881    switch (tag >>> 3) {
1882      case 0:
1883        break end_of_message;
1884      // optional HoverState hover = 1;
1885      case 1: {
1886        let limit = pushTemporaryLength(bb);
1887        message.hover = _decodeHoverState(bb);
1888        bb.limit = limit;
1889        break;
1890      }
1891      default:
1892        skipUnknownField(bb, tag & 7);
1893    }
1894  }
1895  return message;
1896}
1897function _decodeRenderChanged(bb) {
1898  let message = {};
1899  end_of_message: while (!isAtEnd(bb)) {
1900    let tag = readVarint32(bb);
1901    switch (tag >>> 3) {
1902      case 0:
1903        break end_of_message;
1904      // optional RenderOptions render = 1;
1905      case 1: {
1906        let limit = pushTemporaryLength(bb);
1907        message.render = _decodeRenderOptions(bb);
1908        bb.limit = limit;
1909        break;
1910      }
1911      default:
1912        skipUnknownField(bb, tag & 7);
1913    }
1914  }
1915  return message;
1916}
1917function _decodeDiffChanged(bb) {
1918  let message = {};
1919  end_of_message: while (!isAtEnd(bb)) {
1920    let tag = readVarint32(bb);
1921    switch (tag >>> 3) {
1922      case 0:
1923        break end_of_message;
1924      // optional DiffState diff = 1;
1925      case 1: {
1926        let limit = pushTemporaryLength(bb);

1927        message.diff = _decodeDiffState(bb);
1928        bb.limit = limit;
1929        break;
1930      }
1931      default:
1932        skipUnknownField(bb, tag & 7);
1933    }
1934  }
1935  return message;
1936}
1937function _decodeComparedChanged(bb) {
1938  let message = {};
1939  end_of_message: while (!isAtEnd(bb)) {
1940    let tag = readVarint32(bb);
1941    switch (tag >>> 3) {
1942      case 0:
1943        break end_of_message;
1944      // optional ComparedSlide compared = 1;
1945      case 1: {
1946        let limit = pushTemporaryLength(bb);
1947        message.compared = _decodeComparedSlide(bb);
1948        bb.limit = limit;
1949        break;
1950      }
1951      default:
1952        skipUnknownField(bb, tag & 7);
1953    }
1954  }
1955  return message;
1956}
1957function _decodeCompareChanged(bb) {
1958  let message = {};
1959  end_of_message: while (!isAtEnd(bb)) {
1960    let tag = readVarint32(bb);
1961    switch (tag >>> 3) {
1962      case 0:
1963        break end_of_message;
1964      // optional CompareState compare = 1;
1965      case 1: {
1966        let limit = pushTemporaryLength(bb);
1967        message.compare = _decodeCompareState(bb);
1968        bb.limit = limit;
1969        break;
1970      }
1971      default:
1972        skipUnknownField(bb, tag & 7);
1973    }
1974  }
1975  return message;
1976}
1977function _decodeEvent(bb) {
1978  let message = {};
1979  end_of_message: while (!isAtEnd(bb)) {
1980    let tag = readVarint32(bb);
1981    switch (tag >>> 3) {
1982      case 0:
1983        break end_of_message;
1984      // optional Ready ready = 1;
1985      case 1: {
1986        let limit = pushTemporaryLength(bb);
1987        message.ready = _decodeReady(bb);
1988        bb.limit = limit;
1989        break;
1990      }
1991      // optional Error error = 2;
1992      case 2: {
1993        let limit = pushTemporaryLength(bb);
1994        message.error = _decodeError(bb);
1995        bb.limit = limit;
1996        break;
1997      }
1998      // optional DeckChanged deck_changed = 3;
1999      case 3: {
2000        let limit = pushTemporaryLength(bb);
2001        message.deck_changed = _decodeDeckChanged(bb);
2002        bb.limit = limit;
2003        break;
2004      }
2005      // optional SourceChanged source_changed = 4;
2006      case 4: {
2007        let limit = pushTemporaryLength(bb);
2008        message.source_changed = _decodeSourceChanged(bb);
2009        bb.limit = limit;
2010        break;
2011      }
2012      // optional ViewChanged view_changed = 5;
2013      case 5: {
2014        let limit = pushTemporaryLength(bb);
2015        message.view_changed = _decodeViewChanged(bb);
2016        bb.limit = limit;
2017        break;
2018      }
2019      // optional CurrentChanged current_changed = 6;
2020      case 6: {
2021        let limit = pushTemporaryLength(bb);
2022        message.current_changed = _decodeCurrentChanged(bb);
2023        bb.limit = limit;
2024        break;
2025      }
2026      // optional HoverChanged hover_changed = 7;
2027      case 7: {
2028        let limit = pushTemporaryLength(bb);
2029        message.hover_changed = _decodeHoverChanged(bb);
2030        bb.limit = limit;
2031        break;
2032      }
2033      // optional RenderChanged render_changed = 8;
2034      case 8: {
2035        let limit = pushTemporaryLength(bb);
2036        message.render_changed = _decodeRenderChanged(bb);
2037        bb.limit = limit;
2038        break;
2039      }
2040      // optional DiffChanged diff_changed = 9;
2041      case 9: {
2042        let limit = pushTemporaryLength(bb);
2043        message.diff_changed = _decodeDiffChanged(bb);
2044        bb.limit = limit;
2045        break;
2046      }
2047      // optional ComparedChanged compared_changed = 10;
2048      case 10: {
2049        let limit = pushTemporaryLength(bb);
2050        message.compared_changed = _decodeComparedChanged(bb);
2051        bb.limit = limit;
2052        break;
2053      }
2054      // optional CompareChanged compare_changed = 11;
2055      case 11: {
2056        let limit = pushTemporaryLength(bb);
2057        message.compare_changed = _decodeCompareChanged(bb);
2058        bb.limit = limit;
2059        break;
2060      }
2061      default:
2062        skipUnknownField(bb, tag & 7);
2063    }
2064  }
2065  return message;
2066}
2067function decodeEventBatch(binary) {
2068  return _decodeEventBatch(wrapByteBuffer(binary));
2069}
2070function _decodeEventBatch(bb) {
2071  let message = {};
2072  end_of_message: while (!isAtEnd(bb)) {
2073    let tag = readVarint32(bb);
2074    switch (tag >>> 3) {
2075      case 0:
2076        break end_of_message;
2077      // repeated Event events = 1;
2078      case 1: {
2079        let limit = pushTemporaryLength(bb);
2080        let values = message.events || (message.events = []);
2081        values.push(_decodeEvent(bb));
2082        bb.limit = limit;
2083        break;
2084      }
2085      default:
2086        skipUnknownField(bb, tag & 7);
2087    }
2088  }
2089  return message;
2090}
2091function pushTemporaryLength(bb) {
2092  let length = readVarint32(bb);
2093  let limit = bb.limit;
2094  bb.limit = bb.offset + length;
2095  return limit;
2096}
2097function skipUnknownField(bb, type) {
2098  switch (type) {
2099    case 0:
2100      while (readByte(bb) & 128) {
2101      }
2102      break;
2103    case 2:
2104      skip(bb, readVarint32(bb));
2105      break;
2106    case 5:
2107      skip(bb, 4);
2108      break;
2109    case 1:
2110      skip(bb, 8);
2111      break;
2112    default:
2113      throw new Error("Unimplemented type: " + type);
2114  }
2115}
2116var f32 = new Float32Array(1);
2117var f32_u8 = new Uint8Array(f32.buffer);
2118var f64 = new Float64Array(1);
2119var f64_u8 = new Uint8Array(f64.buffer);
2120var bbStack = [];
2121function popByteBuffer() {
2122  const bb = bbStack.pop();
2123  if (!bb) return { bytes: new Uint8Array(64), offset: 0, limit: 0 };
2124  bb.offset = bb.limit = 0;
2125  return bb;
2126}
2127function pushByteBuffer(bb) {
2128  bbStack.push(bb);
2129}
2130function wrapByteBuffer(bytes) {
2131  return { bytes, offset: 0, limit: bytes.length };
2132}
2133function toUint8Array(bb) {
2134  let bytes = bb.bytes;
2135  let limit = bb.limit;
2136  return bytes.length === limit ? bytes : bytes.subarray(0, limit);
2137}
2138function skip(bb, offset) {
2139  if (bb.offset + offset > bb.limit) {
2140    throw new Error("Skip past limit");
2141  }
2142  bb.offset += offset;
2143}
2144function isAtEnd(bb) {
2145  return bb.offset >= bb.limit;
2146}
2147function grow(bb, count) {
2148  let bytes = bb.bytes;
2149  let offset = bb.offset;
2150  let limit = bb.limit;
2151  let finalOffset = offset + count;
2152  if (finalOffset > bytes.length) {
2153    let newBytes = new Uint8Array(finalOffset * 2);
2154    newBytes.set(bytes);
2155    bb.bytes = newBytes;
2156  }
2157  bb.offset = finalOffset;
2158  if (finalOffset > limit) {
2159    bb.limit = finalOffset;
2160  }
2161  return offset;
2162}
2163function advance(bb, count) {
2164  let offset = bb.offset;
2165  if (offset + count > bb.limit) {
2166    throw new Error("Read past limit");
2167  }
2168  bb.offset += count;
2169  return offset;
2170}
2171function writeBytes(bb, buffer) {
2172  let offset = grow(bb, buffer.length);
2173  bb.bytes.set(buffer, offset);
2174}
2175function readString(bb, count) {
2176  let offset = advance(bb, count);
2177  let fromCharCode = String.fromCharCode;
2178  let bytes = bb.bytes;
2179  let invalid = "\uFFFD";
2180  let text = "";
2181  for (let i = 0; i < count; i++) {

2182    let c1 = bytes[i + offset], c2, c3, c4, c;
2183    if ((c1 & 128) === 0) {
2184      text += fromCharCode(c1);
2185    } else if ((c1 & 224) === 192) {
2186      if (i + 1 >= count) text += invalid;
2187      else {
2188        c2 = bytes[i + offset + 1];
2189        if ((c2 & 192) !== 128) text += invalid;
2190        else {
2191          c = (c1 & 31) << 6 | c2 & 63;
2192          if (c < 128) text += invalid;
2193          else {
2194            text += fromCharCode(c);
2195            i++;
2196          }
2197        }
2198      }
2199    } else if ((c1 & 240) == 224) {
2200      if (i + 2 >= count) text += invalid;
2201      else {
2202        c2 = bytes[i + offset + 1];
2203        c3 = bytes[i + offset + 2];
2204        if (((c2 | c3 << 8) & 49344) !== 32896) text += invalid;
2205        else {
2206          c = (c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63;
2207          if (c < 2048 || c >= 55296 && c <= 57343) text += invalid;
2208          else {
2209            text += fromCharCode(c);
2210            i += 2;
2211          }
2212        }
2213      }
2214    } else if ((c1 & 248) == 240) {
2215      if (i + 3 >= count) text += invalid;
2216      else {
2217        c2 = bytes[i + offset + 1];
2218        c3 = bytes[i + offset + 2];
2219        c4 = bytes[i + offset + 3];
2220        if (((c2 | c3 << 8 | c4 << 16) & 12632256) !== 8421504) text += invalid;
2221        else {
2222          c = (c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63;
2223          if (c < 65536 || c > 1114111) text += invalid;
2224          else {
2225            c -= 65536;
2226            text += fromCharCode((c >> 10) + 55296, (c & 1023) + 56320);
2227            i += 3;
2228          }
2229        }
2230      }
2231    } else text += invalid;
2232  }
2233  return text;
2234}
2235function writeString(bb, text) {
2236  let n = text.length;
2237  let byteCount = 0;
2238  for (let i = 0; i < n; i++) {

2239    let c = text.charCodeAt(i);
2240    if (c >= 55296 && c <= 56319 && i + 1 < n) {
2241      c = (c << 10) + text.charCodeAt(++i) - 56613888;
2242    }
2243    byteCount += c < 128 ? 1 : c < 2048 ? 2 : c < 65536 ? 3 : 4;
2244  }
2245  writeVarint32(bb, byteCount);
2246  let offset = grow(bb, byteCount);
2247  let bytes = bb.bytes;
2248  for (let i = 0; i < n; i++) {
2249    let c = text.charCodeAt(i);
2250    if (c >= 55296 && c <= 56319 && i + 1 < n) {
2251      c = (c << 10) + text.charCodeAt(++i) - 56613888;
2252    }
2253    if (c < 128) {
2254      bytes[offset++] = c;
2255    } else {
2256      if (c < 2048) {
2257        bytes[offset++] = c >> 6 & 31 | 192;
2258      } else {
2259        if (c < 65536) {
2260          bytes[offset++] = c >> 12 & 15 | 224;
2261        } else {
2262          bytes[offset++] = c >> 18 & 7 | 240;
2263          bytes[offset++] = c >> 12 & 63 | 128;
2264        }
2265        bytes[offset++] = c >> 6 & 63 | 128;
2266      }
2267      bytes[offset++] = c & 63 | 128;
2268    }
2269  }
2270}
2271function writeByteBuffer(bb, buffer) {
2272  let offset = grow(bb, buffer.limit);
2273  let from = bb.bytes;
2274  let to = buffer.bytes;
2275  for (let i = 0, n = buffer.limit; i < n; i++) {
2276    from[i + offset] = to[i];
2277  }
2278}
2279function readByte(bb) {
2280  return bb.bytes[advance(bb, 1)];
2281}
2282function writeByte(bb, value) {
2283  let offset = grow(bb, 1);
2284  bb.bytes[offset] = value;
2285}
2286function readFloat(bb) {
2287  let offset = advance(bb, 4);
2288  let bytes = bb.bytes;
2289  f32_u8[0] = bytes[offset++];
2290  f32_u8[1] = bytes[offset++];
2291  f32_u8[2] = bytes[offset++];
2292  f32_u8[3] = bytes[offset++];
2293  return f32[0];
2294}
2295function writeFloat(bb, value) {
2296  let offset = grow(bb, 4);
2297  let bytes = bb.bytes;
2298  f32[0] = value;
2299  bytes[offset++] = f32_u8[0];
2300  bytes[offset++] = f32_u8[1];
2301  bytes[offset++] = f32_u8[2];
2302  bytes[offset++] = f32_u8[3];
2303}
2304function readDouble(bb) {
2305  let offset = advance(bb, 8);
2306  let bytes = bb.bytes;
2307  f64_u8[0] = bytes[offset++];
2308  f64_u8[1] = bytes[offset++];
2309  f64_u8[2] = bytes[offset++];
2310  f64_u8[3] = bytes[offset++];
2311  f64_u8[4] = bytes[offset++];
2312  f64_u8[5] = bytes[offset++];
2313  f64_u8[6] = bytes[offset++];
2314  f64_u8[7] = bytes[offset++];
2315  return f64[0];
2316}
2317function writeDouble(bb, value) {
2318  let offset = grow(bb, 8);
2319  let bytes = bb.bytes;
2320  f64[0] = value;
2321  bytes[offset++] = f64_u8[0];
2322  bytes[offset++] = f64_u8[1];
2323  bytes[offset++] = f64_u8[2];
2324  bytes[offset++] = f64_u8[3];
2325  bytes[offset++] = f64_u8[4];
2326  bytes[offset++] = f64_u8[5];
2327  bytes[offset++] = f64_u8[6];
2328  bytes[offset++] = f64_u8[7];
2329}
2330function readVarint32(bb) {
2331  let c = 0;
2332  let value = 0;
2333  let b;
2334  do {
2335    b = readByte(bb);
2336    if (c < 32) value |= (b & 127) << c;
2337    c += 7;
2338  } while (b & 128);
2339  return value;
2340}
2341function writeVarint32(bb, value) {
2342  value >>>= 0;
2343  while (value >= 128) {
2344    writeByte(bb, value & 127 | 128);
2345    value >>>= 7;
2346  }
2347  writeByte(bb, value);
2348}
2349function readVarint64(bb, unsigned) {
2350  let part0 = 0;
2351  let part1 = 0;
2352  let part2 = 0;
2353  let b;
2354  b = readByte(bb);
2355  part0 = b & 127;
2356  if (b & 128) {
2357    b = readByte(bb);
2358    part0 |= (b & 127) << 7;
2359    if (b & 128) {
2360      b = readByte(bb);
2361      part0 |= (b & 127) << 14;
2362      if (b & 128) {
2363        b = readByte(bb);
2364        part0 |= (b & 127) << 21;
2365        if (b & 128) {
2366          b = readByte(bb);
2367          part1 = b & 127;
2368          if (b & 128) {
2369            b = readByte(bb);
2370            part1 |= (b & 127) << 7;
2371            if (b & 128) {
2372              b = readByte(bb);
2373              part1 |= (b & 127) << 14;
2374              if (b & 128) {
2375                b = readByte(bb);
2376                part1 |= (b & 127) << 21;
2377                if (b & 128) {
2378                  b = readByte(bb);
2379                  part2 = b & 127;
2380                  if (b & 128) {
2381                    b = readByte(bb);
2382                    part2 |= (b & 127) << 7;
2383                  }
2384                }
2385              }
2386            }
2387          }
2388        }
2389      }
2390    }
2391  }
2392  return {
2393    low: part0 | part1 << 28,
2394    high: part1 >>> 4 | part2 << 24,
2395    unsigned
2396  };
2397}
2398function writeVarint64(bb, value) {
2399  let part0 = value.low >>> 0;
2400  let part1 = (value.low >>> 28 | value.high << 4) >>> 0;
2401  let part2 = value.high >>> 24;
2402  let size = part2 === 0 ? part1 === 0 ? part0 < 1 << 14 ? part0 < 1 << 7 ? 1 : 2 : part0 < 1 << 21 ? 3 : 4 : part1 < 1 << 14 ? part1 < 1 << 7 ? 5 : 6 : part1 < 1 << 21 ? 7 : 8 : part2 < 1 << 7 ? 9 : 10;
2403  let offset = grow(bb, size);
2404  let bytes = bb.bytes;
2405  switch (size) {
2406    case 10:
2407      bytes[offset + 9] = part2 >>> 7 & 1;
2408    case 9:
2409      bytes[offset + 8] = size !== 9 ? part2 | 128 : part2 & 127;
2410    case 8:
2411      bytes[offset + 7] = size !== 8 ? part1 >>> 21 | 128 : part1 >>> 21 & 127;
2412    case 7:
2413      bytes[offset + 6] = size !== 7 ? part1 >>> 14 | 128 : part1 >>> 14 & 127;
2414    case 6:
2415      bytes[offset + 5] = size !== 6 ? part1 >>> 7 | 128 : part1 >>> 7 & 127;
2416    case 5:
2417      bytes[offset + 4] = size !== 5 ? part1 | 128 : part1 & 127;
2418    case 4:
2419      bytes[offset + 3] = size !== 4 ? part0 >>> 21 | 128 : part0 >>> 21 & 127;
2420    case 3:
2421      bytes[offset + 2] = size !== 3 ? part0 >>> 14 | 128 : part0 >>> 14 & 127;
2422    case 2:
2423      bytes[offset + 1] = size !== 2 ? part0 >>> 7 | 128 : part0 >>> 7 & 127;
2424    case 1:
2425      bytes[offset] = size !== 1 ? part0 | 128 : part0 & 127;
2426  }
2427}
2428function writeVarint32ZigZag(bb, value) {
2429  writeVarint32(bb, value << 1 ^ value >> 31);
2430}
2431

2432// ../../../viewers/slides/bindings/wasm/web-harness/slides-api.js
2433function longToNumber(v) {
2434  if (v === void 0 || v === null) return 0;
2435  if (typeof v === "number") return v;
2436  return (v.high >>> 0) * 4294967296 + (v.low >>> 0);
2437}
2438function toLong(n) {
2439  const v = Math.max(0, Math.trunc(Number(n) || 0));
2440  return { low: v >>> 0, high: Math.floor(v / 4294967296) >>> 0, unsigned: true };
2441}
2442function normRange(r) {
2443  return { offset: longToNumber(r.offset), length: longToNumber(r.length) };
2444}
2445function normDeck(d) {
2446  if (!d) return null;
2447  return {
2448    kind: d.kind ?? "DECK_KIND_UNSPECIFIED",
2449    macroEnabled: d.macro_enabled ?? false,
2450    // EMU, 914400 to the inch.
2451    slideWidth: longToNumber(d.slide_width),
2452    slideHeight: longToNumber(d.slide_height),
2453    slides: (d.slides ?? []).map((s) => ({
2454      number: s.number ?? 0,
2455      hidden: s.hidden ?? false,
2456      title: s.title ?? "",
2457      hasNotes: s.has_notes ?? false,
2458      unreadable: s.unreadable ?? false
2459    })),
2460    title: d.title ?? "",
2461    application: d.application ?? "",
2462    fonts: (d.fonts ?? []).map((f) => ({
2463      requested: f.requested ?? "",
2464      used: f.used ?? "",
2465      metricCompatible: f.metric_compatible ?? false
2466    })),
2467    unrendered: (d.unrendered ?? []).map((u) => ({
2468      kind: u.kind ?? "UNRENDERED_UNSPECIFIED",
2469      count: u.count ?? 0
2470    })),
2471    loading: d.loading ?? false
2472  };
2473}
2474function normSource(s) {
2475  if (!s) return null;
2476  return {
2477    bytesTotal: longToNumber(s.bytes_total),
2478    bytesHave: longToNumber(s.bytes_have),
2479    have: (s.have ?? []).map(normRange),
2480    wanted: (s.wanted ?? []).map(normRange),
2481    complete: s.complete ?? false,
2482    lane: s.lane ?? "LANE_UNSPECIFIED"
2483  };
2484}
2485function normView(v) {
2486  if (!v) return null;
2487  return {
2488    mode: v.mode ?? "VIEW_MODE_UNSPECIFIED",
2489    current: v.current ?? 0,
2490    firstVisible: v.first_visible ?? 0,
2491    lastVisible: v.last_visible ?? 0,
2492    columns: v.columns ?? 0,
2493    scrollY: v.scroll_y ?? 0,
2494    maxScrollY: v.max_scroll_y ?? 0,
2495    contentHeight: v.content_height ?? 0
2496  };
2497}
2498function normCurrent(c) {
2499  if (!c) return null;
2500  return {
2501    index: c.index ?? 0,
2502    // 1-based, as the deck numbers it.
2503    number: c.number ?? (c.index ?? 0) + 1,
2504    title: c.title ?? "",
2505    notes: c.notes ?? "",
2506    hidden: c.hidden ?? false,
2507    layout: c.layout ?? "",
2508    links: c.links ?? []
2509  };
2510}
2511function normHover(h) {
2512  if (!h) return null;
2513  return {
2514    slide: h.slide ?? 0,
2515    x: h.x ?? 0,
2516    y: h.y ?? 0,
2517    width: h.width ?? 0,
2518    height: h.height ?? 0
2519  };
2520}
2521function normRender(r) {
2522  if (!r) return null;
2523  return {
2524    colorScheme: r.color_scheme ?? "COLOR_SCHEME_UNSPECIFIED",
2525    uiScale: r.ui_scale ?? 0
2526  };
2527}
2528function normPair(p) {
2529  if (!p) return null;
2530  return {
2531    status: p.status ?? "SLIDE_STATUS_UNSPECIFIED",
2532    before: p.before ?? null,
2533    after: p.after ?? null,
2534    moved: p.moved ?? false,
2535    basis: p.basis ?? "MATCH_BASIS_UNSPECIFIED",
2536    aspects: p.aspects ?? []
2537  };
2538}
2539function normSpans(spans) {
2540  return (spans ?? []).map((t) => ({ kind: t.kind ?? "TEXT_SPAN_KIND_UNSPECIFIED", text: t.text ?? "" }));
2541}
2542function normBox(b) {
2543  if (!b) return null;
2544  return { x: b.x ?? 0, y: b.y ?? 0, width: b.width ?? 0, height: b.height ?? 0 };
2545}
2546function normDiff(d) {
2547  if (!d) return null;
2548  return {
2549    complete: d.complete ?? false,
2550    before: normDeck(d.before),
2551    same: d.same ?? 0,
2552    added: d.added ?? 0,
2553    removed: d.removed ?? 0,
2554    changed: d.changed ?? 0,
2555    moved: d.moved ?? 0,
2556    rows: (d.rows ?? []).map(normPair),
2557    matchedBy: (d.matched_by ?? []).map((b) => ({
2558      basis: b.basis ?? "MATCH_BASIS_UNSPECIFIED",
2559      count: b.count ?? 0
2560    })),
2561    slideSizeChanged: d.slide_size_changed ?? false,
2562    inherited: d.inherited ?? 0,
2563    errors: (d.errors ?? []).map((e) => ({
2564      lane: e.lane ?? "LANE_UNSPECIFIED",
2565      code: e.code ?? 0,
2566      message: e.message ?? ""
2567    })),
2568    beforeAbsent: d.before_absent ?? false,
2569    afterAbsent: d.after_absent ?? false,
2570    legend: (d.legend ?? []).map((l) => ({
2571      status: l.status ?? "SLIDE_STATUS_UNSPECIFIED",
2572      color: l.color ?? ""
2573    }))
2574  };
2575}
2576function normCompared(c) {
2577  if (!c) return null;
2578  return {
2579    row: c.row ?? 0,
2580    pair: normPair(c.pair),
2581    before: normCurrent(c.before),
2582    after: normCurrent(c.after),
2583    shapes: (c.shapes ?? []).map((s) => ({
2584      name: s.name ?? "",
2585      aspects: s.aspects ?? [],
2586      before: normBox(s.before),
2587      after: normBox(s.after),
2588      text: normSpans(s.text)
2589    })),
2590    title: normSpans(c.title),
2591    notes: normSpans(c.notes)
2592  };
2593}
2594function normCompare(c) {
2595  if (!c) return null;
2596  return {
2597    mode: c.mode ?? "COMPARE_MODE_UNSPECIFIED",
2598    sliderPosition: c.slider_position ?? 0,
2599    onionOpacity: c.onion_opacity ?? 0,
2600    changesOnly: c.changes_only ?? false,
2601    markChanges: c.mark_changes ?? false
2602  };
2603}
2604function normState(s) {
2605  return {
2606    deck: normDeck(s.deck),
2607    source: normSource(s.source),
2608    view: normView(s.view),
2609    current: normCurrent(s.current),
2610    hover: normHover(s.hover),
2611    render: normRender(s.render),
2612    sources: (s.sources ?? []).map(normSource),
2613    diff: normDiff(s.diff),
2614    compared: normCompared(s.compared),
2615    compare: normCompare(s.compare)
2616  };
2617}
2618function convertKeys(options, mapping, what) {
2619  const out = {};
2620  for (const [key, value] of Object.entries(options ?? {})) {
2621    const field = mapping[key];
2622    if (!field) {
2623      const near = Object.keys(mapping).find(
2624        (k) => k.toLowerCase() === String(key).toLowerCase().replace(/_/g, "")
2625      );
2626      throw new TypeError(
2627        `${what}: unknown option "${key}"${near ? ` \u2014 did you mean "${near}"?` : ""}`
2628      );
2629    }
2630    if (value !== void 0 && value !== null) out[field] = value;
2631  }
2632  return out;
2633}
2634function checkEnum(value, names, what) {
2635  if (value !== void 0 && !(value in names)) {
2636    throw new TypeError(`${what}: unknown value "${value}" (expected: ${Object.keys(names).join(", ")})`);
2637  }
2638}
2639function enumName(value, short, names, what) {
2640  if (value === void 0) return void 0;
2641  if (value in short) return short[value];
2642  if (value in names && !String(value).endsWith("_UNSPECIFIED")) return value;
2643  const flat = String(value).toLowerCase().replace(/[_\s-]/g, "");
2644  const near = Object.keys(short).find((k) => k.toLowerCase() === flat);
2645  throw new TypeError(
2646    `${what}: unknown value "${value}"${near ? ` \u2014 did you mean "${near}"?` : ""} (expected: ${Object.keys(short).join(", ")})`
2647  );
2648}
2649var RENDER_KEYS = { colorScheme: "color_scheme", uiScale: "ui_scale" };
2650var VIEW_KEYS = { mode: "mode", slide: "slide", scrollY: "scroll_y" };
2651var STEP_KEYS = { slides: "slides", rows: "rows", changes: "changes" };
2652var DIFF_KEYS = { before: "before", after: "after" };
2653var SIDE_KEYS = { ext: "ext", bytes: "initial", totalBytes: "total_bytes" };
2654var COMPARE_KEYS = {
2655  mode: "mode",
2656  sliderPosition: "slider_position",
2657  onionOpacity: "onion_opacity",
2658  changesOnly: "changes_only",
2659  markChanges: "mark_changes"
2660};
2661var LANES = { before: "LANE_BEFORE", after: "LANE_AFTER" };
2662var COMPARE_MODES = {
2663  sideBySide: "COMPARE_MODE_SIDE_BY_SIDE",
2664  slider: "COMPARE_MODE_SLIDER",
2665  onionskin: "COMPARE_MODE_ONIONSKIN"
2666};
2667function wheelToDevicePixels(event, { lineHeight = 16, pageHeight = 800, dpr = 1 } = {}) {
2668  const unit = event.deltaMode === 1 ? lineHeight : event.deltaMode === 2 ? pageHeight : 1;
2669  return { dx: (event.deltaX ?? 0) * unit * dpr, dy: (event.deltaY ?? 0) * unit * dpr };
2670}
2671function planOpen(bound, loaded) {
2672  if (!bound) return loaded ? "unload" : "none";
2673  if (!loaded) return "open";
2674  const isPair = (p) => "before" in p || "after" in p;
2675  const same = (a, b) => !a && !b || Boolean(a && b && a.bytes === b.bytes && a.name === b.name);
2676  if (isPair(bound) !== isPair(loaded)) return "open";
2677  const unchanged = isPair(bound) ? same(bound.before, loaded.before) && same(bound.after, loaded.after) : same(bound, loaded);
2678  return unchanged ? "none" : "open";
2679}
2680var wasmReady = null;
2681var wasmReadyUrl = null;
2682var memoryRef = null;
2683function boot({ wasmUrl } = {}) {
2684  if (wasmReady && wasmUrl && wasmUrl !== wasmReadyUrl) {
2685    console.warn(
2686      `slides viewer: ignoring wasm URL ${wasmUrl}; already instantiated from ${wasmReadyUrl ?? "the glue's default"}. One module per page.`
2687    );
2688  }
2689  if (!wasmReady) {
2690    wasmReadyUrl = wasmUrl ?? null;
2691    wasmReady = __wbg_init(wasmUrl ? { module_or_path: wasmUrl } : void 0).then((exports) => {
2692      memoryRef = exports?.memory ?? null;
2693      return exports;
2694    }).catch((error) => {
2695      wasmReady = null;
2696      wasmReadyUrl = null;
2697      throw error;
2698    });
2699  }
2700  return wasmReady;
2701}
2702var ABI_VERSION_REQUIRED = 1;
2703var SlideViewerApi = class _SlideViewerApi {
2704  #viewer;
2705  #canvas;
2706  #ctx;
2707  #handlers = {
2708    deck: [],
2709    source: [],
2710    view: [],
2711    current: [],
2712    hover: [],
2713    render: [],
2714    sources: [],
2715    diff: [],
2716    compared: [],
2717    compare: [],
2718    error: [],
2719    ready: [],
2720    any: []
2721  };
2722  #running = false;

2723  constructor(viewer, canvas) {
2724    this.#viewer = viewer;
2725    this.#canvas = canvas;
2726    this.#ctx = canvas.getContext("2d");
2727  }
2728  /**
2729   * Creates a viewer that draws to a canvas through a 2-D context. The core rasterises on the CPU.
2730   *
2731   * `options.wasmUrl` is where the `.wasm` lives when it is not beside the glue; see `boot`.
2732   */
2733  static async create(canvas, options = {}) {
2734    await boot(options);
2735    const version = abi_version();
2736    if (version !== ABI_VERSION_REQUIRED) {
2737      throw new Error(`viewer ABI ${version}, host expects ${ABI_VERSION_REQUIRED}`);
2738    }
2739    const api = new _SlideViewerApi(new SlideViewer(), canvas);
2740    api.resize(canvas.width, canvas.height);
2741    api.#start();
2742    return api;
2743  }
2744  #submit(command) {
2745    const reply = decodeCommandResult(this.#viewer.submit(encodeCommand(command)));
2746    if (reply.error) {
2747      const error = new Error(reply.error.message ?? "viewer error");
2748      error.code = reply.error.code ?? 0;
2749      throw error;
2750    }
2751    return reply;
2752  }
2753  /**
2754   * Returns the whole viewer state. It never mutates and never emits.
2755   */
2756  getState() {
2757    return normState(this.#submit({ get_state: {} }).state ?? {});
2758  }
2759  /**
2760   * Opens one deck and replaces what was open, also on failure.
2761   *
2762   * `ext` is lowercase without the dot. Pass the whole file as `bytes` by default: `wanted` stays
2763   * empty and the pull loop never starts. Pass `totalBytes` with a partial `bytes` to drive the loop.
2764   */
2765  open(ext, bytes, totalBytes) {
2766    this.#submit({
2767      open: {
2768        ext: ext ?? "",
2769        total_bytes: toLong(totalBytes ?? 0),
2770        initial: bytes ?? new Uint8Array()
2771      }
2772    });
2773  }
2774  /**
2775   * Compares two versions of a deck and replaces what was open.
2776   *
2777   * Each side is `{ ext, bytes, totalBytes }`, as {@link SlideViewerApi#open} takes them, or null.
2778   * No `before` is a deck added, and no `after` is a deck deleted. A side that does not open is
2779   * reported in `diff.errors`.
2780   *
2781   * @throws {Error} when neither side opens.
2782   */
2783  openDiff(options) {
2784    const req = convertKeys(options, DIFF_KEYS, "openDiff");
2785    const side = (value, name) => {
2786      if (!value) return void 0;
2787      const s = convertKeys(value, SIDE_KEYS, `openDiff: ${name}`);
2788      return { ext: s.ext ?? "", total_bytes: toLong(s.total_bytes ?? 0), initial: s.initial ?? new Uint8Array() };
2789    };
2790    this.#submit({ open_diff: { before: side(req.before, "before"), after: side(req.after, "after") } });
2791  }
2792  /**
2793   * Supplies a range the core asked for.
2794   *
2795   * In a comparison `lane` is required: `"before"`, `"after"`, or the `lane` of the source that
2796   * asked. Route on that, not on a position in `sources`. Outside a comparison, omit it.
2797   */
2798  supplyBytes(offset, data, lane) {
2799    const name = enumName(lane, LANES, encodeLane, "supplyBytes: lane") ?? "LANE_UNSPECIFIED";
2800    this.#submit({ supply_bytes: { offset: toLong(offset), data, lane: name } });
2801  }
2802  unload() {
2803    this.#submit({ unload: {} });
2804  }
2805  /**
2806   * Moves the view. An omitted key keeps its current value.
2807   *
2808   * `slide` is 0-based, clamped by the core, and applied after `mode`, so
2809   * `{ mode: "VIEW_MODE_SLIDES", slide: 4 }` opens slide 5. `scrollY` is ignored when `slide` is set.
2810   */
2811  setView(options) {
2812    const req = convertKeys(options, VIEW_KEYS, "setView");
2813    checkEnum(req.mode, encodeViewMode, "setView: mode");
2814    this.#submit({ set_view: req });
2815  }
2816  /**
2817   * Moves the current slide by `slides`, by grid `rows`, or by `changes`, and brings it into view.
2818   *
2819   * A change is a comparison row that is added, removed, changed or moved. Keys call this, not
2820   * {@link SlideViewerApi#setView}. The core knows how many columns a grid row holds, and two
2821   * presses in one frame move two places. A host that sets `current + 1` from the last event moves
2822   * one. `changes` outside a comparison throws NotInDiffMode (5).
2823   */
2824  step(options) {
2825    const req = convertKeys(options, STEP_KEYS, "step");
2826    this.#submit({ step: { slides: req.slides ?? 0, rows: req.rows ?? 0, changes: req.changes ?? 0 } });
2827  }
2828  /**
2829   * Sets how a comparison is drawn. An omitted key keeps its current value.
2830   *
2831   * `mode` is `"sideBySide"`, `"slider"` or `"onionskin"`. `sliderPosition` and `onionOpacity`
2832   * run 0 to 1 and the core clamps them. Throws NotInDiffMode (5) outside a comparison.
2833   */
2834  setCompareOptions(options) {
2835    const req = convertKeys(options, COMPARE_KEYS, "setCompareOptions");
2836    const mode = enumName(req.mode, COMPARE_MODES, encodeCompareMode, "setCompareOptions: mode");
2837    if (mode) req.mode = mode;
2838    this.#submit({ set_compare_options: req });
2839  }
2840  /**
2841   * Sets the colour scheme and UI scale. An omitted key keeps its current value.
2842   */
2843  setRenderOptions(options) {
2844    const req = convertKeys(options, RENDER_KEYS, "setRenderOptions");
2845    checkEnum(req.color_scheme, encodeColorScheme, "setRenderOptions: colorScheme");
2846    this.#submit({ set_render_options: req });
2847  }
2848  /**
2849   * Sets the surface size in device pixels, then presents.
2850   *
2851   * Assigning `canvas.width` clears the canvas, even to the same value. The guard stops a
2852   * `ResizeObserver` that fires with an unchanged size from wiping the picture.
2853   *
2854   * The present is unconditional. A same-size resize is a no-op in the viewer, which then reports
2855   * nothing to redraw, so the pump would never repaint a canvas that was just cleared.
2856   */
2857  resize(width, height) {
2858    if (this.#canvas.width !== width || this.#canvas.height !== height) {
2859      this.#canvas.width = width;
2860      this.#canvas.height = height;
2861    }
2862    this.#submit({ resize: { width, height } });
2863    this.present();
2864  }
2865  pointerMove(x, y) {
2866    this.#submit({ input: { pointer_move: { x, y } } });
2867  }
2868  pointerButton(button, x, y, pressed) {
2869    this.#submit({ input: { pointer_button: { button, x, y, pressed } } });
2870  }
2871  pointerLeave() {
2872    this.#submit({ input: { pointer_leave: {} } });
2873  }
2874  /**
2875   * Sends a scroll gesture in device pixels, positive down and right. C

2875onvert a DOM `WheelEvent`
2876   * with {@link wheelToDevicePixels} first.
2877   */
2878  wheel(dx, dy) {
2879    this.#submit({ input: { wheel: { dx, dy } } });
2880  }
2881  onDeckChange(fn) {
2882    return this.#on("deck", fn);
2883  }
2884  onSourceChange(fn) {
2885    return this.#on("source", fn);
2886  }
2887  onViewChange(fn) {
2888    return this.#on("view", fn);
2889  }
2890  onCurrentChange(fn) {
2891    return this.#on("current", fn);
2892  }
2893  onHoverChange(fn) {
2894    return this.#on("hover", fn);
2895  }
2896  onRenderChange(fn) {
2897    return this.#on("render", fn);
2898  }
2899  /** Subscribes to each side's source in a comparison. The payload is `[]` outside one. */
2900  onSourcesChange(fn) {
2901    return this.#on("sources", fn);
2902  }
2903  /** Subscribes to what a comparison found. The payload is null when the comparison ends. */
2904  onDiffChange(fn) {
2905    return this.#on("diff", fn);
2906  }
2907  /** Subscribes to a comparison's current row. The payload is null when there is none. */
2908  onComparedChange(fn) {
2909    return this.#on("compared", fn);
2910  }
2911  /** Subscribes to how a comparison is drawn. The payload is null when the comparison ends. */
2912  onCompareChange(fn) {
2913    return this.#on("compare", fn);
2914  }
2915  onError(fn) {
2916    return this.#on("error", fn);
2917  }
2918  onReady(fn) {
2919    return this.#on("ready", fn);
2920  }
2921  /**
2922   * Subscribes to every event as `{ domain, payload }`.
2923   */
2924  onChange(fn) {
2925    return this.#on("any", fn);
2926  }
2927  #on(domain, fn) {
2928    this.#handlers[domain].push(fn);
2929    return () => {
2930      const at = this.#handlers[domain].indexOf(fn);
2931      if (at >= 0) this.#handlers[domain].splice(at, 1);
2932    };
2933  }
2934  #emit(domain, payload) {
2935    for (const fn of this.#handlers[domain]) this.#call(fn, payload);
2936    for (const fn of this.#handlers.any) this.#call(fn, { domain, payload });
2937  }
2938  // A drained batch is gone from the core, so one throwing handler must not lose the rest of it.
2939  #call(fn, payload) {
2940    try {
2941      fn(payload);
2942    } catch (cause) {
2943      console.error("slides: an event handler threw", cause);
2944    }
2945  }
2946  /**
2947   * Drains queued events and fans them out. The pump calls this once per frame.
2948   */
2949  pollEvents() {
2950    const batch = decodeEventBatch(this.#viewer.poll_events());
2951    for (const event of batch.events ?? []) {
2952      if (event.ready) this.#emit("ready", {});
2953      else if (event.error) {
2954        this.#emit("error", { code: event.error.code ?? 0, message: event.error.message ?? "" });
2955      } else if (event.deck_changed) this.#emit("deck", normDeck(event.deck_changed.deck));
2956      else if (event.source_changed) {
2957        this.#emit("source", normSource(event.source_changed.source));
2958        this.#emit("sources", (event.source_changed.sources ?? []).map(normSource));
2959      } else if (event.view_changed) this.#emit("view", normView(event.view_changed.view));
2960      else if (event.current_changed) {
2961        this.#emit("current", normCurrent(event.current_changed.current));
2962      } else if (event.hover_changed) this.#emit("hover", normHover(event.hover_changed.hover));
2963      else if (event.render_changed) {
2964        this.#emit("render", normRender(event.render_changed.render));
2965      } else if (event.diff_changed) this.#emit("diff", normDiff(event.diff_changed.diff));
2966      else if (event.compared_changed) {
2967        this.#emit("compared", normCompared(event.compared_changed.compared));
2968      } else if (event.compare_changed) {
2969        this.#emit("compare", normCompare(event.compare_changed.compare));
2970      }
2971    }
2972  }
2973  #start() {
2974    this.#running = true;
2975    const pump = () => {
2976      if (!this.#running) return;
2977      try {
2978        this.#viewer.tick();
2979        this.pollEvents();
2980        if (this.#viewer.needs_redraw()) this.present();
2981      } finally {
2982        if (this.#running) requestAnimationFrame(pump);
2983      }
2984    };
2985    requestAnimationFrame(pump);
2986  }
2987  /**
2988   * Draws the frame and copies it to the canvas.
2989   *
2990   * The `Uint8ClampedArray` is rebuilt on every call. Growing wasm memory detaches every view of it
2991   * without an error, and a detached view reads as empty. A cached view paints a blank canvas once
2992   * a large deck grows the heap.
2993   */
2994  present() {
2995    this.#viewer.render();
2996    const width = this.#viewer.frame_width();
2997    const height = this.#viewer.frame_height();
2998    if (width === 0 || height === 0) return;
2999    if (!memoryRef) throw new Error("wasm memory is not available; did create() run?");
3000    const pixels = new Uint8ClampedArray(
3001      memoryRef.buffer,
3002      this.#viewer.frame_ptr(),
3003      this.#viewer.frame_len()
3004    );
3005    this.#ctx.putImageData(new ImageData(pixels, width, height), 0, 0);
3006  }
3007  /**
3008   * Stops the pump and frees the viewer. Nothing else releases it.
3009   */
3010  destroy() {
3011    this.#running = false;

3012    this.#viewer.free?.();
3013  }
3014};
3015export {
3016  ABI_VERSION_REQUIRED,
3017  SlideViewerApi,
3018  planOpen,
3019  wheelToDevicePixels
3020};

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.