"use strict";
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
  // If the importer is in node compatibility mode or this is not an ESM
  // file that has been converted to a CommonJS file using a Babel-
  // compatible transform (i.e. "__esModule" has not been set), then set
  // "default" to the CommonJS "module.exports" for node compatibility.
  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
  mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// union_vector/union_vector.ts
var union_vector_exports = {};
__export(union_vector_exports, {
  Attacker: () => Attacker,
  AttackerT: () => AttackerT,
  BookReader: () => BookReader,
  BookReaderT: () => BookReaderT,
  Character: () => Character,
  FallingTub: () => FallingTub,
  FallingTubT: () => FallingTubT,
  Gadget: () => Gadget,
  HandFan: () => HandFan,
  HandFanT: () => HandFanT,
  Movie: () => Movie,
  MovieT: () => MovieT,
  Rapunzel: () => Rapunzel,
  RapunzelT: () => RapunzelT
});
module.exports = __toCommonJS(union_vector_exports);

// union_vector/attacker.js
var flatbuffers = __toESM(require("flatbuffers"), 1);
var Attacker = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  static getRootAsAttacker(bb, obj) {
    return (obj || new Attacker()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  static getSizePrefixedRootAsAttacker(bb, obj) {
    bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
    return (obj || new Attacker()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  swordAttackDamage() {
    const offset = this.bb.__offset(this.bb_pos, 4);
    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
  }
  mutate_sword_attack_damage(value) {
    const offset = this.bb.__offset(this.bb_pos, 4);
    if (offset === 0) {
      return false;
    }
    this.bb.writeInt32(this.bb_pos + offset, value);
    return true;
  }
  static getFullyQualifiedName() {
    return "Attacker";
  }
  static startAttacker(builder) {
    builder.startObject(1);
  }
  static addSwordAttackDamage(builder, swordAttackDamage) {
    builder.addFieldInt32(0, swordAttackDamage, 0);
  }
  static endAttacker(builder) {
    const offset = builder.endObject();
    return offset;
  }
  static createAttacker(builder, swordAttackDamage) {
    Attacker.startAttacker(builder);
    Attacker.addSwordAttackDamage(builder, swordAttackDamage);
    return Attacker.endAttacker(builder);
  }
  unpack() {
    return new AttackerT(this.swordAttackDamage());
  }
  unpackTo(_o) {
    _o.swordAttackDamage = this.swordAttackDamage();
  }
};
var AttackerT = class {
  constructor(swordAttackDamage = 0) {
    this.swordAttackDamage = swordAttackDamage;
  }
  pack(builder) {
    return Attacker.createAttacker(builder, this.swordAttackDamage);
  }
};

// union_vector/book-reader.js
var BookReader = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  booksRead() {
    return this.bb.readInt32(this.bb_pos);
  }
  mutate_books_read(value) {
    this.bb.writeInt32(this.bb_pos + 0, value);
    return true;
  }
  static getFullyQualifiedName() {
    return "BookReader";
  }
  static sizeOf() {
    return 4;
  }
  static createBookReader(builder, books_read) {
    builder.prep(4, 4);
    builder.writeInt32(books_read);
    return builder.offset();
  }
  unpack() {
    return new BookReaderT(this.booksRead());
  }
  unpackTo(_o) {
    _o.booksRead = this.booksRead();
  }
};
var BookReaderT = class {
  constructor(booksRead = 0) {
    this.booksRead = booksRead;
  }
  pack(builder) {
    return BookReader.createBookReader(builder, this.booksRead);
  }
};

// union_vector/rapunzel.js
var Rapunzel = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  hairLength() {
    return this.bb.readInt32(this.bb_pos);
  }
  mutate_hair_length(value) {
    this.bb.writeInt32(this.bb_pos + 0, value);
    return true;
  }
  static getFullyQualifiedName() {
    return "Rapunzel";
  }
  static sizeOf() {
    return 4;
  }
  static createRapunzel(builder, hair_length) {
    builder.prep(4, 4);
    builder.writeInt32(hair_length);
    return builder.offset();
  }
  unpack() {
    return new RapunzelT(this.hairLength());
  }
  unpackTo(_o) {
    _o.hairLength = this.hairLength();
  }
};
var RapunzelT = class {
  constructor(hairLength = 0) {
    this.hairLength = hairLength;
  }
  pack(builder) {
    return Rapunzel.createRapunzel(builder, this.hairLength);
  }
};

// union_vector/character.js
var Character;
(function(Character2) {
  Character2[Character2["NONE"] = 0] = "NONE";
  Character2[Character2["MuLan"] = 1] = "MuLan";
  Character2[Character2["Rapunzel"] = 2] = "Rapunzel";
  Character2[Character2["Belle"] = 3] = "Belle";
  Character2[Character2["BookFan"] = 4] = "BookFan";
  Character2[Character2["Other"] = 5] = "Other";
  Character2[Character2["Unused"] = 6] = "Unused";
})(Character = Character || (Character = {}));
function unionToCharacter(type, accessor) {
  switch (Character[type]) {
    case "NONE":
      return null;
    case "MuLan":
      return accessor(new Attacker());
    case "Rapunzel":
      return accessor(new Rapunzel());
    case "Belle":
      return accessor(new BookReader());
    case "BookFan":
      return accessor(new BookReader());
    case "Other":
      return accessor("");
    case "Unused":
      return accessor("");
    default:
      return null;
  }
}
function unionListToCharacter(type, accessor, index) {
  switch (Character[type]) {
    case "NONE":
      return null;
    case "MuLan":
      return accessor(index, new Attacker());
    case "Rapunzel":
      return accessor(index, new Rapunzel());
    case "Belle":
      return accessor(index, new BookReader());
    case "BookFan":
      return accessor(index, new BookReader());
    case "Other":
      return accessor(index, "");
    case "Unused":
      return accessor(index, "");
    default:
      return null;
  }
}

// union_vector/falling-tub.js
var FallingTub = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  weight() {
    return this.bb.readInt32(this.bb_pos);
  }
  mutate_weight(value) {
    this.bb.writeInt32(this.bb_pos + 0, value);
    return true;
  }
  static getFullyQualifiedName() {
    return "FallingTub";
  }
  static sizeOf() {
    return 4;
  }
  static createFallingTub(builder, weight) {
    builder.prep(4, 4);
    builder.writeInt32(weight);
    return builder.offset();
  }
  unpack() {
    return new FallingTubT(this.weight());
  }
  unpackTo(_o) {
    _o.weight = this.weight();
  }
};
var FallingTubT = class {
  constructor(weight = 0) {
    this.weight = weight;
  }
  pack(builder) {
    return FallingTub.createFallingTub(builder, this.weight);
  }
};

// union_vector/hand-fan.js
var flatbuffers2 = __toESM(require("flatbuffers"), 1);
var HandFan = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  static getRootAsHandFan(bb, obj) {
    return (obj || new HandFan()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  static getSizePrefixedRootAsHandFan(bb, obj) {
    bb.setPosition(bb.position() + flatbuffers2.SIZE_PREFIX_LENGTH);
    return (obj || new HandFan()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  length() {
    const offset = this.bb.__offset(this.bb_pos, 4);
    return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
  }
  mutate_length(value) {
    const offset = this.bb.__offset(this.bb_pos, 4);
    if (offset === 0) {
      return false;
    }
    this.bb.writeInt32(this.bb_pos + offset, value);
    return true;
  }
  static getFullyQualifiedName() {
    return "HandFan";
  }
  static startHandFan(builder) {
    builder.startObject(1);
  }
  static addLength(builder, length) {
    builder.addFieldInt32(0, length, 0);
  }
  static endHandFan(builder) {
    const offset = builder.endObject();
    return offset;
  }
  static createHandFan(builder, length) {
    HandFan.startHandFan(builder);
    HandFan.addLength(builder, length);
    return HandFan.endHandFan(builder);
  }
  unpack() {
    return new HandFanT(this.length());
  }
  unpackTo(_o) {
    _o.length = this.length();
  }
};
var HandFanT = class {
  constructor(length = 0) {
    this.length = length;
  }
  pack(builder) {
    return HandFan.createHandFan(builder, this.length);
  }
};

// union_vector/gadget.js
var Gadget;
(function(Gadget2) {
  Gadget2[Gadget2["NONE"] = 0] = "NONE";
  Gadget2[Gadget2["FallingTub"] = 1] = "FallingTub";
  Gadget2[Gadget2["HandFan"] = 2] = "HandFan";
})(Gadget = Gadget || (Gadget = {}));

// union_vector/movie.js
var flatbuffers3 = __toESM(require("flatbuffers"), 1);
var Movie = class {
  constructor() {
    this.bb = null;
    this.bb_pos = 0;
  }
  __init(i, bb) {
    this.bb_pos = i;
    this.bb = bb;
    return this;
  }
  static getRootAsMovie(bb, obj) {
    return (obj || new Movie()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  static getSizePrefixedRootAsMovie(bb, obj) {
    bb.setPosition(bb.position() + flatbuffers3.SIZE_PREFIX_LENGTH);
    return (obj || new Movie()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
  }
  static bufferHasIdentifier(bb) {
    return bb.__has_identifier("MOVI");
  }
  mainCharacterType() {
    const offset = this.bb.__offset(this.bb_pos, 4);
    return offset ? this.bb.readUint8(this.bb_pos + offset) : Character.NONE;
  }
  mainCharacter(obj) {
    const offset = this.bb.__offset(this.bb_pos, 6);
    return offset ? this.bb.__union_with_string(obj, this.bb_pos + offset) : null;
  }
  charactersType(index) {
    const offset = this.bb.__offset(this.bb_pos, 8);
    return offset ? this.bb.readUint8(this.bb.__vector(this.bb_pos + offset) + index) : 0;
  }
  charactersTypeLength() {
    const offset = this.bb.__offset(this.bb_pos, 8);
    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
  }
  charactersTypeArray() {
    const offset = this.bb.__offset(this.bb_pos, 8);
    return offset ? new Uint8Array(this.bb.bytes().buffer, this.bb.bytes().byteOffset + this.bb.__vector(this.bb_pos + offset), this.bb.__vector_len(this.bb_pos + offset)) : null;
  }
  characters(index, obj) {
    const offset = this.bb.__offset(this.bb_pos, 10);
    return offset ? this.bb.__union_with_string(obj, this.bb.__vector(this.bb_pos + offset) + index * 4) : null;
  }
  charactersLength() {
    const offset = this.bb.__offset(this.bb_pos, 10);
    return offset ? this.bb.__vector_len(this.bb_pos + offset) : 0;
  }
  static getFullyQualifiedName() {
    return "Movie";
  }
  static startMovie(builder) {
    builder.startObject(4);
  }
  static addMainCharacterType(builder, mainCharacterType) {
    builder.addFieldInt8(0, mainCharacterType, Character.NONE);
  }
  static addMainCharacter(builder, mainCharacterOffset) {
    builder.addFieldOffset(1, mainCharacterOffset, 0);
  }
  static addCharactersType(builder, charactersTypeOffset) {
    builder.addFieldOffset(2, charactersTypeOffset, 0);
  }
  static createCharactersTypeVector(builder, data) {
    builder.startVector(1, data.length, 1);
    for (let i = data.length - 1; i >= 0; i--) {
      builder.addInt8(data[i]);
    }
    return builder.endVector();
  }
  static startCharactersTypeVector(builder, numElems) {
    builder.startVector(1, numElems, 1);
  }
  static addCharacters(builder, charactersOffset) {
    builder.addFieldOffset(3, charactersOffset, 0);
  }
  static createCharactersVector(builder, data) {
    builder.startVector(4, data.length, 4);
    for (let i = data.length - 1; i >= 0; i--) {
      builder.addOffset(data[i]);
    }
    return builder.endVector();
  }
  static startCharactersVector(builder, numElems) {
    builder.startVector(4, numElems, 4);
  }
  static endMovie(builder) {
    const offset = builder.endObject();
    return offset;
  }
  static finishMovieBuffer(builder, offset) {
    builder.finish(offset, "MOVI");
  }
  static finishSizePrefixedMovieBuffer(builder, offset) {
    builder.finish(offset, "MOVI", true);
  }
  static createMovie(builder, mainCharacterType, mainCharacterOffset, charactersTypeOffset, charactersOffset) {
    Movie.startMovie(builder);
    Movie.addMainCharacterType(builder, mainCharacterType);
    Movie.addMainCharacter(builder, mainCharacterOffset);
    Movie.addCharactersType(builder, charactersTypeOffset);
    Movie.addCharacters(builder, charactersOffset);
    return Movie.endMovie(builder);
  }
  unpack() {
    return new MovieT(this.mainCharacterType(), (() => {
      const temp = unionToCharacter(this.mainCharacterType(), this.mainCharacter.bind(this));
      if (temp === null) {
        return null;
      }
      if (typeof temp === "string") {
        return temp;
      }
      return temp.unpack();
    })(), this.bb.createScalarList(this.charactersType.bind(this), this.charactersTypeLength()), (() => {
      const ret = [];
      for (let targetEnumIndex = 0; targetEnumIndex < this.charactersTypeLength(); ++targetEnumIndex) {
        const targetEnum = this.charactersType(targetEnumIndex);
        if (targetEnum === null || Character[targetEnum] === "NONE") {
          continue;
        }
        const temp = unionListToCharacter(targetEnum, this.characters.bind(this), targetEnumIndex);
        if (temp === null) {
          continue;
        }
        if (typeof temp === "string") {
          ret.push(temp);
          continue;
        }
        ret.push(temp.unpack());
      }
      return ret;
    })());
  }
  unpackTo(_o) {
    _o.mainCharacterType = this.mainCharacterType();
    _o.mainCharacter = (() => {
      const temp = unionToCharacter(this.mainCharacterType(), this.mainCharacter.bind(this));
      if (temp === null) {
        return null;
      }
      if (typeof temp === "string") {
        return temp;
      }
      return temp.unpack();
    })();
    _o.charactersType = this.bb.createScalarList(this.charactersType.bind(this), this.charactersTypeLength());
    _o.characters = (() => {
      const ret = [];
      for (let targetEnumIndex = 0; targetEnumIndex < this.charactersTypeLength(); ++targetEnumIndex) {
        const targetEnum = this.charactersType(targetEnumIndex);
        if (targetEnum === null || Character[targetEnum] === "NONE") {
          continue;
        }
        const temp = unionListToCharacter(targetEnum, this.characters.bind(this), targetEnumIndex);
        if (temp === null) {
          continue;
        }
        if (typeof temp === "string") {
          ret.push(temp);
          continue;
        }
        ret.push(temp.unpack());
      }
      return ret;
    })();
  }
};
var MovieT = class {
  constructor(mainCharacterType = Character.NONE, mainCharacter = null, charactersType = [], characters = []) {
    this.mainCharacterType = mainCharacterType;
    this.mainCharacter = mainCharacter;
    this.charactersType = charactersType;
    this.characters = characters;
  }
  pack(builder) {
    const mainCharacter = builder.createObjectOffset(this.mainCharacter);
    const charactersType = Movie.createCharactersTypeVector(builder, this.charactersType);
    const characters = Movie.createCharactersVector(builder, builder.createObjectOffsetList(this.characters));
    return Movie.createMovie(builder, this.mainCharacterType, mainCharacter, charactersType, characters);
  }
};