xVASynth v3 code for English

.gitignore

@@ -0,0 +1,43 @@
+xVAEnv
+xVAEnvCPU
+node_modules
+*.wav
+downloads/*
+output/*
+output/*.wav
+output/**/*.wav
+output/*.mp3
+output/**/*.mp3
+output/*.ogg
+output/**/*.ogg
+output/**/*.json
+*.ckpt
+*.todo
+__pycache__/
+.cache/
+*.pyc
+server.log
+server.log.*
+cpython
+xVASynth-win*
+model.rar
+build
+dist
+FASTPITCH_LOADING
+WAVEGLOW_LOADING
+SERVER_STARTING
+DEBUG*
+models
+release-builds
+package-lock.json
+app.log
+batch
+python/wav2vec2/pytorch_model.bin
+python/ffmpeg.exe
+python/xvapitch/base_v1.0.pt
+env*
+embeddings.txt
+*.exe
+*.pt
+*.dll
+*.bin

LICENSE.md

@@ -0,0 +1,674 @@
+GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<https://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -5,7 +5,7 @@ colorFrom: gray
 colorTo: gray
 sdk: gradio
 python_version: 3.9
-app_file: app.py
+app_file: server.py
 tags:
   - tts
   - t2s

arpabet/custom.json

@@ -0,0 +1,17 @@
+{
+    "title": "Custom Dictionary",
+    "description": "Your own custom dictionary",
+    "version": "1.0.0",
+    "author": "Your name",
+    "nexusLink": null,
+    "data": {
+        "stuff": {
+            "enabled": false,
+            "arpabet": "S T AA0 F"
+        },
+        "things": {
+            "enabled": false,
+            "arpabet": "T HH IH N G S"
+        }
+    }
+}

arpabet/xvasynth.json

@@ -0,0 +1,61 @@
+{
+    "title": "xVASynth Terminology",
+    "description": "Some technical words specific to xVASynth related tech",
+    "version": "1.0.0",
+    "author": "Dan Ruta",
+    "nexusLink": null,
+    "data": {
+        "xvasynth": {
+            "enabled": true,
+            "arpabet": "EH1 G S V EY0 EY0 IH0 S IH0 N TH"
+        },
+        "model": {
+            "enabled": true,
+            "arpabet": "M AA1 D AH0 L"
+        },
+        "hifi": {
+            "enabled": true,
+            "arpabet": "HH AA0 IH0 F AA0 IH0"
+        },
+        "fastpitch": {
+            "enabled": true,
+            "arpabet": "F AE1 S T P IH0 T CH"
+        },
+        "tacotron": {
+            "enabled": true,
+            "arpabet": "T AA0 K OW0 T R OW0 N"
+        },
+        "ai": {
+            "enabled": true,
+            "arpabet": "EY1 IY0 AA0 IY0"
+        },
+        "cmudict": {
+            "enabled": true,
+            "arpabet": "S IY1 IY1 EH0 M Y UW1 D IH1 K T"
+        },
+        "ffmpeg": {
+            "enabled": true,
+            "arpabet": "EH1 F } { EH1 F } { EH0 M P EH0 G"
+        },
+        "vram": {
+            "enabled": true,
+            "arpabet": "V IY0 R AE1 M"
+        },
+        "nvidia": {
+            "enabled": true,
+            "arpabet": "EH0 N V IH1 D IY0 AA1"
+        },
+        "xvatrainer": {
+            "enabled": true,
+            "arpabet": "EH1 G S V EY0 IH0 } { T R EY1 N ER0"
+        },
+        "gpu": {
+            "enabled": true,
+            "arpabet": "JH IY1 P IY1 Y UW1"
+        },
+        "video": {
+            "enabled": true,
+            "arpabet": "V IY0 D IY0 OW0"
+        }
+    }
+}

javascript/appLogger.js

@@ -0,0 +1,39 @@
+"use strict"
+
+const fs = require("fs")
+
+class xVAAppLogger {
+
+    constructor (fileLocation, appVersion) {
+        this.lines = []
+        this.fileLocation = fileLocation
+
+        if (fs.existsSync(fileLocation)) {
+            const data = fs.readFileSync(fileLocation, "utf8")
+            this.lines = data.split("\n")
+        }
+
+        this.prefix = ""
+        this.log(`New session - ${appVersion}`)
+    }
+
+    log (message) {
+        this.lines.push(`${(new Date()).toJSON().replace("T", "_")} |${this.prefix.length?` [${this.prefix}]:`:""} ${message}`)
+
+        if (this.lines.length>1000) {
+            this.lines = this.lines.slice(this.lines.length-1000, this.lines.length)
+        }
+
+        fs.writeFileSync(this.fileLocation, this.lines.join("\n"), "utf8")
+    }
+
+    print (message) {
+        console.log(`${this.prefix.length?` [${this.prefix}]:`:""} ${message}`)
+    }
+
+    setPrefix (prefix) {
+        this.prefix = prefix
+    }
+}
+
+exports.xVAAppLogger = xVAAppLogger

javascript/arpabet.js

@@ -0,0 +1,498 @@
+"use strict"
+
+window.arpabetMenuState = {
+    currentDict: undefined,
+    dictionaries: {},
+    paginationIndex: 0,
+    totalPages: 0,
+    clickedRecord: undefined,
+    skipRefresh: false,
+    hasInitialised: false,
+    isRefreshing: false,
+    hasChangedARPAbet: false
+}
+
+window.ARPAbetSymbols = ['AA0', 'AA1', 'AA2', 'AA', 'AE0', 'AE1', 'AE2', 'AE', 'AH0', 'AH1', 'AH2', 'AH',
+  'AO0', 'AO1', 'AO2', 'AO', 'AW0', 'AW1', 'AW2', 'AW', 'AY0', 'AY1', 'AY2', 'AY',
+  'B', 'CH', 'D', 'DH', 'EH0', 'EH1', 'EH2', 'EH', 'ER0', 'ER1', 'ER2', 'ER',
+  'EY0', 'EY1', 'EY2', 'EY', 'F', 'G', 'HH', 'IH0', 'IH1', 'IH2', 'IH', 'IY0', 'IY1',
+  'IY2', 'IY', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW0', 'OW1', 'OW2', 'OW', 'OY0',
+  'OY1', 'OY2', 'OY', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH0', 'UH1', 'UH2', 'UH',
+  'UW0', 'UW1', 'UW2', 'UW', 'V', 'W', 'Y', 'Z', 'ZH', ,"}","{", "_",
+  "AX", "AXR", "IX", "UX", "DX", "EL", "EM", "EN0", "EN1", "EN2", "EN", "NX", "Q", "WH",
+  "RRR", "HR", "OE", "RH", "TS", "RR", "UU", "OO", "KH", "SJ", "HJ", "BR",
+
+  "A1", "A2", "A3", "A4", "A5", "AI1", "AI2", "AI3", "AI4", "AI5", "AIR2", "AIR3", "AIR4", "AN1", "AN2", "AN3", "AN4", "AN5", "ANG1", "ANG2", "ANG3", "ANG4", "ANG5", "ANGR2", "ANGR3", "ANGR4", "ANR1", "ANR3", "ANR4", "AO1", "AO2", "AO3", "AO4", "AO5", "AOR1", "AOR2", "AOR3", "AOR4", "AOR5", "AR2", "AR3", "AR4", "AR5", "E1", "E2", "E3", "E4", "E5", "EI1", "EI2", "EI3", "EI4", "EI5", "EIR4", "EN1", "EN2", "EN3", "EN4", "EN5", "ENG1", "ENG2", "ENG3", "ENG4", "ENG5", "ENGR1", "ENGR4", "ENR1", "ENR2", "ENR3", "ENR4", "ENR5", "ER1", "ER2", "ER3", "ER4", "ER5", "I1", "I2", "I3", "I4", "I5", "IA1", "IA2", "IA3", "IA4", "IA5", "IAN1", "IAN2", "IAN3", "IAN4", "IAN5", "IANG1", "IANG2", "IANG3", "IANG4", "IANG5", "IANGR2", "IANR1", "IANR2", "IANR3", "IANR4", "IANR5", "IAO1", "IAO2", "IAO3", "IAO4", "IAO5", "IAOR1", "IAOR2", "IAOR3", "IAOR4", "IAR1", "IAR4", "IE1", "IE2", "IE3", "IE4", "IE5", "IN1", "IN2", "IN3", "IN4", "IN5", "ING1", "ING2", "ING3", "ING4", "ING5", "INGR2", "INGR4", "INR1", "INR4", "IONG1", "IONG2", "IONG3", "IONG4", "IONG5", "IR1", "IR3", "IR4", "IU1", "IU2", "IU3", "IU4", "IU5", "IUR1", "IUR2", "O1", "O2", "O3", "O4", "O5", "ONG1", "ONG2", "ONG3", "ONG4", "ONG5", "OR1", "OR2", "OU1", "OU2", "OU3", "OU4", "OU5", "OUR2", "OUR3", "OUR4", "OUR5", "U1", "U2", "U3", "U4", "U5", "UA1", "UA2", "UA3", "UA4", "UA5", "UAI1", "UAI2", "UAI3", "UAI4", "UAIR4", "UAIR5", "UAN1", "UAN2", "UAN3", "UAN4", "UAN5", "UANG1", "UANG2", "UANG3", "UANG4", "UANG5", "UANR1", "UANR2", "UANR3", "UANR4", "UAR1", "UAR2", "UAR4", "UE1", "UE2", "UE3", "UE4", "UE5", "UER2", "UER3", "UI1", "UI2", "UI3", "UI4", "UI5", "UIR1", "UIR2", "UIR3", "UIR4", "UN1", "UN2", "UN3", "UN4", "UN5", "UNR1", "UNR2", "UNR3", "UNR4", "UO1", "UO2", "UO3", "UO4", "UO5", "UOR1", "UOR2", "UOR3", "UOR5", "UR1", "UR2", "UR4", "UR5", "V2", "V3", "V4", "V5", "VE4", "VR3", "WA1", "WA2", "WA3", "WA4", "WA5", "WAI1", "WAI2", "WAI3", "WAI4", "WAN1", "WAN2", "WAN3", "WAN4", "WAN5", "WANG1", "WANG2", "WANG3", "WANG4", "WANG5", "WANGR2", "WANGR4", "WANR2", "WANR4", "WANR5", "WEI1", "WEI2", "WEI3", "WEI4", "WEI5", "WEIR1", "WEIR2", "WEIR3", "WEIR4", "WEIR5", "WEN1", "WEN2", "WEN3", "WEN4", "WEN5", "WENG1", "WENG2", "WENG3", "WENG4", "WENR2", "WO1", "WO2", "WO3", "WO4", "WO5", "WU1", "WU2", "WU3", "WU4", "WU5", "WUR3", "YA1", "YA2", "YA3", "YA4", "YA5", "YAN1", "YAN2", "YAN3", "YAN4", "YANG1", "YANG2", "YANG3", "YANG4", "YANG5", "YANGR4", "YANR3", "YAO1", "YAO2", "YAO3", "YAO4", "YAO5", "YE1", "YE2", "YE3", "YE4", "YE5", "YER4", "YI1", "YI2", "YI3", "YI4", "YI5", "YIN1", "YIN2", "YIN3", "YIN4", "YIN5", "YING1", "YING2", "YING3", "YING4", "YING5", "YINGR1", "YINGR2", "YINGR3", "YIR4", "YO1", "YO3", "YONG1", "YONG2", "YONG3", "YONG4", "YONG5", "YONGR3", "YOU1", "YOU2", "YOU3", "YOU4", "YOU5", "YOUR2", "YOUR3", "YOUR4", "YU1", "YU2", "YU3", "YU4", "YU5", "YUAN1", "YUAN2", "YUAN3", "YUAN4", "YUAN5", "YUANR2", "YUANR4", "YUE1", "YUE2", "YUE4", "YUE5", "YUER4", "YUN1", "YUN2", "YUN3", "YUN4",
+
+  "@BREATHE_IN", "@BREATHE_OUT", "@LAUGH", "@GIGGLE", "@SIGH", "@COUGH", "@AHEM", "@SNEEZE", "@WHISTLE", "@UGH", "@HMM", "@GASP", "@AAH", "@GRUNT", "@YAWN", "@SNIFF"
+
+  ]
+// window.ARPAbetSymbols = [
+//   'AA', 'AA0', 'AA1', 'AA2', 'AE', 'AE0', 'AE1', 'AE2', 'AH', 'AH0', 'AH1', 'AH2',
+//   'AO', 'AO0', 'AO1', 'AO2', 'AW', 'AW0', 'AW1', 'AW2', 'AY', 'AY0', 'AY1', 'AY2',
+//   'B', 'CH', 'D', 'DH', 'EH', 'EH0', 'EH1', 'EH2', 'ER', 'ER0', 'ER1', 'ER2', 'EY',
+//   'EY0', 'EY1', 'EY2', 'F', 'G', 'HH', 'IH', 'IH0', 'IH1', 'IH2', 'IY', 'IY0', 'IY1',
+//   'IY2', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW', 'OW0', 'OW1', 'OW2', 'OY', 'OY0',
+//   'OY1', 'OY2', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH', 'UH0', 'UH1', 'UH2', 'UW',
+//   'UW0', 'UW1', 'UW2', 'V', 'W', 'Y', 'Z', 'ZH'
+//   ,"}","{", "_"
+// ]
+
+window.refreshDictionariesList = () => {
+
+    return new Promise(resolve => {
+
+        // Don't spam with changes when the menu isn't open
+        // if (arpabetModal.parentElement.style.display!="flex" && window.arpabetMenuState.hasInitialised) {
+        if (arpabetModal.parentElement.style.display!="flex") {
+            return
+        }
+
+        window.arpabetMenuState.hasInitialised = true
+        if (window.arpabetMenuState.isRefreshing) {
+            resolve()
+            return
+        }
+        window.arpabetMenuState.isRefreshing = true
+
+        if (window.arpabetMenuState.skipRefresh) {
+            resolve()
+            return
+        }
+
+        spinnerModal(window.i18n.LOADING_DICTIONARIES)
+        window.arpabetMenuState.dictionaries = {}
+        arpabet_dicts_list.innerHTML = ""
+
+        const jsonFiles = fs.readdirSync(`${window.path}/arpabet`).filter(fname => fname.includes(".json"))
+
+        const readFile = (fileCounter) => {
+
+            const fname = jsonFiles[fileCounter]
+            if (!fname.includes(".json")) {
+                if ((fileCounter+1)<jsonFiles.length) {
+                    readFile(fileCounter+1)
+                } else {
+                    window.arpabetRunSearch()
+                    window.arpabetMenuState.isRefreshing = false
+                    closeModal(undefined, arpabetContainer)
+                    resolve()
+                }
+                return
+            }
+            const dictId = fname.replace(".json", "")
+
+            fs.readFile(`${window.path}/arpabet/${fname}`, "utf8", (err, data) => {
+                const jsonData = JSON.parse(data)
+
+                const dictButton = createElem("button", jsonData.title)
+                dictButton.title = jsonData.description
+                dictButton.style.background = window.currentGame ? `#${window.currentGame.themeColourPrimary}` : "#aaa"
+                arpabet_dicts_list.appendChild(dictButton)
+
+                window.arpabetMenuState.dictionaries[dictId] = jsonData
+
+                dictButton.addEventListener("click", ()=>handleDictClick(dictId))
+
+                if ((fileCounter+1)<jsonFiles.length) {
+                    readFile(fileCounter+1)
+                } else {
+                    window.arpabetRunSearch()
+                    window.arpabetMenuState.isRefreshing = false
+                    closeModal(undefined, arpabetContainer)
+                    resolve()
+                }
+            })
+        }
+        if (jsonFiles.length) {
+            readFile(0)
+        } else {
+            window.arpabetMenuState.isRefreshing = false
+            closeModal(undefined, arpabetContainer)
+            resolve()
+        }
+    })
+}
+
+window.handleDictClick = (dictId) => {
+
+    if (window.arpabetMenuState.currentDict==dictId) {
+        return
+    }
+    arpabet_enableall_button.disabled = false
+    arpabet_disableall_button.disabled = false
+    window.arpabetMenuState.currentDict = dictId
+    window.arpabetMenuState.paginationIndex = 0
+    window.arpabetMenuState.totalPages = 0
+
+    arpabet_word_search_input.value = ""
+    window.arpabetRunSearch()
+    window.refreshDictWordList()
+}
+
+window.refreshDictWordList = () => {
+
+    const dictId = window.arpabetMenuState.currentDict
+    arpabetWordsListContainer.innerHTML = ""
+
+    const wordKeys = Object.keys(window.arpabetMenuState.dictionaries[dictId].filteredData)
+    let startIndex = window.arpabetMenuState.paginationIndex*window.userSettings.arpabet_paginationSize
+    const endIndex = Math.min(startIndex+window.userSettings.arpabet_paginationSize, wordKeys.length)
+
+    window.arpabetMenuState.totalPages = Math.ceil(wordKeys.length/window.userSettings.arpabet_paginationSize)
+    arpabet_pagination_numbers.innerHTML = window.i18n.PAGINATION_X_OF_Y.replace("_1", window.arpabetMenuState.paginationIndex+1).replace("_2", window.arpabetMenuState.totalPages)
+
+    for (let i=startIndex; i<endIndex; i++) {
+        const data = window.arpabetMenuState.dictionaries[dictId].filteredData[wordKeys[i]]
+        const word = wordKeys[i]
+
+        const rowElem = createElem("div.arpabetRow")
+        const ckbx = createElem("input.arpabetRowItem", {type: "checkbox"})
+        ckbx.checked = data.enabled
+        ckbx.style.marginTop = 0
+        ckbx.addEventListener("click", () => {
+            window.arpabetMenuState.dictionaries[dictId].data[wordKeys[i]].enabled = ckbx.checked
+            window.arpabetMenuState.skipRefresh = true
+            window.saveARPAbetDict(dictId)
+            window.arpabetMenuState.hasChangedARPAbet = true
+            setTimeout(() => window.arpabetMenuState.skipRefresh = false, 1000)
+        })
+
+        const deleteButton = createElem("button.smallButton.arpabetRowItem", window.i18n.DELETE)
+        deleteButton.style.background = window.currentGame ? `#${window.currentGame.themeColourPrimary}` : "#aaa"
+        deleteButton.addEventListener("click", () => {
+            window.confirmModal(window.i18n.ARPABET_CONFIRM_DELETE_WORD.replace("_1", word)).then(response => {
+                if (response) {
+                    setTimeout(() => {
+                        delete window.arpabetMenuState.dictionaries[dictId].data[word]
+                        delete window.arpabetMenuState.dictionaries[dictId].filteredData[word]
+                        window.saveARPAbetDict(dictId)
+                        window.refreshDictWordList()
+                    }, 210)
+                }
+            })
+        })
+
+        const wordElem = createElem("div.arpabetRowItem", word)
+        wordElem.title = word
+
+        const arpabetElem = createElem("div.arpabetRowItem", data.arpabet)
+        arpabetElem.title = data.arpabet
+
+
+        rowElem.appendChild(createElem("div.arpabetRowItem", ckbx))
+        rowElem.appendChild(createElem("div.arpabetRowItem", deleteButton))
+        rowElem.appendChild(wordElem)
+        rowElem.appendChild(arpabetElem)
+
+        rowElem.addEventListener("click", () => {
+            window.arpabetMenuState.clickedRecord = {elem: rowElem, word}
+            arpabet_word_input.value = word
+            arpabet_arpabet_input.value = data.arpabet
+        })
+
+        arpabetWordsListContainer.appendChild(rowElem)
+    }
+}
+
+window.saveARPAbetDict = (dictId) => {
+
+    const dataOut = {
+        title: window.arpabetMenuState.dictionaries[dictId].title,
+        description: window.arpabetMenuState.dictionaries[dictId].description,
+        version: window.arpabetMenuState.dictionaries[dictId].version,
+        author: window.arpabetMenuState.dictionaries[dictId].author,
+        nexusLink: window.arpabetMenuState.dictionaries[dictId].nexusLink,
+        data: window.arpabetMenuState.dictionaries[dictId].data
+    }
+
+    doFetch(`http://localhost:8008/updateARPABet`, {
+        method: "Post",
+        body: JSON.stringify({})
+    })//.then(r => r.text()).then(r => {console.log(r)})
+
+
+    fs.writeFileSync(`${window.path}/arpabet/${dictId}.json`, JSON.stringify(dataOut, null, 4))
+}
+
+
+
+
+window.refreshARPABETReferenceDisplay = () => {
+
+    const V2 = [2]
+    const V3 = [3]
+    const V2_3 = [2,3]
+
+    const data = [
+        // Min model version, symbols, examples
+        [V2, "AA0, AA1, AA2", "b<b>al</b>m, b<b>o</b>t, c<b>o</b>t"],
+        [V3, "AA, AA0, AA1, AA2", "b<b>al</b>m, b<b>o</b>t, c<b>o</b>t"],
+
+        [V2, "AE0, AE1, AE2", "b<b>a</b>t, f<b>a</b>st"],
+        [V3, "AE, AE0, AE1, AE2", "b<b>a</b>t, f<b>a</b>st"],
+
+        [V2, "AH0, AH1, AH2", "b<b>u</b>tt"],
+        [V3, "AH, AH0, AH1, AH2", "b<b>u</b>tt"],
+
+        [V2, "AO0, AO1, AO2", "st<b>o</b>ry"],
+        [V3, "AO, AO0, AO1, AO2", "st<b>o</b>ry"],
+
+        [V2, "AW0, AW1, AW2", "b<b>ou</b>t"],
+        [V3, "AW, AW0, AW1, AW2", "b<b>ou</b>t"],
+
+        [V3, "AX", "comm<b>a</b>"],
+        [V3, "AXR", "lett<b>er</b>"],
+
+        [V2, "AY0, AY1, AY2", "b<b>i</b>te"],
+        [V3, "AY, AY0, AY1, AY2", "b<b>i</b>te"],
+
+        [V2_3, "B", "<b>b</b>uy"],
+
+        [V3, "BR", "B and RRR sounds, together"],
+
+        [V2_3, "CH", "<b>ch</b>ina"],
+        [V2_3, "D", "<b>d</b>ie"],
+        [V3, "DX", "bu<b>tt</b>er"],
+        [V2_3, "DH", "<b>th</b>y"],
+        [V2, "EH0, EH1, EH2", "b<b>e</b>t"],
+        [V3, "EH,EH0, EH1, EH2", "b<b>e</b>t"],
+
+        [V3, "EL", "bott<b>le</b>"],
+        [V3, "EM", "rhyth<b>m</b>"],
+        [V3, "EN, EN0, EN1, EN2", "butt<b>on</b>"],
+
+        [V2, "ER0, ER1, ER2", "b<b>i</b>rd"],
+        [V3, "ER, ER0, ER1, ER2", "b<b>i</b>rd"],
+
+        [V2, "EY0, EY1, EY2", "b<b>ai</b>t"],
+        [V3, "EY, EY0, EY1, EY2", "b<b>ai</b>t"],
+
+        [V2_3, "F", "<b>f</b>ight"],
+        [V2_3, "G", "<b>g</b>uy"],
+        [V2_3, "HH", "<b>h</b>igh"],
+        [V3, "HJ", "J sound if mouth was open"],
+        [V3, "HR", "hrr sound typical in Arabic"],
+        [V2, "IH0, IH1, IH2", "b<b>i</b>t"],
+        [V3, "IH, IH0, IH1, IH2", "b<b>i</b>t"],
+        [V3, "IX", "ros<b>e</b>s, rabb<b>i</b>t"],
+
+        [V2, "IY0, IY1, IY2", "b<b>ea</b>t"],
+        [V3, "IY, IY0, IY1, IY2", "b<b>ea</b>t"],
+
+        [V2_3, "JH", "<b>j</b>ive"],
+        [V2_3, "K", "<b>k</b>ite"],
+        [V3, "KH", "K and H sounds, but together"],
+        [V2_3, "L", "<b>l</b>ie"],
+        [V2_3, "M", "<b>m</b>y"],
+        [V2_3, "N", "<b>n</b>igh"],
+        [V2_3, "NG", "si<b>ng</b>"],
+        [V3, "NX", "wi<b>nn</b>er"],
+
+        [V3, "OE", "german m<b>ö</b>ve, french eu (bl<b>eu</b>)"],
+        [V3, "OO", "hard o sound"],
+        [V2, "OW0, OW1, OW2", "b<b>oa</b>t"],
+        [V3, "OW, OW0, OW1, OW2", "b<b>oa</b>t"],
+
+        [V2, "OY0, OY1, OY2", "b<b>oy</b>"],
+        [V3, "OY, OY0, OY1, OY2", "b<b>oy</b>"],
+
+        [V2_3, "P", "<b>p</b>ie"],
+        [V3, "Q", "(glottal stop) uh<b>-</b>oh)"],
+        [V2_3, "R", "<b>r</b>ye"],
+        [V3, "RH, RR", "<b>r</b>un"],
+        [V3, "RRR", "<strong r>"],
+        [V2_3, "S", "<b>s</b>igh"],
+        [V3, "SJ", "swedish sj"],
+        [V2_3, "SH", "<b>sh</b>y"],
+        [V2_3, "T", "<b>t</b>ie"],
+        [V2_3, "TH", "<b>th</b>igh"],
+        [V3, "TS", "T and S sounds together (eg romanian ț)"],
+        [V2, "UH0, UH1, UH2", "b<b>oo</b>k"],
+        [V3, "UH, UH0, UH1, UH2", "b<b>oo</b>k"],
+        [V3, "UU", "german <b>ü</b>ber"],
+
+        [V2, "UW0, UW1, UW2", "b<b>oo</b>t"],
+        [V3, "UW, UW0, UW1, UW2", "b<b>oo</b>t"],
+        [V3, "UX", "d<b>u</b>de"],
+        [V3, "WH", "<b>wh</b>at, <b>wh</b>y (w with 'h' sound)"],
+
+        [V2_3, "V", "<b>v</b>ie"],
+        [V2_3, "W", "<b>w</b>ise"],
+        [V2_3, "Y", "<b>y</b>acht"],
+        [V2_3, "Z", "<b>z</b>oo"],
+        [V2_3, "ZH", "plea<b>s</b>ure"],
+    ]
+    arpabetReferenceList.innerHTML = ""
+    data.forEach(item => {
+        if (item[0].includes(parseInt(arpabetMenuModelDropdown.value))) {
+            const div = createElem("div")
+            div.appendChild(createElem("div", item[1]))
+
+            const exampleDiv = createElem("div")
+            exampleDiv.appendChild(createElem("div",item[2]))
+            div.appendChild(exampleDiv)
+
+            arpabetReferenceList.appendChild(div)
+        }
+    })
+}
+arpabetMenuModelDropdown.value = "3"
+window.refreshARPABETReferenceDisplay()
+arpabetMenuModelDropdown.addEventListener("click", window.refreshARPABETReferenceDisplay)
+
+
+arpabet_save.addEventListener("click", () => {
+    const word = arpabet_word_input.value.trim().toLowerCase()
+    const arpabet = arpabet_arpabet_input.value.trim().toUpperCase().replace(/\s{2,}/g, " ")
+
+    if (!word.length || !arpabet.length) {
+        return window.errorModal(window.i18n.ARPABET_ERROR_EMPTY_INPUT)
+    }
+
+    const badSymbols = arpabet.split(" ").filter(symb => !window.ARPAbetSymbols.includes(symb))
+    if (badSymbols.length) {
+        return window.errorModal(window.i18n.ARPABET_ERROR_BAD_SYMBOLS.replace("_1", badSymbols.join(", ")))
+    }
+
+    const wordKeys = Object.keys(window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data)
+
+    const doTheRest_updateDict = () => {
+        window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[word] = {enabled: true, arpabet: arpabet}
+        window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data
+
+        window.refreshDictWordList()
+        window.saveARPAbetDict(window.arpabetMenuState.currentDict)
+    }
+
+
+    // Delete the old record
+    if (window.arpabetMenuState.clickedRecord && window.arpabetMenuState.clickedRecord.word != word) {
+        delete window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[window.arpabetMenuState.clickedRecord.word]
+    }
+
+    let wordExists = []
+    Object.keys(window.arpabetMenuState.dictionaries).forEach(dictName => {
+        if (dictName==window.arpabetMenuState.currentDict) {
+            return
+        }
+
+        if (Object.keys(window.arpabetMenuState.dictionaries[dictName].data).includes(word)) {
+            wordExists.push(dictName)
+        }
+    })
+
+    if (wordExists.length) {
+        window.confirmModal(window.i18n.ARPABET_CONFIRM_SAME_WORD.replace("_1", word).replace("_2", wordExists.join("<br>"))).then(response => {
+            if (response) {
+                doTheRest_updateDict()
+            }
+        })
+    } else {
+        doTheRest_updateDict()
+    }
+})
+
+arpabetModal.addEventListener("click", (event) => {
+    if (window.arpabetMenuState.clickedRecord && event.target.className!="arpabetRow"&& event.target.className!="arpabetRowItem" && ![arpabet_word_input, arpabet_arpabet_input, arpabet_save, arpabet_prev_btn, arpabet_next_btn].includes(event.target)) {
+        window.arpabetMenuState.clickedRecord = undefined
+        arpabet_word_input.value = ""
+        arpabet_arpabet_input.value = ""
+    }
+})
+arpabet_prev_btn.addEventListener("click", () => {
+    window.arpabetMenuState.paginationIndex = Math.max(0, window.arpabetMenuState.paginationIndex-1)
+    window.refreshDictWordList()
+})
+arpabet_next_btn.addEventListener("click", () => {
+    window.arpabetMenuState.paginationIndex = Math.min(window.arpabetMenuState.totalPages-1, window.arpabetMenuState.paginationIndex+1)
+    window.refreshDictWordList()
+})
+
+window.arpabetRunSearch = () => {
+    if (!window.arpabetMenuState.currentDict) {
+        return
+    }
+    window.arpabetMenuState.paginationIndex = 0
+    window.arpabetMenuState.totalPages = 0
+
+    let query = arpabet_word_search_input.value.trim().toLowerCase()
+
+    if (!query.length) {
+        if (arpabet_search_only_enabled.checked) {
+            const filteredKeys = Object.keys(window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data).filter(key => window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[key].enabled)
+            window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData = {}
+            filteredKeys.forEach(key => {
+                window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData[key] = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[key]
+            })
+        } else {
+            window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data
+        }
+    } else {
+        const strictQuery = query.startsWith("\"")
+        const filteredKeys = Object.keys(window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data)
+        .filter(key => {
+            if (strictQuery) {
+                query = query.replaceAll("\"", "")
+                return key==query && (arpabet_search_only_enabled.checked ? (window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[key].enabled) : true)
+            } else {
+                return key.includes(query) && (arpabet_search_only_enabled.checked ? (window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[key].enabled) : true)
+            }
+        })
+
+        window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData = {}
+        filteredKeys.forEach(key => {
+            window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].filteredData[key] = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[key]
+        })
+    }
+
+    window.refreshDictWordList()
+}
+let arpabetSearchInterval
+arpabet_word_search_input.addEventListener("keyup", () => {
+    if (arpabetSearchInterval!=null) {
+        clearTimeout(arpabetSearchInterval)
+    }
+    arpabetSearchInterval = setTimeout(window.arpabetRunSearch, 500)
+})
+
+arpabet_enableall_button.addEventListener("click", () => {
+
+    const dictName = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].title
+    window.confirmModal(window.i18n.ARPABET_CONFIRM_ENABLE_ALL.replace("_1", dictName)).then(response => {
+        if (response) {
+            setTimeout(() => {
+                const wordKeys = Object.keys(window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data)
+                wordKeys.forEach(word => {
+                    window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[word].enabled = true
+                })
+
+                window.saveARPAbetDict(window.arpabetMenuState.currentDict)
+                window.arpabetRunSearch()
+            }, 210)
+        }
+    })
+})
+
+arpabet_disableall_button.addEventListener("click", () => {
+
+    const dictName = window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].title
+    window.confirmModal(window.i18n.ARPABET_CONFIRM_DISABLE_ALL.replace("_1", dictName)).then(response => {
+        if (response) {
+            setTimeout(() => {
+                const wordKeys = Object.keys(window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data)
+                wordKeys.forEach(word => {
+                    window.arpabetMenuState.dictionaries[window.arpabetMenuState.currentDict].data[word].enabled = false
+                })
+
+                window.saveARPAbetDict(window.arpabetMenuState.currentDict)
+                window.arpabetRunSearch()
+            }, 210)
+        }
+    })
+})
+arpabet_search_only_enabled.addEventListener("click", () => window.arpabetRunSearch())
+
+
+
+fs.watch(`${window.path}/arpabet`, {recursive: false, persistent: true}, (eventType, filename) => {console.log(eventType, filename);refreshDictionariesList()})

javascript/batch.js

@@ -0,0 +1,1573 @@
+"use strict"
+
+const path = require('path')
+const smi = require('node-nvidia-smi')
+
+window.batch_state = {
+    lines: [],
+    fastModeActuallyFinishedTasks: 0,
+    fastModeOutputPromises: [],
+    lastModel: undefined,
+    lastVocoder: undefined,
+    lineIndex: 0,
+    state: false,
+    outPathsChecked: [],
+    skippedExisting: 0,
+    paginationIndex: 0,
+    taskBarPercent: 0,
+    startTime: undefined,
+    linesDoneSinceStart: 0
+}
+
+
+// https://stackoverflow.com/questions/1293147/example-javascript-code-to-parse-csv-data
+function CSVToArray( strData, strDelimiter ){
+    // Check to see if the delimiter is defined. If not,
+    // then default to comma.
+    strDelimiter = (strDelimiter || ",");
+
+    // Create a regular expression to parse the CSV values.
+    var objPattern = new RegExp(
+        (
+            // Delimiters.
+            "(\\" + strDelimiter + "|\\r?\\n|\\r|^)" +
+
+            // Quoted fields.
+            "(?:\"([^\"]*(?:\"\"[^\"]*)*)\"|" +
+
+            // Standard fields.
+            "([^\"\\" + strDelimiter + "\\r\\n]*))"
+        ),
+        "gi"
+        );
+
+    // Create an array to hold our data. Give the array
+    // a default empty first row.
+    var arrData = [[]];
+
+    // Create an array to hold our individual pattern
+    // matching groups.
+    var arrMatches = null;
+
+    // Keep looping over the regular expression matches
+    // until we can no longer find a match.
+    while (arrMatches = objPattern.exec( strData )){
+
+        // Get the delimiter that was found.
+        var strMatchedDelimiter = arrMatches[ 1 ];
+
+        // Check to see if the given delimiter has a length
+        // (is not the start of string) and if it matches
+        // field delimiter. If id does not, then we know
+        // that this delimiter is a row delimiter.
+        if (
+            strMatchedDelimiter.length &&
+            strMatchedDelimiter !== strDelimiter
+            ){
+            // Since we have reached a new row of data,
+            // add an empty row to our data array.
+            arrData.push( [] );
+        }
+
+        var strMatchedValue;
+
+        // Now that we have our delimiter out of the way,
+        // let's check to see which kind of value we
+        // captured (quoted or unquoted).
+        if (arrMatches[ 2 ]){
+            // We found a quoted value. When we capture
+            // this value, unescape any double quotes.
+            strMatchedValue = arrMatches[ 2 ].replace(
+                new RegExp( "\"\"", "g" ),
+                "\""
+                );
+        } else {
+            // We found a non-quoted value.
+            strMatchedValue = arrMatches[ 3 ];
+
+        }
+
+        // Now that we have our value string, let's add
+        // it to the data array.
+        arrData[ arrData.length - 1 ].push( strMatchedValue );
+    }
+
+    // Return the parsed data.
+    return( arrData );
+}
+window.CSVToArray = CSVToArray
+
+let smiInterval = setInterval(() => {
+    try {
+        if (window.userSettings.useGPU) {
+            smi((err, data) => {
+                if (err) {
+                    console.log("smi error: ", err)
+                }
+                if (data && data.nvidia_smi_log.cuda_version) {
+                    let total
+                    let used
+
+                    if (data.nvidia_smi_log.gpu.length) {
+                        total = parseInt(data.nvidia_smi_log.gpu[0].fb_memory_usage.total.split(" ")[0])
+                        used = parseInt(data.nvidia_smi_log.gpu[0].fb_memory_usage.used.split(" ")[0])
+                    } else {
+                        total = parseInt(data.nvidia_smi_log.gpu.fb_memory_usage.total.split(" ")[0])
+                        used = parseInt(data.nvidia_smi_log.gpu.fb_memory_usage.used.split(" ")[0])
+                    }
+                    const percent = used/total*100
+
+                    vramUsage.innerHTML = `${(used/1000).toFixed(1)}/${(total/1000).toFixed(1)} GB (${percent.toFixed(2)}%)`
+                }
+            })
+        } else {
+            vramUsage.innerHTML = window.i18n.NOT_USING_GPU
+        }
+    } catch (e) {
+        console.log(e)
+        window.appLogger.log(e.stack)
+        clearInterval(smiInterval)
+    }
+}, 1000)
+
+batch_instructions_btn.addEventListener("click", () => {
+    window.createModal("error", `${window.i18n.BATCH_INSTR1} <a href="https://www.youtube.com/watch?v=PK-m54f84q4" target="_blank">${window.i18n.BATCH_INSTR2}</a> <span>${window.i18n.BATCH_INSTR3}</span>`)
+})
+
+batch_generateSample.addEventListener("click", () => {
+    // const lines = []
+    const csv = ["game_id,voice_id,text,vocoder,out_path,pacing"] // TODO: ffmpeg options
+    const games = Object.keys(window.games)
+
+    if (games.length==0) {
+        window.errorModal(window.i18n.BATCH_ERR_NO_VOICES)
+        return
+    }
+
+    const sampleText = [
+        "Include as many lines of text you wish with one line of data per line of voice to be read out.",
+        "Make sure that the required columns (game_id, voice_id, and text) are filled out",
+        "The others can be left blank, and the app will figure out some sensible defaults",
+        "The valid options for vocoder are one of: quickanddirty, waveglow, waveglowBIG, hifi",
+        "If your specified model does not have a bespoke hifi model, it will use the waveglow model, also the default if you leave this blank.",
+        "For all the other options, you can leave them blank.",
+        "If no output path is specified for a specific voice, the default batch output directory will be used",
+    ]
+
+    sampleText.forEach(line => {
+        const game = games[parseInt(Math.random()*games.length)]
+        const gameModels = window.games[game].models
+        const model = gameModels[parseInt(Math.random()*gameModels.length)].variants[0]
+
+        console.log("game", game, "model", model)
+
+        const record = {
+            game_id: game,
+            voice_id: model.voiceId,
+            text: line,
+            vocoder: ["quickanddirty","waveglow","waveglowBIG","hifi"][parseInt(Math.random()*4)],
+            out_path: "",
+            pacing: 1
+        }
+        // lines.push(record)
+        csv.push(Object.values(record).map(v => typeof v =="string" ? `"${v}"` : v).join(","))
+    })
+
+    const out_directory = `${__dirname.replace("\\javascript", "").replace(/\\/g,"/")}/batch`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app")
+    if (!fs.existsSync(out_directory)){
+        fs.mkdirSync(out_directory)
+    }
+    fs.writeFileSync(`${out_directory}/sample.csv`, csv.join("\n"))
+    // shell.showItemInFolder(`${out_directory}/sample.csv`)
+    er.shell.showItemInFolder(`${out_directory}/sample.csv`)
+    spawn(`explorer`, [out_directory], {stdio: "ignore"})
+})
+
+window.readFileTxt = (file) => {
+    return new Promise((resolve, reject) => {
+        const dataLines = []
+        const reader = new FileReader()
+        reader.readAsText(file)
+        reader.onloadend = () => {
+            const lines = reader.result.replace(/\r\n/g, "\n").split("\n")
+            lines.forEach(line => {
+                if (line.trim().length) {
+                    const record = {}
+                    record.game_id = window.currentModel.games[0].gameId
+                    record.voice_id = window.currentModel.games[0].voiceId
+                    record.text = line
+                    if (window.currentModel.hifi) {
+                        record.vocoder = "hifi"
+                    }
+                    dataLines.push(record)
+                }
+            })
+            resolve(dataLines)
+        }
+    })
+}
+
+window.readFile = (file) => {
+    return new Promise((resolve, reject) => {
+        const dataLines = []
+        const reader = new FileReader()
+        reader.readAsText(file)
+        reader.onloadend = () => {
+            const lines = reader.result.replace(/\r\n/g, "\n").split("\n")
+            const headerLine = lines.shift()
+
+            const doRest = () => {
+
+                const header = headerLine.split(window.userSettings.batch_delimiter).map(head => head.replace(/\r/, ""))
+
+                lines.forEach(line => {
+                    const record = {}
+                    if (line.trim().length) {
+                        const parts = CSVToArray(line, window.userSettings.batch_delimiter)[0]
+                        parts.forEach((val, vi) => {
+                            try {
+                                let header_val = header[vi].replace(/^"/, "").replace(/"$/, "")
+                                record[header_val.replace(/\s/g,"")] = (val||"").replace(/\\/g, "/")
+                            } catch (e) {
+                                window.errorModal(`Error parsing line: ${val}`)
+                                console.log(e)
+                                window.appLogger.log(e)
+                            }
+                        })
+                        dataLines.push(record)
+                    }
+                })
+                resolve(dataLines)
+            }
+
+            const headerLine_clean = headerLine.replaceAll("\"", "")
+            if (headerLine_clean.includes(window.userSettings.batch_delimiter)) {
+                doRest()
+            } else {
+                const potentialDelimiter = headerLine_clean.split("voice_id")[0].split("game_id")[1]
+
+                window.confirmModal(window.i18n.BATCH_CHANGE_DELIMITER.replace("_1", window.userSettings.batch_delimiter).replace("_2", potentialDelimiter)).then(response => {
+                    if (response) {
+                        window.userSettings.batch_delimiter = potentialDelimiter
+                        setting_batch_delimiter.value = potentialDelimiter
+                        window.saveUserSettings()
+                        doRest()
+                    }
+                })
+            }
+        }
+    })
+}
+
+let handleMetadataCSVdrop_response = undefined
+const sleep = ms => {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve()
+        }, ms)
+    })
+}
+const handleMetadataCSVdrop = (file) => {
+    return new Promise(async resolve => {
+        i18n_batch_metadata_open_btn.click()
+
+        handleMetadataCSVdrop_response = undefined
+        batch_metadata_input_gameID.value = window.currentGame.gameId
+        if (window.currentModel) {
+            batch_metadata_input_voiceID.value = window.currentModel.voiceId
+
+        }
+
+        await sleep(1000)
+        while (handleMetadataCSVdrop_response === undefined) {
+            if (batchMetadataCSVContainer.style.opacity.length==0 || parseFloat(batchMetadataCSVContainer.style.opacity)==1) {
+                await sleep(1000)
+            } else {
+                handleMetadataCSVdrop_response = false
+            }
+        }
+
+        if (handleMetadataCSVdrop_response) {
+
+            const dataLines = []
+            const reader = new FileReader()
+            reader.readAsText(file)
+            reader.onloadend = () => {
+                const lines = reader.result.replace(/\r\n/g, "\n").split("\n")
+                lines.forEach(line => {
+                    if (line.trim().length) {
+
+                        const text = line.split("|")[1]
+                        const record = {}
+                        record.game_id = batch_metadata_input_gameID.value
+                        record.voice_id = batch_metadata_input_voiceID.value
+                        record.text = text
+                        if (!window.currentModel || window.currentModel.hifi) {
+                            record.vocoder = "hifi"
+                        }
+                        dataLines.push(record)
+                    }
+                })
+                resolve(dataLines)
+            }
+
+        } else {
+            resolve(false)
+        }
+
+
+    })
+}
+i18n_batch_metadata_confirm_btn.addEventListener("click", () => {
+    handleMetadataCSVdrop_response = true
+    batchMetadataCSVContainer.click()
+    batchIcon.click()
+})
+
+window.uploadBatchCSVs = async (eType, event) => {
+
+    if (["dragenter", "dragover"].includes(eType)) {
+        batch_main.style.background = "#5b5b5b"
+        batch_main.style.color = "white"
+    }
+    if (["dragleave", "drop"].includes(eType)) {
+        batch_main.style.background = "#4b4b4b"
+        batch_main.style.color = "gray"
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+
+    const dataLines = []
+
+    if (eType=="drop") {
+
+        batchDropZoneNote.innerHTML = window.i18n.PROCESSING_DATA
+        window.batch_state.skippedExisting = 0
+
+        const dataTransfer = event.dataTransfer
+        const files = Array.from(dataTransfer.files)
+        for (let fi=0; fi<files.length; fi++) {
+            const file = files[fi]
+
+            if (!file.name.toLowerCase().endsWith(".csv") || file.name.toLowerCase()=="metadata.csv") {
+                if ( file.name.toLowerCase().endsWith(".txt") || file.name.toLowerCase()=="metadata.csv" ) {
+                    if (window.currentModel || file.name.toLowerCase()=="metadata.csv") {
+                        window.appLogger.log(`Reading file: ${file.name}`)
+
+                        let records
+
+                        if (file.name.toLowerCase()=="metadata.csv") {
+
+                            records = await handleMetadataCSVdrop(file)
+                            if (records===false) {
+                                continue
+                            }
+
+                        } else {
+                            if (window.currentModel) {
+                                records = await window.readFileTxt(file)
+                            }
+                        }
+
+                        if (window.currentModel || file.name.toLowerCase()=="metadata.csv") {
+                            if (window.userSettings.batch_skipExisting) {
+                                window.appLogger.log("Checking existing files before adding to queue")
+                            } else {
+                                window.appLogger.log("Adding files to queue")
+                            }
+                            records.forEach(item => {
+                                let outPath
+
+                                if (item.out_path && item.out_path.split("/").reverse()[0].includes(".")) {
+                                    outPath = item.out_path
+                                } else {
+                                    if (item.out_path) {
+                                        outPath = item.out_path
+                                    } else {
+                                        outPath = window.userSettings.batchOutFolder
+                                    }
+                                    if (item.vc_content) {
+                                        let vc_content_fname = item.vc_content.split("/").reverse()[0]
+                                        outPath = `${outPath}/${vc_content_fname.slice(0,vc_content_fname.length-4).slice(0, window.userSettings.max_filename_chars-10).replace(/\.$/, "")}.${window.userSettings.audio.format}`
+                                    } else {
+                                        outPath = `${outPath}/${item.voice_id}_${item.vocoder}_${item.text.replace(/[\/\\:\*?<>"|]*/g, "").slice(0, window.userSettings.max_filename_chars-10).replace(/\.$/, "")}.${window.userSettings.audio.format}`
+                                    }
+                                }
+
+                                outPath = outPath.startsWith("./") ? window.userSettings.batchOutFolder + outPath.slice(1,100000) : outPath
+                                item.out_path = outPath
+
+                                if (window.userSettings.batch_skipExisting && fs.existsSync(outPath)) {
+                                    window.batch_state.skippedExisting++
+                                } else {
+                                    dataLines.push(item)
+                                }
+                            })
+                        }
+
+                    }
+                    continue
+                } else {
+                    continue
+                }
+            }
+
+            window.appLogger.log(`Reading file: ${file.name}`)
+            const records = await window.readFile(file)
+            if (window.userSettings.batch_skipExisting) {
+                window.appLogger.log("Checking existing files before adding to queue")
+            } else {
+                window.appLogger.log("Adding files to queue")
+            }
+            records.forEach((item, ii) => {
+                let outPath
+
+                if (item.out_path && item.out_path.split("/").reverse()[0].includes(".")) {
+                    outPath = item.out_path
+                } else {
+                    if (item.out_path) {
+                        outPath = item.out_path
+                    } else {
+                        outPath = window.userSettings.batchOutFolder
+                    }
+                    if (item.vc_content) {
+                        let vc_content_fname = item.vc_content.split("/").reverse()[0]
+                        outPath = `${outPath}/${vc_content_fname.slice(0,vc_content_fname.length-4).slice(0,item.vc_content.length-4).slice(0, window.userSettings.max_filename_chars-10).replace(/\.$/, "")}.${window.userSettings.audio.format}`
+                    } else {
+                        outPath = `${outPath}/${item.voice_id}_${item.vocoder}_${item.text.replace(/[\/\\:\*?<>"|]*/g, "").slice(0, window.userSettings.max_filename_chars-10).replace(/\.$/, "")}.${window.userSettings.audio.format}`
+                    }
+                }
+
+                outPath = outPath.startsWith("./") ? window.userSettings.batchOutFolder + outPath.slice(1,100000) : outPath
+                item.out_path = outPath
+
+                if (window.userSettings.batch_skipExisting && fs.existsSync(outPath)) {
+                    window.batch_state.skippedExisting++
+                } else {
+                    dataLines.push(item)
+                }
+            })
+        }
+
+        if (dataLines.length==0 && window.batch_state.skippedExisting) {
+            batchDropZoneNote.innerHTML = window.i18n.BATCH_DROPZONE
+            return window.errorModal(window.i18n.BATCH_ERR_SKIPPEDALL.replace("_1", window.batch_state.skippedExisting))
+        }
+
+        window.batch_state.paginationIndex = 0
+        batch_pageNum.value = 1
+
+
+        window.appLogger.log("Preprocessing data...")
+        const cleanedData = window.preProcessCSVData(dataLines)
+        if (cleanedData.length) {
+            window.populateBatchRecordsList(cleanedData)
+            window.appLogger.log("Grouping up lines...")
+            const finalOrder = window.groupBatchLines()
+            window.refreshBatchRecordsList(finalOrder)
+            window.batch_state.lines = finalOrder
+        } else {
+            // batch_clearBtn.click()
+        }
+        window.appLogger.log("batch import done")
+
+        const numPages = Math.ceil(window.batch_state.lines.length/window.userSettings.batch_paginationSize)
+        batch_total_pages.innerHTML = `of ${numPages}`
+        batchDropZoneNote.innerHTML = window.i18n.BATCH_DROPZONE
+    }
+}
+
+window.preProcessCSVData = data => {
+
+    batch_main.style.display = "block"
+    batchDropZoneNote.style.display = "none"
+    batchRecordsHeader.style.display = "flex"
+    batch_clearBtn.style.display = "inline-block"
+    Array.from(batchRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${window.currentGame.themeColourPrimary}`)
+
+    const availableGames = Object.keys(window.games)
+    for (let di=0; di<data.length; di++) {
+        try {
+            const record = data[di]
+
+            // Validate the records first
+            // ==================
+            if (!record.game_id) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: ${window.i18n.MISSING} game_id`)
+                return []
+            }
+            if (!record.voice_id) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: ${window.i18n.MISSING} voice_id`)
+                return []
+            }
+            if ((!record.text || record.text.length==0) && (!record.vc_content)) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: ${window.i18n.MISSING} text/vc_content`)
+                return []
+            }
+
+            // Check that the game_id exists
+            if (!availableGames.includes(record.game_id)) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: game_id "${record.game_id}" ${window.i18n.BATCH_ERR_GAMEID} <br><br>(${availableGames.join(', ')})`)
+                return []
+            }
+            // Check that the voice_id exists
+            const gameVoices = []
+            window.games[record.game_id].models.forEach(model => {
+                model.variants.forEach(variant => gameVoices.push(variant.voiceId))
+            })
+
+            if (!gameVoices.includes(record.voice_id)) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: voice_id "${record.voice_id}" ${window.i18n.BATCH_ERR_VOICEID}: ${record.game_id}`)
+                return []
+            }
+            // Check that the vocoder exists
+            if (!["quickanddirty", "waveglow", "waveglowBIG", "hifi", "", "-", undefined].includes(record.vocoder)) {
+                window.errorModal(`[${window.i18n.LINE}: ${di+2}] ${window.i18n.ERROR}: ${window.i18n.BATCHH_VOCODER} "${record.vocoder}" ${window.i18n.BATCH_ERR_VOCODER1}: quickanddirty, waveglow, waveglowBIG, hifi ${window.i18n.BATCH_ERR_VOCODER2}`)
+                return []
+            }
+
+            data[di].modelType = undefined
+            let hasHifi = false
+            window.games[data[di].game_id].models.forEach(model => {
+                model.variants.forEach(variant => {
+                    if (variant.voiceId==data[di].voice_id) {
+                        data[di].modelType = variant.modelType || model.modelType
+                        record.voiceName = model.voiceName // For easy access later on
+                        if (variant.hifi) {
+                            hasHifi = variant.hifi
+                        }
+                        if (variant.lang && !record.lang) {
+                            record.lang = "en"
+                        }
+                        // TODO allow batch mode voice conversion/speech to speech by computing the embs of specified audio files instead of using the base voice embedding
+                        // Also TODO, might need to allow for custom voice embeddings
+                        if (variant.modelType=="xVAPitch") {
+                            record.base_emb = variant.base_speaker_emb
+                            record.vocoder = "-"
+                        }
+                    }
+                })
+            })
+
+            // Fill with defaults
+            // ==================
+            if (!record.out_path) {
+                record.out_path = window.userSettings.batchOutFolder
+            }
+            if (!record.pacing) {
+                record.pacing = 1
+            }
+            record.pacing = parseFloat(record.pacing)
+
+
+            if (!record.pitch_amp) {
+                record.pitch_amp = 1
+            }
+            record.pitch_amp = parseFloat(record.pitch_amp)
+
+            if (!record.out_path.includes(":/") && !record.out_path.startsWith("./")) {
+                record.out_path = `./${record.out_path}`
+            }
+
+            if (!record.vocoder || (record.vocoder=="hifi" && !hasHifi)) {
+                record.vocoder = "quickanddirty"
+            }
+        } catch (e) {
+            console.log(e)
+            window.appLogger.log(e)
+            console.log(data[di])
+            console.log(window.games[data[di].game_id])
+        }
+    }
+
+    return data
+}
+
+window.populateBatchRecordsList = records => {
+    batch_synthesizeBtn.style.display = "inline-block"
+    batchDropZoneNote.style.display = "none"
+
+    records.forEach((record, ri) => {
+        const row = createElem("div")
+
+        const rNumElem = createElem("div", batchRecordsContainer.children.length.toString())
+        const rStatusElem = createElem("div", "Ready")
+        const rActionsElem = createElem("div")
+        const rVoiceElem = createElem("div", record.voice_id)
+        const rTextElem = createElem("div", (record.vc_content?record.vc_content:record.text).toString())
+        rTextElem.title = rTextElem.innerText
+        if (record.vc_content) {
+            rTextElem.style.fontStyle = "italic"
+        }
+        const rGameElem = createElem("div", record.game_id)
+        const rOutPathElem = createElem("div", "&lrm;"+record.out_path+"&lrm;")
+        rOutPathElem.title = record.out_path
+        const rBaseLangElem = createElem("div", record.vc_content?"-":(record.lang||" ").toString())
+        const rVCStyleElem = createElem("div", (record.vc_style||" ").toString())
+        rVCStyleElem.title = rVCStyleElem.innerText
+        const rVocoderElem = createElem("div", record.vocoder)
+        const rPacingElem = createElem("div", record.vc_content?"-":(record.pacing||" ").toString())
+        const rPitchAmpElem = createElem("div", record.vc_content?"-":(record.pitch_amp||" ").toString())
+
+
+        row.appendChild(rNumElem)
+        row.appendChild(rStatusElem)
+        row.appendChild(rActionsElem)
+        row.appendChild(rVoiceElem)
+        row.appendChild(rTextElem)
+        row.appendChild(rGameElem)
+        row.appendChild(rOutPathElem)
+        row.appendChild(rBaseLangElem)
+        row.appendChild(rVCStyleElem)
+        row.appendChild(rVocoderElem)
+        row.appendChild(rPacingElem)
+        row.appendChild(rPitchAmpElem)
+
+        window.batch_state.lines.push([record, row, ri])
+    })
+}
+
+window.refreshBatchRecordsList = (finalOrder) => {
+    batchRecordsContainer.innerHTML = ""
+    finalOrder = finalOrder ? finalOrder : window.batch_state.lines
+
+    const startIndex = (window.batch_state.paginationIndex*window.userSettings.batch_paginationSize)
+    const endIndex = Math.min(startIndex+window.userSettings.batch_paginationSize, finalOrder.length)
+
+    for (let ri=startIndex; ri<endIndex; ri++) {
+        const recordAndElem = finalOrder[ri]
+        recordAndElem[1].children[0].innerHTML = (ri+1)//batchRecordsContainer.children.length.toString()
+        batchRecordsContainer.appendChild(recordAndElem[1])
+    }
+    window.toggleNumericalRecordsDisplay()
+}
+
+// Sort the lines by voice_id, and then by vocoder used
+window.groupBatchLines = () => {
+    if (window.userSettings.batch_doGrouping) {
+        const voices_order = []
+
+        const lines = window.batch_state.lines.sort((a,b) => {
+            return a.voice_id - b.voice_id
+        })
+
+        const voices_groups = {}
+
+        // Get the order of the voice_id, and group them up
+        window.batch_state.lines.forEach(record => {
+            if (!voices_order.includes(record[0].voice_id)) {
+                voices_order.push(record[0].voice_id)
+                voices_groups[record[0].voice_id] = []
+            }
+            voices_groups[record[0].voice_id].push(record)
+        })
+
+        // Go through the voice groups and sort them by vocoder
+        if (window.userSettings.batch_doVocoderGrouping) {
+            voices_order.forEach(voice_id => {
+                voices_groups[voice_id] = voices_groups[voice_id].sort((a,b) => a[0].vocoder<b[0].vocoder?1:-1)
+            })
+        }
+
+        // Collate everything back into the final order
+        const finalOrder = []
+        voices_order.forEach(voice_id => {
+            voices_groups[voice_id].forEach(record => finalOrder.push(record))
+        })
+
+        return finalOrder
+
+    } else {
+        return window.batch_state.lines
+    }
+}
+
+
+batch_clearBtn.addEventListener("click", () => {
+
+    window.batch_state.lines = []
+    batch_main.style.display = "flex"
+    batchDropZoneNote.style.display = "block"
+    batchRecordsHeader.style.display = "none"
+    batch_clearBtn.style.display = "none"
+    batch_outputFolderInput.style.display = "inline-block"
+    batch_clearDirOpts.style.display = "flex"
+    batch_skipExistingOpts.style.display = "flex"
+    batch_useSR.style.display = "flex"
+    batch_useCleanup.style.display = "flex"
+    batch_outputNumericallyOpts.style.display = "flex"
+    batch_progressItems.style.display = "none"
+    batch_progressBar.style.display = "none"
+
+    batch_pauseBtn.style.display = "none"
+    batch_stopBtn.style.display = "none"
+    batch_synthesizeBtn.style.display = "none"
+
+    batchRecordsContainer.innerHTML = ""
+})
+
+
+window.startBatch = () => {
+
+    // Output directory
+    if (!fs.existsSync(window.userSettings.batchOutFolder)) {
+        window.userSettings.batchOutFolder.split("/")
+        .reduce((prevPath, folder) => {
+            const currentPath = path.join(prevPath, folder, path.sep);
+            if (!fs.existsSync(currentPath)){
+                try {
+                    fs.mkdirSync(currentPath);
+                } catch (e) {
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}:<br><br>`+e.message)
+                    throw ""
+                }
+            }
+            return currentPath;
+         }, '');
+    }
+    if (batch_clearDirFirstCkbx.checked) {
+        const filesAndFolders = fs.readdirSync(window.userSettings.batchOutFolder)
+        filesAndFolders.forEach(faf => {
+            // Ignore .csv and .txt files
+            if (faf.toLowerCase().endsWith(".csv") || faf.toLowerCase().endsWith(".txt")) {
+                return
+            }
+            if (fs.lstatSync(`${window.userSettings.batchOutFolder}/${faf}`).isDirectory()) {
+                window.deleteFolderRecursive(`${window.userSettings.batchOutFolder}/${faf}`, false)
+            } else {
+                fs.unlinkSync(`${window.userSettings.batchOutFolder}/${faf}`)
+            }
+            console.log(`${window.userSettings.batchOutFolder}/${faf}`,  )
+        })
+    }
+
+    batch_synthesizeBtn.style.display = "none"
+    batch_clearBtn.style.display = "none"
+    batch_outputFolderInput.style.display = "none"
+    batch_clearDirOpts.style.display = "none"
+    batch_skipExistingOpts.style.display = "none"
+    batch_useSR.style.display = "none"
+    batch_useCleanup.style.display = "none"
+    batch_outputNumericallyOpts.style.display = "none"
+    batch_progressItems.style.display = "flex"
+    batch_progressBar.style.display = "flex"
+    batch_pauseBtn.style.display = "inline-block"
+    batch_stopBtn.style.display = "inline-block"
+    batch_openDirBtn.style.display = "none"
+
+    window.batch_state.lines.forEach(record => {
+        record[1].children[1].innerHTML = window.i18n.READY
+        record[1].children[1].style.background = "none"
+    })
+
+    window.batch_state.fastModeOutputPromises = []
+    window.batch_state.fastModeActuallyFinishedTasks = 0
+    window.batch_state.lineIndex = 0
+    window.batch_state.state = true
+    window.batch_state.outPathsChecked = []
+    window.batch_state.startTime = new Date()
+    window.batch_state.linesDoneSinceStart = 0
+    window.performSynthesis()
+}
+
+window.batchChangeVoice = (game, voice, modelType) => {
+    return new Promise((resolve) => {
+        if (!window.batch_state.state) {
+            return resolve()
+        }
+        // Update the main app with any changes, if a voice has already been selected
+        if (window.currentModel) {
+            generateVoiceButton.innerHTML = window.i18n.LOAD_MODEL
+            keepSampleButton.style.display = "none"
+            wavesurferContainer.innerHTML = ""
+
+            const modelGameFolder = window.currentModel.audioPreviewPath.split("/")[0]
+            const modelFileName = window.currentModel.audioPreviewPath.split("/")[1].split(".wav")[0]
+            generateVoiceButton.dataset.modelQuery = JSON.stringify({
+                outputs: parseInt(window.currentModel.outputs),
+                model: `${window.path}/models/${modelGameFolder}/${modelFileName}`,
+                model_speakers: window.currentModel.emb_size,
+                cmudict: window.currentModel.cmudict
+            })
+        }
+
+
+        if (window.batch_state.state) {
+            batch_progressNotes.innerHTML = `${window.i18n.BATCH_CHANGING_MODEL_TO}: ${voice}`
+        }
+
+        let model
+        window.games[game].models.forEach(gameModel => {
+            gameModel.variants.forEach(variant => {
+                if (variant.voiceId==voice) {
+                    model = variant
+                }
+            })
+        })
+
+        doFetch(`http://localhost:8008/loadModel`, {
+            method: "Post",
+            body: JSON.stringify({
+                "modelType": modelType,
+                "outputs": null,
+                "model": `${window.userSettings[`modelspath_${game}`]}/${voice}`,
+                "model_speakers": model.num_speakers,
+                "base_lang": model.lang,
+                "pluginsContext": JSON.stringify(window.pluginsContext)
+            })
+        }).then(r=>r.text()).then(res => {
+            resolve()
+        }).catch(async e => {
+            if (e.code=="ECONNREFUSED" || e.code=="ECONNRESET") {
+                await window.batchChangeVoice(game, voice, modelType)
+                resolve()
+            } else {
+                console.log(e)
+                window.appLogger.log(e)
+                batch_pauseBtn.click()
+
+                if (document.getElementById("activeModal")) {
+                    activeModal.remove()
+                }
+                if (e.code=="ENOENT") {
+                    window.errorModal(window.i18n.ERR_SERVER)
+                } else {
+                    window.errorModal(e.message)
+                }
+                resolve()
+            }
+        })
+    })
+}
+window.batchChangeVocoder = (vocoder, game, voice) => {
+    return new Promise((resolve) => {
+        if (!window.batch_state.state) {
+            return resolve()
+        }
+        console.log("Changing vocoder: ", vocoder)
+        if (window.batch_state.state) {
+            batch_progressNotes.innerHTML = `${window.i18n.BATCH_CHANGING_VOCODER_TO}: ${vocoder}`
+        }
+
+        const vocoderMappings = [["waveglow", "256_waveglow"], ["waveglowBIG", "big_waveglow"], ["quickanddirty", "qnd"], ["hifi", `${game}/${voice}.hg.pt`]]
+        const vocoderId = vocoderMappings.find(record => record[0]==vocoder)[1]
+
+        doFetch(`http://localhost:8008/setVocoder`, {
+            method: "Post",
+            body: JSON.stringify({
+                vocoder: vocoderId,
+                modelPath: vocoderId=="256_waveglow" ? window.userSettings.waveglow_path : window.userSettings.bigwaveglow_path,
+            })
+        }).then(r=>r.text()).then((res) => {
+            if (res=="ENOENT") {
+                closeModal(undefined, batchGenerationContainer).then(() => {
+                    setTimeout(() => {
+                        vocoder_select.value = window.userSettings.vocoder
+                        window.errorModal(`${window.i18n.BATCH_MODEL_NOT_FOUND}.${vocoderId.includes("waveglow")?" "+window.i18n.BATCH_DOWNLOAD_WAVEGLOW:""}`)
+                        batch_pauseBtn.click()
+                        resolve()
+                    }, 300)
+                })
+            } else {
+                window.batch_state.lastVocoder = vocoder
+                resolve()
+            }
+        }).catch(async e => {
+            if (e.code=="ECONNREFUSED" || e.code=="ECONNRESET") {
+                await window.batchChangeVocoder(vocoder, game, voice)
+                resolve()
+            } else {
+                console.log(e)
+                window.appLogger.log(e)
+                batch_pauseBtn.click()
+
+                if (document.getElementById("activeModal")) {
+                    activeModal.remove()
+                }
+                if (e.code=="ENOENT") {
+                    window.errorModal(window.i18n.ERR_SERVER)
+                } else {
+                    window.errorModal(e.message)
+                }
+                resolve()
+            }
+        })
+    })
+}
+
+
+window.prepareLinesBatchForSynth = () => {
+
+    const linesBatch = []
+    const records = []
+    let firstItemVoiceId = undefined
+    let firstItemVocoder = undefined
+    let speaker_i = 0
+
+    for (let i=0; i<Math.min(window.userSettings.batch_batchSize, window.batch_state.lines.length-window.batch_state.lineIndex); i++) {
+
+        const record = window.batch_state.lines[window.batch_state.lineIndex+i]
+
+        const vocoderMappings = [["waveglow", "256_waveglow"], ["waveglowBIG", "big_waveglow"], ["quickanddirty", "qnd"], ["hifi", `${record[0].game_id}/${record[0].voice_id}.hg.pt`]]
+        const vocoder = record[0].vocoder=="-"?"-":vocoderMappings.find(voc => voc[0]==record[0].vocoder)[1]
+
+        if (firstItemVoiceId==undefined) firstItemVoiceId = record[0].voice_id
+        if (firstItemVocoder==undefined) firstItemVocoder = vocoder
+
+        if (record[0].voice_id!=firstItemVoiceId || vocoder!=firstItemVocoder) {
+            break
+        }
+
+        let model
+        window.games[record[0].game_id].models.forEach(gamesModel => {
+            gamesModel.variants.forEach(variant => {
+                if (variant.voiceId==record[0].voice_id) {
+                    model = variant
+                }
+            })
+        })
+
+        const sequence = record[0].text
+        const pitch = undefined // maybe later
+        const duration = undefined // maybe later
+        speaker_i = model.emb_i || 0
+        let pace = record[0].pacing
+        pace = Number.isNaN(pace) ? 1.0 : pace
+        let pitch_amp = record[0].pitch_amp
+        pitch_amp = Number.isNaN(pitch_amp) ? 1.0 : pitch_amp
+
+        const tempFileNum = `${Math.random().toString().split(".")[1]}`
+        const tempFileLocation = `${window.path}/output/temp-${tempFileNum}.wav`
+
+        let outPath
+        let outFolder
+
+        outPath = record[0].out_path
+        outFolder = String(record[0].out_path).split("/").reverse().slice(1,10000).reverse().join("/")
+        outFolder = outFolder.length ? outFolder : window.userSettings.batchOutFolder
+
+        if (batch_outputNumerically.checked) {
+            outPath = `${window.userSettings.batchOutFolder}/${String(record[2]).padStart(10, '0')}.${outPath.split(".").reverse()[0]}`
+        } else {
+            outPath = outPath.startsWith("./") ? window.userSettings.batchOutFolder + outPath.slice(1,100000) : outPath
+        }
+
+        linesBatch.push([sequence, pitch, duration, pace, tempFileLocation, outPath, outFolder, pitch_amp, record[0].lang, record[0].base_emb, record[0].vc_content, record[0].vc_style])
+        records.push(record)
+    }
+
+    return [speaker_i, firstItemVoiceId, firstItemVocoder, linesBatch, records]
+}
+
+
+window.addActionButtons = (records, ri) => {
+
+    let audioPreview
+    const playButton = createElem("button.smallButton", window.i18n.PLAY)
+    playButton.style.background = `#${window.currentGame.themeColourPrimary}`
+    playButton.addEventListener("click", () => {
+
+        let audioPreviewPath = records[ri][0].fileOutputPath
+        if (audioPreviewPath.startsWith("./")) {
+            audioPreviewPath = window.userSettings.batchOutFolder + audioPreviewPath.replace("./", "/")
+        }
+
+        if (audioPreview==undefined) {
+            const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+                src: audioPreviewPath
+            }))
+            audioPreview.addEventListener("play", () => {
+                if (window.ctrlKeyIsPressed) {
+                    audioPreview.setSinkId(window.userSettings.alt_speaker)
+                } else {
+                    audioPreview.setSinkId(window.userSettings.base_speaker)
+                }
+            })
+            audioPreview.setSinkId(window.userSettings.base_speaker)
+        }
+    })
+    records[ri][1].children[2].appendChild(playButton)
+
+    // If not a Voice Conversion line
+    if (!records[ri][0].vc_content) {
+        const editButton = createElem("button.smallButton", window.i18n.EDIT)
+        editButton.style.background = `#${window.currentGame.themeColourPrimary}`
+        editButton.addEventListener("click", () => {
+            audioPreview = undefined
+
+
+            if (window.batch_state.state) {
+                window.errorModal(window.i18n.BATCH_ERR_EDIT)
+                return
+            }
+
+            // Change app theme to the voice's game
+            if (window.currentGame.gameId!=records[ri][0].game_id) {
+                window.changeGame(window.gameAssets[records[ri][0].game_id])
+            }
+
+            dialogueInput.value = records[ri][0].text
+
+            // Simulate voice loading through the UI
+            if (!window.currentModel || window.currentModel.voiceId != records[ri][0].voice_id) {
+                const voiceName = records[ri][0].voiceName
+                const voiceButton = Array.from(voiceTypeContainer.children).find(button => button.innerHTML==voiceName)
+                voiceButton.click()
+                vocoder_select.value = records[ri][0].vocoder=="hifi" ? `${records[ri][0].game_id}/${records[ri][0].voice_id}.hg.pt` : records[ri][0].vocoder
+                generateVoiceButton.click()
+            }
+            window.closeModal(batchGenerationContainer)
+
+            setTimeout(() => {
+                let audioPreviewPath = records[ri][0].fileOutputPath
+                if (audioPreviewPath.startsWith("./")) {
+                    audioPreviewPath = window.userSettings.batchOutFolder + audioPreviewPath.replace("./", "/")
+                }
+                keepSampleButton.dataset.newFileLocation = "BATCH_EDIT"+audioPreviewPath
+                generateVoiceButton.click()
+            }, 500)
+        })
+        records[ri][1].children[2].appendChild(editButton)
+    }
+}
+
+
+window.batchKickOffMPffmpegOutput = (records, tempPaths, outPaths, options, extraInfo) => {
+    let hasShownError = false
+    return new Promise((resolve, reject) => {
+        doFetch(`http://localhost:8008/batchOutputAudio`, {
+            method: "Post",
+            body: JSON.stringify({
+                input_paths: tempPaths,
+                output_paths: outPaths,
+                isBatchMode: true,
+                pluginsContext: JSON.stringify(window.pluginsContext),
+                processes: window.userSettings.batch_MPCount,
+                extraInfo: extraInfo,
+                options: JSON.stringify(options)
+            })
+        }).then(r=>r.text()).then(res => {
+            res = res.split("\n")
+            res.forEach((resItem, ri) => {
+                if (resItem.length && resItem!="-") {
+                    window.appLogger.log(`Batch error, item ${ri} - ${resItem}`)
+                    if (window.batch_state.state) {
+                        batch_pauseBtn.click()
+                    }
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}:<br><br>`+resItem)
+                    hasShownError = true
+
+                    records[ri][1].children[1].innerHTML = window.i18n.FAILED
+                    records[ri][1].children[1].style.background = "red"
+
+                } else {
+
+                    records[ri][1].children[1].innerHTML = window.i18n.DONE
+                    records[ri][1].children[1].style.background = "green"
+                    fs.unlinkSync(tempPaths[ri])
+                    window.addActionButtons(records, ri)
+                }
+
+                // if (!window.userSettings.batch_fastMode) { // No more fast modde. TODO, remove completely
+                window.batch_state.lineIndex += 1
+                // }
+
+                window.batch_state.fastModeActuallyFinishedTasks += 1
+
+            })
+            const percentDone = (window.batch_state.fastModeActuallyFinishedTasks) / window.batch_state.lines.length * 100
+            batch_progressBar.style.background = `linear-gradient(90deg, green ${parseInt(percentDone)}%, rgba(255,255,255,0) ${parseInt(percentDone)}%)`
+            batch_progressBar.innerHTML = `${parseInt(percentDone* 100)/100}%`
+            window.batch_state.taskBarPercent = percentDone/100
+            window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent)
+            window.adjustETA()
+            resolve()
+
+        }).catch(async e => {
+            if (e.code=="ECONNREFUSED" || e.code=="ECONNRESET") {
+                await window.batchKickOffMPffmpegOutput(records, tempPaths, outPaths, options, extraInfo)
+                resolve()
+            } else {
+                console.log(e)
+                window.appLogger.log(e.stack)
+                if (document.getElementById("activeModal")) {
+                    activeModal.remove()
+                }
+                if (!hasShownError) {
+                    window.errorModal(e.message)
+                }
+                resolve()
+            }
+        })
+    })
+}
+
+
+window.batchKickOffFfmpegOutput = (ri, linesBatch, records, tempFileLocation, body) => {
+    return new Promise((resolve, reject) => {
+        doFetch(`http://localhost:8008/outputAudio`, {
+            method: "Post",
+            body
+        }).then(r=>r.text()).then(res => {
+            if (res.length && res!="-") {
+                window.appLogger.log("res", res)
+                if (window.batch_state.state) {
+                    batch_pauseBtn.click()
+                }
+
+                for (let ri2=ri; ri2<linesBatch.length; ri2++) {
+                    records[ri][1].children[1].innerHTML = window.i18n.FAILED
+                    records[ri][1].children[1].style.background = "red"
+                }
+
+                reject(res)
+            } else {
+                records[ri][1].children[1].innerHTML = window.i18n.DONE
+                records[ri][1].children[1].style.background = "green"
+                fs.unlinkSync(tempFileLocation)
+                window.addActionButtons(records, ri)
+                window.batch_state.fastModeActuallyFinishedTasks += 1
+
+                const percentDone = (window.batch_state.fastModeActuallyFinishedTasks) / window.batch_state.lines.length * 100
+                batch_progressBar.style.background = `linear-gradient(90deg, green ${parseInt(percentDone)}%, rgba(255,255,255,0) ${parseInt(percentDone)}%)`
+                batch_progressBar.innerHTML = `${parseInt(percentDone* 100)/100}%`
+                window.batch_state.taskBarPercent = percentDone/100
+                window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent)
+                window.adjustETA()
+                resolve()
+            }
+        }).catch(async e => {
+            if (e.code=="ECONNREFUSED" || e.code=="ECONNRESET") {
+                await window.batchKickOffFfmpegOutput(ri, linesBatch, records, tempFileLocation, body)
+                resolve()
+            } else {
+                console.log(e)
+                window.appLogger.log(e)
+                batch_pauseBtn.click()
+                if (document.getElementById("activeModal")) {
+                    activeModal.remove()
+                }
+                window.errorModal(e.message)
+                resolve()
+            }
+        })
+    })
+}
+
+window.batchKickOffGeneration = () => {
+    return new Promise((resolve) => {
+        if (!window.batch_state.state) {
+            return resolve()
+        }
+        const [speaker_i, voice_id, vocoder, linesBatch, records] = window.prepareLinesBatchForSynth()
+
+        records.forEach((record, ri) => {
+            record[1].children[1].innerHTML = window.i18n.RUNNING
+            record[1].children[1].style.background = "goldenrod"
+            record[0].fileOutputPath = linesBatch[ri][5]
+        })
+
+        const record = window.batch_state.lines[window.batch_state.lineIndex]
+
+        if (window.batch_state.state) {
+            if (linesBatch.length==1) {
+                batch_progressNotes.innerHTML = `${window.i18n.SYNTHESIZING}: <i>${record[0].text}</i>`
+            } else {
+                batch_progressNotes.innerHTML = `${window.i18n.SYNTHESIZING} ${linesBatch.length} ${window.i18n.LINES}`
+            }
+        }
+        const batchPostData = {
+            modelType: records[0][0].modelType,
+            batchSize: window.userSettings.batch_batchSize,
+            defaultOutFolder: window.userSettings.batchOutFolder,
+            pluginsContext: JSON.stringify(window.pluginsContext),
+            outputJSON: window.userSettings.batch_json,
+            useSR: batch_useSRCkbx.checked,
+            useCleanup: batch_useCleanupCkbx.checked,
+            speaker_i, vocoder, linesBatch
+        }
+        doFetch(`http://localhost:8008/synthesize_batch`, {
+            method: "Post",
+            body: JSON.stringify(batchPostData)
+        }).then(r=>r.text()).then(async (res) => {
+
+            if (res && res!="-") {
+                if (res=="CUDA OOM") {
+                    window.errorModal(window.i18n.BATCH_ERR_CUDA_OOM)
+                } else {
+                    window.errorModal(res.replace(/\n/g, "<br>"))
+                }
+                if (window.batch_state.state) {
+                    batch_pauseBtn.click()
+                }
+                return
+            }
+
+
+            // Create the output directory if it does not exist
+            linesBatch.forEach(record => {
+                let outFolder = record[6].startsWith("./") ? window.userSettings.batchOutFolder + record[6].slice(1,100000) : record[6]
+
+                if (!window.batch_state.outPathsChecked.includes(outFolder)) {
+                    window.batch_state.outPathsChecked.push(outFolder)
+                    if (!fs.existsSync(outFolder)) {
+                        window.createFolderRecursive(outFolder)
+                    }
+                }
+            })
+
+            if (window.userSettings.audio.ffmpeg) {
+                const options = {
+                    hz: window.userSettings.audio.hz,
+                    padStart: window.userSettings.audio.padStart,
+                    padEnd: window.userSettings.audio.padEnd,
+                    bit_depth: window.userSettings.audio.bitdepth,
+                    amplitude: window.userSettings.audio.amplitude,
+                    pitchMult: window.userSettings.audio.pitchMult,
+                    tempo: window.userSettings.audio.tempo,
+                    deessing: window.userSettings.audio.deessing,
+                    nr: window.userSettings.audio.nr,
+                    nf: window.userSettings.audio.nf,
+                    useNR: window.userSettings.audio.useNR,
+                    useSR: batch_useSRCkbx.checked,
+                    useCleanup: batch_useCleanupCkbx.checked,
+                }
+
+                if (window.batch_state.state) {
+                    batch_progressNotes.innerHTML = window.i18n.BATCH_OUTPUTTING_FFMPEG
+                }
+
+                const tempPaths = linesBatch.map(line => line[4])
+                const outPaths = linesBatch.map((line, li) => {
+                    let outPath = linesBatch[li][5].includes(":") || linesBatch[li][5].includes("./") ? linesBatch[li][5] : `${linesBatch[li][6]}/${linesBatch[li][5]}`
+                    if (outPath.startsWith("./")) {
+                        outPath = window.userSettings.batchOutFolder + outPath.slice(1,100000)
+                    }
+                    return outPath
+                })
+
+                if (window.userSettings.batch_useMP) {
+                    const extraInfo = {
+                        game: records.map(rec => rec[0].game_id),
+                        voiceId: records.map(rec => rec[0].voice_id),
+                        voiceName: records.map(rec => rec[0].voiceName),
+                        inputSequence: records.map(rec => rec[0].text)
+                    }
+                    if (window.userSettings.batch_fastMode && false) { // No more fast mode. TODO, remove completely
+                        window.batch_state.fastModeOutputPromises.push(window.batchKickOffMPffmpegOutput(records, tempPaths, outPaths, options, JSON.stringify(extraInfo)))
+                        window.batch_state.lineIndex += records.length
+                    } else {
+                        await window.batchKickOffMPffmpegOutput(records, tempPaths, outPaths, options, JSON.stringify(extraInfo))
+                    }
+                } else {
+                    for (let ri=0; ri<linesBatch.length; ri++) {
+                        let tempFileLocation = tempPaths[ri]
+                        let outPath = outPaths[ri]
+                        try {
+                            if (window.batch_state.state) {
+                                records[ri][1].children[1].innerHTML = window.i18n.OUTPUTTING
+                                const extraInfo = {
+                                    game: records[ri][0].game_id,
+                                    voiceId: records[ri][0].voiceId,
+                                    voiceName: records[ri][0].voiceName,
+                                    letters: records[ri][0].text
+                                }
+
+                                if (window.userSettings.batch_fastMode && false) { // No more fast modde. TODO, remove completely
+                                    window.batch_state.fastModeOutputPromises.push(window.batchKickOffFfmpegOutput(ri, linesBatch, records, tempFileLocation, JSON.stringify({
+                                        input_path: tempFileLocation,
+                                        output_path: outPath,
+                                        isBatchMode: true,
+                                        pluginsContext: JSON.stringify(window.pluginsContext),
+                                        extraInfo: JSON.stringify(extraInfo),
+                                        options: JSON.stringify(options)
+                                    })))
+                                } else {
+                                    await window.batchKickOffFfmpegOutput(ri, linesBatch, records, tempFileLocation, JSON.stringify({
+                                        input_path: tempFileLocation,
+                                        output_path: outPath,
+                                        isBatchMode: true,
+                                        pluginsContext: JSON.stringify(window.pluginsContext),
+                                        extraInfo: JSON.stringify(extraInfo),
+                                        options: JSON.stringify(options)
+                                    }))
+                                }
+                                window.batch_state.lineIndex += 1
+                            }
+                        } catch (e) {
+                            console.log(e)
+                            window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}:<br><br>`+e)
+                            resolve()
+                        }
+                    }
+                }
+                window.batch_state.linesDoneSinceStart += linesBatch.length
+                resolve()
+            } else {
+                linesBatch.forEach((lineRecord, li) => {
+                    let tempFileLocation = lineRecord[4]
+                    let outPath = lineRecord[5]
+                    try {
+                        fs.copyFileSync(tempFileLocation, outPath)
+                        records[li][1].children[1].innerHTML = window.i18n.DONE
+                        records[li][1].children[1].style.background = "green"
+
+                        window.batch_state.lineIndex += 1
+
+                        window.addActionButtons(records, li)
+
+                    } catch (err) {
+                        console.log(err)
+                        window.appLogger.log(err)
+                        window.errorModal(err.message)
+                        batch_pauseBtn.click()
+                    }
+                    window.batch_state.linesDoneSinceStart += linesBatch.length
+                    resolve()
+                })
+            }
+        }).catch(async e => {
+            if (e.code=="ECONNREFUSED" || e.code=="ECONNRESET") {
+                await window.batchKickOffGeneration()
+                resolve()
+            } else {
+                console.log(e)
+                window.appLogger.log(e)
+                batch_pauseBtn.click()
+                if (document.getElementById("activeModal")) {
+                    activeModal.remove()
+                }
+                console.log(e.message)
+                window.errorModal(e.message).then(() => resolve())
+            }
+        })
+    })
+}
+
+window.performSynthesis = async () => {
+
+    if (batch_state.lineIndex-batch_state.fastModeActuallyFinishedTasks > window.userSettings.batch_fastModeMaxParallelizations) {
+        console.log(`Ahead by ${batch_state.lineIndex-batch_state.fastModeActuallyFinishedTasks} tasks. Waiting...`)
+        setTimeout(() => {window.performSynthesis()}, 1000)
+        return
+    }
+
+    if (!window.batch_state.state) {
+        return
+    }
+
+    if (window.batch_state.lineIndex==0) {
+        const percentDone = (window.batch_state.lineIndex) / window.batch_state.lines.length * 100
+        batch_progressBar.style.background = `linear-gradient(90deg, green ${parseInt(percentDone)}%, rgba(255,255,255,0) ${parseInt(percentDone)}%)`
+        batch_progressBar.innerHTML = `${parseInt(percentDone* 100)/100}%`
+        window.batch_state.taskBarPercent = percentDone/100
+        window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent)
+    }
+
+
+    const record = window.batch_state.lines[window.batch_state.lineIndex]
+
+    // Change the voice model if the next line uses a different one
+    if (window.batch_state.lastModel!=record[0].voice_id) {
+        await window.batchChangeVoice(record[0].game_id, record[0].voice_id, record[0].modelType)
+        window.batch_state.lastModel = record[0].voice_id
+    }
+
+    // Change the vocoder if the next line uses a different one
+    if (window.batch_state.lastVocoder!=record[0].vocoder && record[0].vocoder!="-") {
+        await window.batchChangeVocoder(record[0].vocoder, record[0].game_id, record[0].voice_id)
+    }
+
+    await window.batchKickOffGeneration()
+
+    if (window.batch_state.lineIndex==window.batch_state.lines.length) {
+        // The end
+        if (window.userSettings.batch_fastMode && false) { // No more fast modde. TODO, remove completely
+            Promise.all(window.batch_state.fastModeOutputPromises).then(() => {
+                window.stopBatch()
+                batch_openDirBtn.style.display = "inline-block"
+            })
+        } else {
+            window.stopBatch()
+            batch_openDirBtn.style.display = "inline-block"
+        }
+
+    } else {
+        window.performSynthesis()
+    }
+}
+
+window.pauseResumeBatch = () => {
+
+    batch_progressNotes.innerHTML = window.i18n.PAUSED
+
+    const isRunning = window.batch_state.state
+    batch_pauseBtn.innerHTML = isRunning ? window.i18n.RESUME : window.i18n.PAUSE
+    window.batch_state.state = !isRunning
+
+    window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent?window.batch_state.taskBarPercent:1, {mode: isRunning ? "paused" : "normal"})
+
+    if (window.batch_state.state) {
+        window.batch_state.startTime = new Date()
+        window.batch_state.linesDoneSinceStart = 0
+    }
+
+
+    if (!isRunning) {
+        window.performSynthesis()
+    }
+}
+
+window.stopBatch = (stoppedByUser) => {
+    window.electronBrowserWindow.setProgressBar(0)
+    window.batch_state.state = false
+    window.batch_state.lineIndex = 0
+
+    batch_ETA_container.style.opacity = 0
+    batch_synthesizeBtn.style.display = "inline-block"
+    batch_clearBtn.style.display = "inline-block"
+    batch_outputFolderInput.style.display = "inline-block"
+    batch_clearDirOpts.style.display = "flex"
+    batch_skipExistingOpts.style.display = "flex"
+    batch_useSR.style.display = "flex"
+    batch_useCleanup.style.display = "flex"
+    batch_outputNumericallyOpts.style.display = "flex"
+    batch_progressItems.style.display = "none"
+    batch_progressBar.style.display = "none"
+    batch_pauseBtn.style.display = "none"
+    batch_stopBtn.style.display = "none"
+
+    window.batch_state.lines.forEach(record => {
+        if (record[1].children[1].innerHTML==window.i18n.READY || record[1].children[1].innerHTML==window.i18n.RUNNING) {
+            record[1].children[1].innerHTML = window.i18n.STOPPED
+            record[1].children[1].style.background = "none"
+        }
+    })
+
+    const pluginData = {
+        stoppedByUser: stoppedByUser
+    }
+    window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["batch-stop"]["post"], event="post batch-stop", pluginData)
+}
+
+window.adjustETA = () => {
+    if (window.batch_state.state && window.batch_state.fastModeActuallyFinishedTasks>=2) {
+        batch_ETA_container.style.opacity = 1
+
+        // Lines per second
+        const timeNow = new Date()
+        const timeSinceStart = timeNow - window.batch_state.startTime
+        const avgMSTimePerLine = timeSinceStart / window.batch_state.fastModeActuallyFinishedTasks
+        batch_eta_lps.innerHTML = parseInt((1000/avgMSTimePerLine)*100)/100
+
+
+        const remainingLines = window.batch_state.lines.length - window.batch_state.fastModeActuallyFinishedTasks
+        let estTimeRemaining = avgMSTimePerLine*remainingLines
+
+        // Estimated finish time
+        const finishTime = new Date(timeNow.getTime() + estTimeRemaining)
+        let etaFinishTime = `${finishTime.getHours()}:${String(finishTime.getMinutes()).padStart(2, "0")}:${String(finishTime.getSeconds()).padStart(2, "0")}`
+        const days = [window.i18n.SUNDAY, window.i18n.MONDAY, window.i18n.TUESDAY, window.i18n.WEDNESDAY, window.i18n.THURSDAY, window.i18n.FRIDAY, window.i18n.SATURDAY]
+        etaFinishTime = `${days[finishTime.getDay()]} ${etaFinishTime}`
+
+        batch_eta_eta.innerHTML = etaFinishTime
+
+        // Time remaining
+        let etaTimeDisplay = []
+        if (estTimeRemaining > (1000*60*60)) { // hours
+            const hours = parseInt(estTimeRemaining/(1000*60*60))
+            etaTimeDisplay.push(hours+"h")
+            estTimeRemaining -= hours*(1000*60*60)
+        }
+        if (estTimeRemaining > (1000*60)) { // minutes
+            const minutes = parseInt(estTimeRemaining/(1000*60))
+            etaTimeDisplay.push(String(minutes).padStart(2, "0")+"m")
+            estTimeRemaining -= minutes*(1000*60)
+        }
+        if (estTimeRemaining > (1000)) { // seconds
+            const seconds = parseInt(estTimeRemaining/(1000))
+            etaTimeDisplay.push(String(seconds).padStart(2, "0")+"s")
+            estTimeRemaining -= seconds*(1000)
+        }
+        batch_eta_time.innerHTML = etaTimeDisplay.join(" ")
+
+    } else {
+        batch_ETA_container.style.opacity = 0
+    }
+}
+
+
+const openOutput = () => {
+    er.shell.showItemInFolder(window.userSettings.batchOutFolder+"/dummy.txt")
+    spawn(`explorer`, [window.userSettings.batchOutFolder.replace(/\//g, "\\")], {stdio: "ignore"})
+}
+
+
+batch_paginationPrev.addEventListener("click", () => {
+    batch_pageNum.value = Math.max(1, parseInt(batch_pageNum.value)-1)
+    window.batch_state.paginationIndex = batch_pageNum.value-1
+    window.refreshBatchRecordsList()
+})
+batch_paginationNext.addEventListener("click", () => {
+    const numPages = Math.ceil(window.batch_state.lines.length/window.userSettings.batch_paginationSize)
+    batch_pageNum.value = Math.min(parseInt(batch_pageNum.value)+1, numPages)
+    window.batch_state.paginationIndex = batch_pageNum.value-1
+    window.refreshBatchRecordsList()
+})
+batch_pageNum.addEventListener("change", () => {
+    const numPages = Math.ceil(window.batch_state.lines.length/window.userSettings.batch_paginationSize)
+    batch_pageNum.value = Math.max(1, Math.min(parseInt(batch_pageNum.value), numPages))
+    window.batch_state.paginationIndex = batch_pageNum.value-1
+    window.refreshBatchRecordsList()
+})
+setting_batch_paginationSize.addEventListener("change", () => {
+    const numPages = Math.ceil(window.batch_state.lines.length/window.userSettings.batch_paginationSize)
+    batch_pageNum.value = Math.max(1, Math.min(parseInt(batch_pageNum.value), numPages))
+    window.batch_state.paginationIndex = batch_pageNum.value-1
+    batch_total_pages.innerHTML = window.i18n.PAGINATION_TOTAL_OF.replace("_1", numPages)
+
+    window.refreshBatchRecordsList()
+})
+
+window.toggleNumericalRecordsDisplay = () => {
+    window.batch_state.lines.forEach(record => {
+        record[1].children[6].innerHTML = batch_outputNumerically.checked ? `${window.userSettings.batchOutFolder}/${String(record[2]).padStart(10, '0')}` : record[0].out_path
+    })
+}
+batch_outputNumerically.addEventListener("click", () => {
+    window.toggleNumericalRecordsDisplay()
+})
+batch_saveToCSV.addEventListener("click", () => {
+
+    try {
+        const csv_file = [`game_id|voice_id|text`]
+        window.batch_state.lines.forEach(line => {
+            csv_file.push(`${line[0].game_id}|${line[0].voice_id}|${line[0].text}`)
+        })
+
+        const outFileName = JSON.stringify(new Date()).replace("\"","").replaceAll(":","_").split(".")[0]+"_batch.csv"
+
+        fs.writeFileSync(`${window.userSettings.batchOutFolder}/${outFileName}`, csv_file.join("\n"), "utf8")
+
+        window.createModal("error", `${window.i18n.BATCH_TOCSV_DONE}<br><br>${window.userSettings.batchOutFolder}/${outFileName}`)
+
+    } catch(e) {
+        console.log(e)
+        window.appLogger.log(e.stack)
+        window.errorModal(e.stack)
+    }
+
+})
+
+
+batch_main.addEventListener("dragenter", event => window.uploadBatchCSVs("dragenter", event), false)
+batch_main.addEventListener("dragleave", event => window.uploadBatchCSVs("dragleave", event), false)
+batch_main.addEventListener("dragover", event => window.uploadBatchCSVs("dragover", event), false)
+batch_main.addEventListener("drop", event => window.uploadBatchCSVs("drop", event), false)
+
+
+batch_synthesizeBtn.addEventListener("click", window.startBatch)
+batch_pauseBtn.addEventListener("click", window.pauseResumeBatch)
+batch_stopBtn.addEventListener("click", () => window.stopBatch(true))
+batch_openDirBtn.addEventListener("click", openOutput)

javascript/dragdrop_model_install.js

@@ -0,0 +1,180 @@
+"use strict"
+
+window.dragDropModelInstallation = (eType, event) => {
+    if (["dragenter", "dragover"].includes(eType)) {
+        left.style.background = "#5b5b5b"
+        left.style.color = "white"
+    }
+    if (["dragleave", "drop"].includes(eType)) {
+        left.style.background = "rgba(0,0,0,0)"
+        left.style.color = "white"
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+
+    const dataLines = []
+
+    if (eType=="drop") {
+        const dataTransfer = event.dataTransfer
+        const files = Array.from(dataTransfer.files)
+
+        const modelGroups = {} // Group up all files by their base name (for if loose files are given)
+        files.forEach(file => {
+            const baseName = file.name.split(".")[0]
+            if (!modelGroups[baseName]) {
+                modelGroups[baseName] = []
+            }
+            modelGroups[baseName].push(file.path)
+        })
+
+        const modelGroupsComplete = []
+        const modelGroupsNotComplete = []
+        Object.keys(modelGroups).forEach(key => {
+            if (modelGroups[key][0].split(".").at(-1)!="zip") {
+                const fileExtensions = modelGroups[key].map(filePath => filePath.split(".").at(-1))
+                if (fileExtensions.includes("json") && fileExtensions.includes("pt")) {
+                    modelGroupsComplete.push(key)
+                } else {
+                    modelGroupsNotComplete.push(key)
+                }
+            } else {
+                modelGroupsComplete.push(key)
+            }
+        })
+
+        if (modelGroupsNotComplete.length) {
+            return window.errorModal(window.i18n.MODEL_INSTALL_DRAGDROP_INCOMPLETE.replace("_1", modelGroupsNotComplete.join(", ")))
+        }
+
+        const modelsInstalledSuccessfully = []
+        const modelsFailedInstallation = []
+        let lastGameInstalledOkFor = undefined
+
+
+        const handleZip = (files, key) => {
+            return new Promise(resolve => {
+                let installedOk = false
+                let game = undefined
+
+                try {
+                    if (fs.existsSync(`${window.path}/downloads`)) {
+                        fs.readdirSync(`${window.path}/downloads`).forEach(fileName => {
+                            fs.unlinkSync(`${window.path}/downloads/${fileName}`)
+                        })
+                    } else {
+                        fs.mkdirSync(`${window.path}/downloads`)
+                    }
+
+                    window.unzipFileTo(files[0], `${window.path}/downloads`).then(() => {
+                        const allFiles = fs.readdirSync(`${window.path}/downloads`)
+                        const jsonFiles = allFiles.filter(fname => fname.endsWith(".json"))
+
+                        jsonFiles.forEach(jsonFile => {
+                            const jsonData = JSON.parse(fs.readFileSync(`${window.path}/downloads/${jsonFile}`))
+
+                            game = jsonData.games[0].gameId
+                            const voiceId = jsonData.games[0].voiceId
+                            const modelsFolder = window.userSettings[`modelspath_${game}`]
+
+                            const allFilesForThisModel = allFiles.filter(fname => fname.includes(voiceId))
+                            allFilesForThisModel.forEach(fname => {
+                                fs.copyFileSync(`${window.path}/downloads/${fname}`, `${modelsFolder}/${fname}`)
+                            })
+
+                            installedOk = true
+                        })
+
+                        resolve([game, key, installedOk])
+                    })
+
+                } catch (e) {
+                    resolve([game, key, false])
+                }
+            })
+        }
+
+        const handleLoose = (files, key) => {
+            let game = undefined
+            return new Promise(resolve => {
+                try {
+                    const jsonFile = files.find(fname => fname.endsWith(".json"))
+                    const parentFolder = jsonFile.replaceAll("\\", "/").split("/").reverse().slice(1, 100000).reverse().join("/")
+                    // const jsonData = JSON.parse(fs.readFileSync(`${parentFolder}/${jsonFile}`))
+                    const jsonData = JSON.parse(fs.readFileSync(`${jsonFile}`))
+
+                    const game = jsonData.games[0].gameId
+                    const voiceId = jsonData.games[0].voiceId
+                    const modelsFolder = window.userSettings[`modelspath_${game}`]
+
+                    const allFilesForThisModel = fs.readdirSync(parentFolder).filter(fname => fname.includes(voiceId))
+                    allFilesForThisModel.forEach(fname => {
+                        fs.copyFileSync(`${parentFolder}/${fname}`, `${modelsFolder}/${fname}`)
+                        // fs.copyFileSync(`${fname}`, `${modelsFolder}/${fname}`)
+                    })
+
+                    // lastGameInstalledOkFor = game
+                    // modelsInstalledSuccessfully.push(key)
+                    resolve([game, key, true])
+                } catch (e) {
+                    resolve([game, key, false])
+                }
+            })
+        }
+
+        const installPromises = []
+
+        modelGroupsComplete.forEach(key => {
+            try {
+                const files = modelGroups[key]
+                if (files[0].endsWith(".zip")) {
+                    installPromises.push(handleZip(files, key))
+                } else {
+                    installPromises.push(handleLoose(files, key))
+                }
+
+            } catch (e) {
+                console.log(e)
+                window.appLogger.log(e)
+                modelsFailedInstallation.push(key)
+            }
+        })
+
+
+        Promise.all(installPromises).then(responses => {
+
+            responses.forEach(([game, key, installedOk]) => {
+                if (installedOk) {
+                    lastGameInstalledOkFor = game
+                    modelsInstalledSuccessfully.push(key)
+                } else {
+                    modelsFailedInstallation.push(key)
+                }
+            })
+
+            let outputMessage = ""
+
+            if (modelsInstalledSuccessfully.length) {
+                outputMessage += window.i18n.MODEL_INSTALL_DRAGDROP_SUCCESS.replace("_1", modelsInstalledSuccessfully.length)
+            }
+            if (modelsFailedInstallation.length) {
+                outputMessage += window.i18n.MODEL_INSTALL_DRAGDROP_FAILED.replace("_1", modelsFailedInstallation.length).replace("_2", modelsFailedInstallation.join(", "))
+            }
+            window.infoModal(outputMessage)
+
+            if (lastGameInstalledOkFor) {
+                window.changeGame(window.gameAssets[lastGameInstalledOkFor])
+            }
+            window.displayAllModels(true)
+            window.loadAllModels(true).then(() => {
+                changeGame(window.currentGame)
+            })
+        })
+
+
+    }
+}
+left.addEventListener("dragenter", event => window.dragDropModelInstallation("dragenter", event), false)
+left.addEventListener("dragleave", event => window.dragDropModelInstallation("dragleave", event), false)
+left.addEventListener("dragover", event => window.dragDropModelInstallation("dragover", event), false)
+left.addEventListener("drop", event => window.dragDropModelInstallation("drop", event), false)

javascript/editor.js

@@ -0,0 +1,2089 @@
+"use strict"
+
+
+class Editor {
+
+    constructor () {
+
+        this.isCreated = false
+
+        this.hasChanged = false
+        this.autoInferTimer = null
+
+        this.adjustedLetters = new Set()
+
+        this.LEFT_RIGHT_SEQ_PADDING = 20
+        this.EDITOR_HEIGHT = 150
+        this.LETTERS_Y_OFFSET = 40
+        this.SLIDER_GRABBER_H = 15
+        this.MIN_LETTER_LENGTH = 20
+        this.MAX_LETTER_LENGTH = 100
+        this.SPACE_BETWEEN_LETTERS = 5
+
+        this.default_pitchSliderRange = 4
+        this.pitchSliderRange = 4
+        this.duration_visual_size_multiplier = 1
+
+        this.default_MIN_ENERGY = 3.45
+        this.MIN_ENERGY = 3.45
+        this.default_MAX_ENERGY = 4.35
+        this.MAX_ENERGY = 4.35
+        this.ENERGY_GRABBER_RADIUS = 8
+        this.EMOTION_STYLE_GRABBER_RADIUS = 8
+
+        this.MIN_EMOTIONS = 0
+        this.MAX_EMOTIONS = 1.06
+
+        this.MIN_STYLES = 0
+        this.MAX_STYLES = 1.06
+
+        this.clear() // And thus init
+
+        this.registeredStyleKeys = []
+        this.historyState = [] // TODO, add support for undo/redo across all editor functions
+    }
+
+    clear () {
+        this.sliderBoxes = []
+        this.grabbers = [] // Pitch (original single grabber)
+        this.energyGrabbers = []
+        this.emAngryGrabbers = []
+        this.emHappyGrabbers = []
+        this.emSadGrabbers = []
+        this.emSurpriseGrabbers = []
+
+        this.styleGrabbers = {}
+        this.styleValuesNew = {}
+        this.styleValuesReset = {}
+        this.multiLetterStyleDelta = {}
+        this.multiLetterStartStyleVals = {}
+
+        this.letters = []
+        this.pitchNew = []
+        this.dursNew = []
+        this.energyNew = []
+        this.emAngryNew = []
+        this.emHappyNew = []
+        this.emSadNew = []
+        this.emSurpriseNew = []
+        this.pacing = 1
+        this.ampFlatCounter = 0
+
+        this.inputSequence = undefined
+        this.currentVoice = undefined
+        this.letterFocus = []
+        this.lastSelected = 0
+        this.letterClasses = []
+        this.resetDurs = []
+        this.resetPitch = []
+        this.resetEnergy = []
+        this.resetEmAngry = []
+        this.resetEmHappy = []
+        this.resetEmSad = []
+        this.resetEmSurprise = []
+
+        this.multiLetterPitchDelta = undefined
+        this.multiLetterStartPitchVals = []
+        this.multiLetterStartDursVals = []
+        this.multiLetterEnergyDelta = undefined
+        this.multiLetterStartEnergyVals = []
+        this.multiLetterEmotionDelta = undefined
+        this.multiLetterStartEmotionVals = []
+
+        this.multiLetterLengthDelta = undefined
+        this.multiLetterStartLengthVals = []
+    }
+
+    loadStylesData (editorStyles) {
+        this.registeredStyleKeys = []
+        Object.keys(window.appState.currentModelEmbeddings).forEach(styleKey => {
+            if (styleKey=="default") return
+            this.registeredStyleKeys.push(styleKey)
+
+            this.styleGrabbers[styleKey] = []
+            this.styleValuesReset[styleKey] = this.resetPitch.map(v=>0)
+            this.styleValuesNew[styleKey] = (editorStyles&&editorStyles[styleKey]&&editorStyles[styleKey].sliders) ? editorStyles[styleKey].sliders : this.resetPitch.map(v=>0)
+            this.multiLetterStyleDelta[styleKey] = undefined
+            this.multiLetterStartStyleVals[styleKey] = []
+        })
+    }
+
+    init () {
+
+        // Clear away old instance
+        if (this.isCreated) {
+            editorContainer.innerHTML = ""
+            delete this.canvas
+            delete this.context
+        }
+
+        let canvasWidth = 0
+        if (this.sliderBoxes.length) {
+            canvasWidth = this.sliderBoxes.at(-1).getX() + this.SPACE_BETWEEN_LETTERS * 2 + 100
+        } else {
+            canvasWidth = this.LEFT_RIGHT_SEQ_PADDING*2 // Padding
+            this.dursNew.forEach((dur,di) => {
+                if (di) {
+                    canvasWidth += this.SPACE_BETWEEN_LETTERS
+                }
+
+                let value = dur
+                value = value * this.pacing
+                value = Math.max(0.1, value)
+                value = Math.min(value, 20)
+                const percentAcross = value/20
+                const width = percentAcross * (this.MAX_LETTER_LENGTH-this.MIN_LETTER_LENGTH) + this.MIN_LETTER_LENGTH
+                canvasWidth += width
+            })
+        }
+
+        this.canvas = document.createElement("canvas")
+        this.context = this.canvas.getContext("2d")
+        this.context.textAlign  = "center"
+        this.canvas.width = canvasWidth
+        this.canvas.height = 200
+
+        editorContainer.appendChild(this.canvas)
+
+
+        // Mouse cursor
+        this.canvas.addEventListener("mousemove", event => {
+            const mouseX = parseInt(event.offsetX)
+            const mouseY = parseInt(event.offsetY)
+            this.canvas.style.cursor = "default"
+
+            // Check energy grabber hover
+            const isOnEGrabber = seq_edit_view_select.value.includes("energy") && this.energyGrabbers.find((eGrabber, egi) => {
+                if (!this.enabled_disabled_items[egi]) return
+                const grabberX = eGrabber.getXLeft()+eGrabber.sliderBox.width/2-this.ENERGY_GRABBER_RADIUS
+                return (mouseX>grabberX && mouseX<grabberX+this.ENERGY_GRABBER_RADIUS*2+4) && (mouseY>eGrabber.topLeftY-this.ENERGY_GRABBER_RADIUS-2 && mouseY<eGrabber.topLeftY+this.ENERGY_GRABBER_RADIUS+2)
+            })
+            if (isOnEGrabber && isOnEGrabber!=undefined) {
+                this.canvas.style.cursor = "row-resize"
+                return
+            }
+
+            // One grabber type
+            if (seq_edit_view_select.value !== "pitch_energy") {
+                this.sliderBoxes.forEach((sbox, sboxi) => {
+                    if (!this.enabled_disabled_items[sboxi]) return;
+
+                    // is outside slider box => return
+                    if (!(
+                        mouseX>sbox.getXLeft()
+                        && mouseX<sbox.getXLeft() + sbox.width
+                    )) {
+                        return;
+                    }
+
+                    this.canvas.style.cursor = "row-resize"
+                })
+            }
+
+            // Check emotion grabber hover
+            const isHoveringOverEmotionGrabber = emotionGrabbers => {
+                return emotionGrabbers.find((eGrabber, egi) => {
+                    if (!this.enabled_disabled_items[egi]) return
+                    const grabberX = eGrabber.getXLeft()+eGrabber.sliderBox.width/2-this.EMOTION_STYLE_GRABBER_RADIUS
+                    return (mouseX>grabberX && mouseX<grabberX+this.EMOTION_STYLE_GRABBER_RADIUS*2+4) && (mouseY>eGrabber.topLeftY-this.EMOTION_STYLE_GRABBER_RADIUS-2 && mouseY<eGrabber.topLeftY+this.EMOTION_STYLE_GRABBER_RADIUS+2)
+                })
+            }
+            if (window.currentModel.modelType=="xVAPitch") {
+                const isOnEmGrabber = seq_edit_view_select.value.startsWith("em") && (isHoveringOverEmotionGrabber(this.emAngryGrabbers) || isHoveringOverEmotionGrabber(this.emHappyGrabbers) || isHoveringOverEmotionGrabber(this.emSadGrabbers) || isHoveringOverEmotionGrabber(this.emSurpriseGrabbers))
+                if (isOnEmGrabber && isOnEmGrabber!=undefined) {
+                    this.canvas.style.cursor = "row-resize"
+                    return
+                }
+            }
+            // Check pitch grabber hover
+            const isOnGrabber = seq_edit_view_select.value.includes("pitch") && this.grabbers.find((grabber, gi) => {
+                if (!this.enabled_disabled_items[gi]) return
+                const grabberX = grabber.getXLeft()
+                return (mouseX>grabberX && mouseX<grabberX+grabber.width) && (mouseY>grabber.topLeftY && mouseY<grabber.topLeftY+grabber.height)
+            })
+            if (isOnGrabber && isOnGrabber!=undefined) {
+                this.canvas.style.cursor = "n-resize"
+                return
+            }
+
+            // Check styles grabbers
+            if (this.registeredStyleKeys && this.registeredStyleKeys.length) {
+                let isOnStyleGrabber
+                this.registeredStyleKeys.forEach(styleKey => {
+                    if (isOnStyleGrabber) return // Skip unnecessary work if already found
+                    if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+                        isOnStyleGrabber = this.styleGrabbers[styleKey].find((grabber, gi) => {
+                            if (!this.enabled_disabled_items[gi]) return
+                            const grabberX = grabber.getXLeft()
+                            return (mouseX>grabberX && mouseX<grabberX+grabber.width) && (mouseY>grabber.topLeftY && mouseY<grabber.topLeftY+grabber.height)
+                        })
+                        if (isOnStyleGrabber) {
+                            this.canvas.style.cursor = "row-resize"
+                            return
+                        }
+                    }
+                })
+            }
+
+            // Check letter hover
+            const isOnLetter = this.letterClasses.find((letter, l) => {
+                if (!this.enabled_disabled_items[l]) return
+                return (mouseY<this.LETTERS_Y_OFFSET) && (mouseX>this.sliderBoxes[l].getXLeft() && mouseX<this.sliderBoxes[l].getXLeft()+this.sliderBoxes[l].width)
+            })
+            if (isOnLetter!=undefined) {
+                this.canvas.style.cursor = "pointer"
+                return
+            }
+            // Check box length dragger
+            const isBetweenBoxes = this.sliderBoxes.find((box, bi) => {
+                if (!this.enabled_disabled_items[bi]) return
+                const boxX = box.getXLeft()
+                return (mouseY>box.topY && mouseY<box.topY+box.height) && (mouseX>(boxX+box.width-10) && mouseX<(boxX+box.width+10)+5)
+            })
+            if (isBetweenBoxes!=undefined) {
+                this.canvas.style.cursor = "w-resize"
+                return
+            }
+        })
+
+        let elemDragged = undefined
+        let mouseDownStart = {x: undefined, y: undefined}
+        this.canvas.addEventListener("mousedown", event => {
+            const mouseX = parseInt(event.offsetX)
+            const mouseY = parseInt(event.offsetY)
+            mouseDownStart.x = mouseX
+            mouseDownStart.y = mouseY
+
+            // Check up-down pitch dragging box first
+            const isOnGrabber = seq_edit_view_select.value.includes("pitch") && this.grabbers.find((grabber, gi) => {
+                if (!this.enabled_disabled_items[gi]) return
+                const grabberX = grabber.getXLeft()
+                return (mouseX>grabberX && mouseX<grabberX+grabber.width) && (mouseY>grabber.topLeftY && mouseY<grabber.topLeftY+grabber.height)
+            })
+            if (isOnGrabber) {
+
+                const slider = isOnGrabber
+                if (this.letterFocus.length <= 1 || (!this.letterFocus.includes(slider.index))) {
+                    this.setLetterFocus(this.grabbers.indexOf(slider), event.ctrlKey, event.shiftKey, event.altKey)
+                }
+                this.multiLetterPitchDelta = slider.topLeftY
+                this.multiLetterStartPitchVals = this.grabbers.map(slider => slider.topLeftY)
+
+                elemDragged = isOnGrabber
+                return
+            }
+
+            // Check sideways dragging
+            const isBetweenBoxes = this.sliderBoxes.find((box, bi) => {
+                if (!this.enabled_disabled_items[bi]) return
+                const boxX = box.getXLeft()
+                return (mouseY>box.topY && mouseY<box.topY+box.height) && (mouseX>(boxX+box.width-10) && mouseX<(boxX+box.width+10)+5)
+            })
+            if (isBetweenBoxes) {
+                this.multiLetterStartDursVals = this.sliderBoxes.map(box => box.width)
+
+                isBetweenBoxes.dragStart.width = isBetweenBoxes.width
+                elemDragged = isBetweenBoxes
+                return
+            }
+
+            // Check up-down emotion dragging
+            const findGrabber = emotionGrabbers => {
+                return emotionGrabbers.find((eGrabber, egi) => {
+                    if (!this.enabled_disabled_items[egi]) return
+                    const boxX = eGrabber.sliderBox.getXLeft()
+                    return (
+                        (mouseX > boxX)
+                        && (mouseX < (boxX + eGrabber.sliderBox.width))
+                    )
+                })
+            }
+            const handleEmGrabber = (emGrabber, grabbersList) => {
+                if (this.letterFocus.length <= 1 || (!this.letterFocus.includes(emGrabber.index))) {
+                    this.setLetterFocus(grabbersList.indexOf(emGrabber), event.ctrlKey, event.shiftKey, event.altKey)
+                }
+                this.multiLetterEmotionDelta = emGrabber.topLeftY
+                this.multiLetterStartEmotionVals = grabbersList.map(emGrabber => emGrabber.topLeftY)
+
+                return emGrabber
+            }
+            const handleStyleGrabber = (styleGrabber, grabbersList, styleKey) => {
+                if (this.letterFocus.length <= 1 || (!this.letterFocus.includes(styleGrabber.index))) {
+                    this.setLetterFocus(grabbersList.indexOf(styleGrabber), event.ctrlKey, event.shiftKey, event.altKey)
+                }
+                this.multiLetterStyleDelta[styleKey] = styleGrabber.topLeftY
+                this.multiLetterStartStyleVals[styleKey] = grabbersList.map(styleGrabber => styleGrabber.topLeftY)
+                return styleGrabber
+            }
+
+            // Check up-down energy dragging
+            const isOnEGrabber = seq_edit_view_select.value.includes("energy") && this.energyGrabbers.find((eGrabber, egi) => {
+                if (!this.enabled_disabled_items[egi]) return
+                const grabberX = eGrabber.getXLeft()+eGrabber.sliderBox.width/2-this.ENERGY_GRABBER_RADIUS
+                return (mouseX>grabberX && mouseX<grabberX+this.ENERGY_GRABBER_RADIUS*2+4) && (mouseY>eGrabber.topLeftY-this.ENERGY_GRABBER_RADIUS-2 && mouseY<eGrabber.topLeftY+this.ENERGY_GRABBER_RADIUS+2)
+            })
+            if (isOnEGrabber) {
+
+                const eGrabber = isOnEGrabber
+                if (this.letterFocus.length <= 1 || (!this.letterFocus.includes(eGrabber.index))) {
+                    this.setLetterFocus(this.energyGrabbers.indexOf(eGrabber), event.ctrlKey, event.shiftKey, event.altKey)
+                }
+                this.multiLetterEnergyDelta = eGrabber.topLeftY
+                this.multiLetterStartEnergyVals = this.energyGrabbers.map(eGrabber => eGrabber.topLeftY)
+
+                elemDragged = isOnEGrabber
+                return
+            }
+
+            // Check clicking on the top letters
+            const isOnLetter = this.letterClasses.find((letter, l) => {
+                if (!this.enabled_disabled_items[l]) return
+                return (mouseY<this.LETTERS_Y_OFFSET) && (mouseX>this.sliderBoxes[l].getXLeft() && mouseX<this.sliderBoxes[l].getXLeft()+this.sliderBoxes[l].width)
+            })
+
+            if (isOnLetter) {
+                this.setLetterFocus(this.letterClasses.indexOf(isOnLetter), event.ctrlKey, event.shiftKey, event.altKey)
+                return;
+            }
+
+            // Not on letter
+
+            // Drag grabber when only single type of grabber
+            if (seq_edit_view_select.value === "pitch_energy")
+            {
+                return;
+            }
+            // Fetch any grabber within letter column
+            const isOnGrabberCol = seq_edit_view_select.value=="pitch" && findGrabber(this.grabbers)
+            if (isOnGrabberCol) {
+                const slider = isOnGrabberCol
+                this.multiLetterPitchDelta = slider.topLeftY
+                this.multiLetterStartPitchVals = this.grabbers.map(slider => slider.topLeftY)
+
+                elemDragged = isOnGrabberCol
+                return
+            }
+            const isOnEGrabberCol = seq_edit_view_select.value=="energy" && findGrabber(this.energyGrabbers)
+            if (isOnEGrabberCol) {
+                this.multiLetterEnergyDelta = isOnEGrabberCol.topLeftY
+                this.multiLetterStartEnergyVals = this.energyGrabbers.map(isOnEGrabberCol => isOnEGrabberCol.topLeftY)
+
+                elemDragged = isOnEGrabberCol
+                return
+            }
+
+            if (window.currentModel.modelType !== "xVAPitch") {
+                return
+            }
+
+            // v3 model
+            if (seq_edit_view_select.value.startsWith("style_") && this.registeredStyleKeys.length) {
+                this.registeredStyleKeys.forEach(styleKey => {
+                    if (seq_edit_view_select.value.includes(styleKey)) {
+                        const isOnStyleGrabber = findGrabber(this.styleGrabbers[styleKey])
+                        if (isOnStyleGrabber) {
+                            elemDragged = handleStyleGrabber(isOnStyleGrabber, this.styleGrabbers[styleKey], styleKey)
+                            return
+                        }
+                    }
+                })
+            }
+
+            const isOnEmAngryGrabber = seq_edit_view_select.value=="emAngry" && findGrabber(this.emAngryGrabbers)
+            if (isOnEmAngryGrabber) {
+                elemDragged = handleEmGrabber(isOnEmAngryGrabber, this.emAngryGrabbers)
+                return
+            }
+            const isOnEmHappyGrabber = seq_edit_view_select.value=="emHappy" && findGrabber(this.emHappyGrabbers)
+            if (isOnEmHappyGrabber) {
+                elemDragged = handleEmGrabber(isOnEmHappyGrabber, this.emHappyGrabbers)
+                return
+            }
+            const isOnEmSadGrabber = seq_edit_view_select.value=="emSad" && findGrabber(this.emSadGrabbers)
+            if (isOnEmSadGrabber) {
+                elemDragged = handleEmGrabber(isOnEmSadGrabber, this.emSadGrabbers)
+                return
+            }
+            const isOnEmSurpriseGrabber = seq_edit_view_select.value=="emSurprise" && findGrabber(this.emSurpriseGrabbers)
+            if (isOnEmSurpriseGrabber) {
+                elemDragged = handleEmGrabber(isOnEmSurpriseGrabber, this.emSurpriseGrabbers)
+                return
+            }
+        })
+
+        this.canvas.addEventListener("mouseup", event => {
+            mouseDownStart = {x: undefined, y: undefined}
+            if (autoplay_ckbx.checked && this.hasChanged) {
+                generateVoiceButton.click()
+            }
+            this.init()
+        })
+
+        this.canvas.addEventListener("mousemove", event => {
+            if (mouseDownStart.x && mouseDownStart.y) {
+
+                if (elemDragged && (parseInt(event.offsetX)-mouseDownStart.x || parseInt(event.offsetY)-mouseDownStart.y)) {
+                    this.hasChanged = true
+                    this.letterFocus.forEach(index => this.adjustedLetters.add(index))
+                }
+
+                if (elemDragged) {
+                    if (elemDragged.type=="slider") { // Pitch sliders, specifically
+
+                        elemDragged.setValueFromCoords(parseInt(event.offsetY)-elemDragged.height/2)
+
+                        // If there's a multi-selection, update all of their values, otherwise update the numerical input
+                        if (this.letterFocus.length>1) {
+                            this.letterFocus.forEach(li => {
+                                if (li!=elemDragged.index) {
+                                    this.grabbers[li].setValueFromCoords(this.multiLetterStartPitchVals[li]+(elemDragged.topLeftY-this.multiLetterPitchDelta))
+                                }
+                            })
+                        } else {
+                            letterPitchNumb.value = parseInt(this.pitchNew[elemDragged.index]*100)/100
+                        }
+
+
+                    } else if (elemDragged.type=="box") { // Durations being dragged sideways
+
+                        // If there's a multi-selection, update all of their values, otherwise update the numerical input
+                        if (this.letterFocus.length>1) {
+                            this.letterFocus.forEach(li => {
+                                let newWidth = this.multiLetterStartDursVals[li] + parseInt(elemDragged.width - elemDragged.dragStart.width)
+                                newWidth = Math.max(20, newWidth)
+                                newWidth = Math.min(newWidth, this.MAX_LETTER_LENGTH)
+
+                                this.sliderBoxes[li].width = newWidth
+
+                                this.sliderBoxes[li].percentAcross = (this.sliderBoxes[li].width-20) / (this.MAX_LETTER_LENGTH-20)
+                                this.dursNew[this.sliderBoxes[li].index] = Math.max(0.1, this.sliderBoxes[li].percentAcross*20)
+
+                                this.sliderBoxes[li].grabber.width = this.sliderBoxes[li].width-2
+                                this.sliderBoxes[li].letter.centerX = this.sliderBoxes[li].leftX + this.sliderBoxes[li].width/2
+                            })
+                        } else {
+
+                            letterLengthNumb.value = parseInt(this.dursNew[elemDragged.index]*100)/100
+                        }
+
+
+                        let newWidth = elemDragged.dragStart.width + parseInt(event.offsetX)-mouseDownStart.x
+                        newWidth = Math.max(20, newWidth)
+                        newWidth = Math.min(newWidth, this.MAX_LETTER_LENGTH)
+                        elemDragged.width = newWidth
+
+                        elemDragged.percentAcross = (elemDragged.width-20) / (this.MAX_LETTER_LENGTH-20)
+                        this.dursNew[elemDragged.index] = Math.max(0.1, elemDragged.percentAcross*20)
+
+                        elemDragged.grabber.width = elemDragged.width-2
+                        elemDragged.letter.centerX = elemDragged.leftX + elemDragged.width/2
+
+                    } else if (elemDragged.type=="energy_slider") { // Energy sliders
+
+                        elemDragged.setValueFromCoords(parseInt(event.offsetY)-elemDragged.height/2)
+
+                        // If there's a multi-selection, update all of their values, otherwise update the numerical input
+                        if (this.letterFocus.length>1) {
+                            this.letterFocus.forEach(li => {
+                                if (li!=elemDragged.index) {
+                                    this.energyGrabbers[li].setValueFromCoords(this.multiLetterStartEnergyVals[li]+(elemDragged.topLeftY-this.multiLetterEnergyDelta))
+                                }
+                            })
+                        } else {
+                            letterEnergyNumb.value = parseInt(this.energyNew[elemDragged.index]*100)/100
+                        }
+
+                    } else if (elemDragged.type=="emotion_slider") { // Emotion sliders
+
+                        elemDragged.setValueFromCoords(parseInt(event.offsetY)-elemDragged.height/2)
+
+                        // If there's a multi-selection, update all of their values, otherwise update the numerical input
+                        if (this.letterFocus.length>1) {
+                            this.letterFocus.forEach(li => {
+                                if (li!=elemDragged.index) {
+                                    if (seq_edit_view_select.value=="emAngry") {
+                                        this.emAngryGrabbers[li].setValueFromCoords(this.multiLetterStartEmotionVals[li]+(elemDragged.topLeftY-this.multiLetterEmotionDelta))
+                                    } else if (seq_edit_view_select.value=="emHappy") {
+                                        this.emHappyGrabbers[li].setValueFromCoords(this.multiLetterStartEmotionVals[li]+(elemDragged.topLeftY-this.multiLetterEmotionDelta))
+                                    } else if (seq_edit_view_select.value=="emSad") {
+                                        this.emSadGrabbers[li].setValueFromCoords(this.multiLetterStartEmotionVals[li]+(elemDragged.topLeftY-this.multiLetterEmotionDelta))
+                                    } else if (seq_edit_view_select.value=="emSurprise") {
+                                        this.emSurpriseGrabbers[li].setValueFromCoords(this.multiLetterStartEmotionVals[li]+(elemDragged.topLeftY-this.multiLetterEmotionDelta))
+                                    }
+                                }
+                            })
+                        } else {
+                            if (seq_edit_view_select.value=="emAngry") {
+                                letterEmotionNumb.value = parseFloat(this.emAngryNew[elemDragged.index]*100)/100
+                            } else if (seq_edit_view_select.value=="emHappy") {
+                                letterEmotionNumb.value = parseFloat(this.emHappyNew[elemDragged.index]*100)/100
+                            } else if (seq_edit_view_select.value=="emSad") {
+                                letterEmotionNumb.value = parseFloat(this.emSadNew[elemDragged.index]*100)/100
+                            } else if (seq_edit_view_select.value=="emSurprise") {
+                                letterEmotionNumb.value = parseFloat(this.emSurpriseNew[elemDragged.index]*100)/100
+                            }
+                        }
+                    } else if (elemDragged.type=="style_slider") { // Style sliders
+
+                        elemDragged.setValueFromCoords(parseInt(event.offsetY)-elemDragged.height/2)
+
+                        if (this.registeredStyleKeys.length) {
+                            this.registeredStyleKeys.forEach(styleKey => {
+                                if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+                                    // If there's a multi-selection, update all of their values, otherwise update the numerical input
+                                    if (this.letterFocus.length>1) {
+                                        this.letterFocus.forEach(li => {
+                                            if (li!=elemDragged.index) {
+                                                this.styleGrabbers[styleKey][li].setValueFromCoords(this.multiLetterStartStyleVals[styleKey][li]+(elemDragged.topLeftY-this.multiLetterStyleDelta[styleKey]))
+                                            }
+                                        })
+                                    } else {
+                                        letterStyleNumb.value = parseInt(this.styleValuesNew[styleKey][elemDragged.index]*100)/100
+                                    }
+                                }
+                            })
+                        }
+                    }
+                }
+            }
+        })
+
+        if (!this.isCreated) {
+            this.render()
+        }
+        this.isCreated = true
+    }
+
+
+
+
+    render () {
+        if (this.context!=undefined) {
+            this.context.clearRect(0, 0, this.canvas.width, this.canvas.height)
+            this.letterClasses.forEach((letter, li) => {
+                if (this.letters[li]=="<PAD>") return
+                letter.context = this.context
+                letter.render()
+            })
+            this.sliderBoxes.forEach((sliderBox, sbi) => {
+                if (this.letters[sbi]=="<PAD>") return
+                sliderBox.context = this.context
+                sliderBox.render()
+            })
+            if (seq_edit_view_select.value=="pitch_energy" || seq_edit_view_select.value=="pitch") {
+                this.grabbers.forEach((grabber,gi) => {
+                    if (this.letters[gi]=="<PAD>") return
+                    grabber.context = this.context
+                    grabber.render()
+                })
+            }
+            if (seq_edit_view_select.value=="pitch_energy" || seq_edit_view_select.value=="energy") {
+                this.energyGrabbers.forEach((eGrabber, egi) => {
+                    if (this.letters[egi]=="<PAD>") return
+                    eGrabber.context = this.context
+                    eGrabber.render()
+                })
+            }
+            if (window.currentModel.modelType=="xVAPitch") {
+                if (seq_edit_view_select.value=="emAngry") {
+                    this.emAngryGrabbers.forEach((eGrabber, egi) => {
+                        if (this.letters[egi]=="<PAD>") return
+                        eGrabber.context = this.context
+                        eGrabber.render()
+                    })
+                }
+                if (seq_edit_view_select.value=="emHappy") {
+                    this.emHappyGrabbers.forEach((eGrabber, egi) => {
+                        if (this.letters[egi]=="<PAD>") return
+                        eGrabber.context = this.context
+                        eGrabber.render()
+                    })
+                }
+                if (seq_edit_view_select.value=="emSad") {
+                    this.emSadGrabbers.forEach((eGrabber, egi) => {
+                        if (this.letters[egi]=="<PAD>") return
+                        eGrabber.context = this.context
+                        eGrabber.render()
+                    })
+                }
+                if (seq_edit_view_select.value=="emSurprise") {
+                    this.emSurpriseGrabbers.forEach((eGrabber, egi) => {
+                        if (this.letters[egi]=="<PAD>") return
+                        eGrabber.context = this.context
+                        eGrabber.render()
+                    })
+                }
+                if (this.registeredStyleKeys && this.registeredStyleKeys.length) {
+                    this.registeredStyleKeys.forEach(styleKey => {
+                        if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+                            this.styleGrabbers[styleKey].forEach((styleGrabber, sgi) => {
+                                if (this.letters[sgi]=="<PAD>") return
+                                styleGrabber.context = this.context
+                                styleGrabber.render()
+                            })
+                        }
+                    })
+                }
+            }
+        }
+        requestAnimationFrame(() => {this.render()})
+    }
+
+
+
+
+    update (modelType=undefined, sliderRange=undefined) {
+
+        self.modelType = modelType
+
+        // Make model-specific adjustments
+        if (modelType=="xVAPitch") {
+            this.default_pitchSliderRange = 6
+            this.pitchSliderRange = sliderRange || 6
+            this.duration_visual_size_multiplier = 1
+            this.MAX_LETTER_LENGTH = 200
+            this.default_MIN_ENERGY = 0
+            this.MIN_ENERGY = 0
+            this.default_MAX_ENERGY = 1.07
+            this.MAX_ENERGY = 1.07
+
+            this.styleGrabbers = {}
+            this.registeredStyleKeys.forEach(styleKey => {
+                this.styleGrabbers[styleKey] = []
+            })
+
+        } else {
+            this.default_pitchSliderRange = 4
+            this.pitchSliderRange = sliderRange || 4
+            this.duration_visual_size_multiplier = 1
+            this.MAX_LETTER_LENGTH = 100
+        }
+
+        this.letterClasses = []
+        this.sliderBoxes = []
+        this.grabbers = []
+        this.energyGrabbers = []
+        this.emAngryGrabbers = []
+        this.emHappyGrabbers = []
+        this.emSadGrabbers = []
+        this.emSurpriseGrabbers = []
+
+        this.enabled_disabled_items = []
+
+        let xCounter = 0
+        let lastBox = undefined
+        let letter_counter = 0
+        this.letters.forEach((letter, li) => {
+
+            if (letter=="<PAD>") {
+                this.enabled_disabled_items.push(false)
+                letter_counter += 1
+            } else {
+                this.enabled_disabled_items.push(true)
+            }
+            letter_counter += 1
+
+            const dur = this.dursNew[li]
+            const width = Math.max(25, dur*10)
+
+
+            // Slider box
+            const sliderBox = new SliderBox(this.context, li, lastBox, this.LETTERS_Y_OFFSET, this.EDITOR_HEIGHT, this.MIN_LETTER_LENGTH, this.MAX_LETTER_LENGTH, letter_counter%2==0)
+            sliderBox.render()
+            if (lastBox) {
+                lastBox.rightBox = sliderBox
+            }
+            lastBox = sliderBox
+            this.sliderBoxes.push(sliderBox)
+
+            // Letter text
+            const letterClass = new Letter(this.context, li, letter, sliderBox, 20, 20+xCounter, width)
+            if (this.letterFocus.includes(li)) {
+                letterClass.colour = "red"
+            }
+            letterClass.render()
+            this.letterClasses.push(letterClass)
+
+            // Slider grabber thing
+            const pitchPercent = 1-(this.pitchNew[li]+this.pitchSliderRange)/(this.pitchSliderRange*2)
+            const grabber = new SliderGrabber(this.context, li, sliderBox, (this.LETTERS_Y_OFFSET+1)+(this.SLIDER_GRABBER_H/2)+((this.EDITOR_HEIGHT-2)-this.SLIDER_GRABBER_H)*pitchPercent-this.SLIDER_GRABBER_H/2, width-2, this.SLIDER_GRABBER_H, this.pitchSliderRange)
+            grabber.render()
+            this.grabbers.push(grabber)
+
+            if (this.energyNew && this.energyNew.length) {
+                // Energy round grabber
+                let energyPercent
+                if (modelType=="xVAPitch") {
+                    energyPercent = ( (this.energyNew[li]-this.MIN_ENERGY) / (this.MAX_ENERGY-this.MIN_ENERGY)  )
+                } else {
+                    energyPercent = 1 - ( (this.energyNew[li]-this.MIN_ENERGY) / (this.MAX_ENERGY-this.MIN_ENERGY)  )
+                }
+                energyPercent = Math.max(0, energyPercent)
+                energyPercent = Math.min(energyPercent, 1)
+
+                let topLeftY = (1 - energyPercent) * (this.EDITOR_HEIGHT-2-this.ENERGY_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                const energyGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.ENERGY_GRABBER_RADIUS, undefined, modelType, this.ENERGY_GRABBER_RADIUS, "energy")
+                energyGrabber.render()
+                this.energyGrabbers.push(energyGrabber)
+            }
+
+            if (modelType=="xVAPitch") {
+                if (this.emAngryNew && this.emAngryNew.length) {
+                    let emotionPercent = ( (this.emAngryNew[li]-this.MIN_EMOTIONS) / (this.MAX_EMOTIONS-this.MIN_EMOTIONS)  )
+                    emotionPercent = Math.max(0, emotionPercent)
+                    emotionPercent = Math.min(emotionPercent, 1)
+
+                    let topLeftY = (1 - emotionPercent) * (this.EDITOR_HEIGHT-2-this.EMOTION_STYLE_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                    const emAngryGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.EMOTION_STYLE_GRABBER_RADIUS, undefined, modelType, this.EMOTION_STYLE_GRABBER_RADIUS, "emotion")
+                    emAngryGrabber.render()
+                    this.emAngryGrabbers.push(emAngryGrabber)
+                }
+                if (this.emHappyNew && this.emHappyNew.length) {
+                    let emotionPercent = ( (this.emHappyNew[li]-this.MIN_EMOTIONS) / (this.MAX_EMOTIONS-this.MIN_EMOTIONS)  )
+                    emotionPercent = Math.max(0, emotionPercent)
+                    emotionPercent = Math.min(emotionPercent, 1)
+
+                    let topLeftY = (1 - emotionPercent) * (this.EDITOR_HEIGHT-2-this.EMOTION_STYLE_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                    const emHappyGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.EMOTION_STYLE_GRABBER_RADIUS, undefined, modelType, this.EMOTION_STYLE_GRABBER_RADIUS, "emotion")
+                    emHappyGrabber.render()
+                    this.emHappyGrabbers.push(emHappyGrabber)
+                }
+                if (this.emSadNew && this.emSadNew.length) {
+                    let emotionPercent = ( (this.emSadNew[li]-this.MIN_EMOTIONS) / (this.MAX_EMOTIONS-this.MIN_EMOTIONS)  )
+                    emotionPercent = Math.max(0, emotionPercent)
+                    emotionPercent = Math.min(emotionPercent, 1)
+
+                    let topLeftY = (1 - emotionPercent) * (this.EDITOR_HEIGHT-2-this.EMOTION_STYLE_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                    const emSadGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.EMOTION_STYLE_GRABBER_RADIUS, undefined, modelType, this.EMOTION_STYLE_GRABBER_RADIUS, "emotion")
+                    emSadGrabber.render()
+                    this.emSadGrabbers.push(emSadGrabber)
+                }
+                if (this.emSurpriseNew && this.emSurpriseNew.length) {
+                    let emotionPercent = ( (this.emSurpriseNew[li]-this.MIN_EMOTIONS) / (this.MAX_EMOTIONS-this.MIN_EMOTIONS)  )
+                    emotionPercent = Math.max(0, emotionPercent)
+                    emotionPercent = Math.min(emotionPercent, 1)
+
+                    let topLeftY = (1 - emotionPercent) * (this.EDITOR_HEIGHT-2-this.EMOTION_STYLE_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                    const emSurpriseGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.EMOTION_STYLE_GRABBER_RADIUS, undefined, modelType, this.EMOTION_STYLE_GRABBER_RADIUS, "emotion")
+                    emSurpriseGrabber.render()
+                    this.emSurpriseGrabbers.push(emSurpriseGrabber)
+                }
+
+                // Initialize grabbers dynamically for every style
+                this.registeredStyleKeys.forEach(styleKey => {
+                    let stylePercent = ( (this.styleValuesNew[styleKey][li]-this.MIN_STYLES) / (this.MAX_STYLES-this.MIN_STYLES)  )
+                    stylePercent = Math.max(0, stylePercent)
+                    stylePercent = Math.min(stylePercent, 1)
+
+                    let topLeftY = (1 - stylePercent) * (this.EDITOR_HEIGHT-2-this.EMOTION_STYLE_GRABBER_RADIUS) + (this.LETTERS_Y_OFFSET)
+                    const styleGrabber = new EnergyEmotionGrabber(this.context, li, sliderBox, topLeftY, width-2, this.EMOTION_STYLE_GRABBER_RADIUS, undefined, modelType, this.EMOTION_STYLE_GRABBER_RADIUS, "style")
+                    styleGrabber.render()
+                    this.styleGrabbers[styleKey].push(styleGrabber)
+                })
+            }
+
+            sliderBox.letter = letterClass
+            sliderBox.grabber = grabber
+
+            sliderBox.setValueFromValue(dur)
+
+            xCounter += width + 5
+
+        })
+
+        this.canvas.width = this.sliderBoxes.at(-1).getX() + this.SPACE_BETWEEN_LETTERS * 2 + 100
+    }
+
+    setLetterFocus (l, ctrlKey, shiftKey, altKey) {
+
+        // NONE = Clear selection, add l to selection
+        // Ctrl = Add l to existing selection
+        // Shift = Add all letters from the last selected letter up to and including l to existing selection
+        // Ctrl + Shift = (See Shift)
+        // Alt = Clear selection and select word surrounding l (space delimited)
+        // Ctrl + Alt = Add word surrounding l to existing selection
+        // Shift + Alt = Same as shift, then afterwards add word (space delimited) around l to selection
+        // Ctrl + Shift + Alt = (See Shift + Alt)
+
+        // If nothing is selected and we hold shift, we assume we start from the first letter: at position 0
+
+        // If we don't press shift or ctrl, we can clear our current selection.
+        if (!(ctrlKey || shiftKey) && this.letterFocus.length){
+                this.letterFocus.forEach(li => {
+                    this.letterClasses[li].colour = "black"
+                })
+                this.letterFocus = []
+                this.lastSelected = 0
+        }
+        if (shiftKey){
+            if (l>this.lastSelected) {
+                for (let i=this.lastSelected; i<=l; i++) {
+                    this.letterFocus.push(i)
+                }
+            } else {
+                for (let i=l; i<=this.lastSelected; i++) {
+                    this.letterFocus.push(i)
+                }
+            }
+        }
+        this.letterFocus.push(l) // Push l
+        this.lastSelected = l
+        if (altKey){
+            let l2 = l
+                // Looking backwards
+                while (l2>=0) {
+                    let prevLetter = this.letters[l2]
+                    if (prevLetter!="_") {
+                        this.letterFocus.push(l2)
+                    } else {
+                        break
+                    }
+                    l2--
+                }
+            l2 = l
+            // Looking forward
+            while (l2<this.letters.length) {
+                let nextLetter = this.letters[l2]
+                if (nextLetter!="_") {
+                    this.letterFocus.push(l2)
+                } else {
+                    break
+                }
+                l2++
+            }
+        }
+
+        this.letterFocus = Array.from(new Set(this.letterFocus.sort()))
+        this.letterFocus.forEach(li => {
+            this.letterClasses[li].colour = "red"
+        })
+
+
+        letterStyleNumb.value = ""
+        letterStyleNumb.disabled = true
+        if (this.letterFocus.length==1) {
+            if (this.energyNew.length) {
+                letterEnergyNumb.value = parseFloat(this.energyNew[this.letterFocus[0]])
+                letterEnergyNumb.disabled = false
+            }
+            if (this.emAngryNew && this.emAngryNew.length) {
+                letterEmotionNumb.value = parseFloat(this.emAngryNew[this.letterFocus[0]])
+                letterEmotionNumb.disabled = false
+            }
+            if (this.emHappyNew && this.emHappyNew.length) {
+                letterEmotionNumb.value = parseFloat(this.emHappyNew[this.letterFocus[0]])
+                letterEmotionNumb.disabled = false
+            }
+            if (this.emSadNew && this.emSadNew.length) {
+                letterEmotionNumb.value = parseFloat(this.emSadNew[this.letterFocus[0]])
+                letterEmotionNumb.disabled = false
+            }
+            if (this.emSurpriseNew && this.emSurpriseNew.length) {
+                letterEmotionNumb.value = parseFloat(this.emSurpriseNew[this.letterFocus[0]])
+                letterEmotionNumb.disabled = false
+            }
+            if (this.registeredStyleKeys) {
+                this.registeredStyleKeys.forEach(styleKey => {
+                    if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+                        letterStyleNumb.value = parseFloat(this.styleValuesNew[styleKey][this.letterFocus[0]])
+                        letterStyleNumb.disabled = false
+                    }
+                })
+            }
+            letterPitchNumb.value = parseInt(this.pitchNew[this.letterFocus[0]]*100)/100
+            letterLengthNumb.value = parseInt(parseFloat(this.dursNew[this.letterFocus[0]])*100)/100
+
+            letterPitchNumb.disabled = false
+            letterLengthNumb.disabled = false
+        } else {
+            letterEnergyNumb.disabled = true
+            letterEnergyNumb.value = ""
+            letterEmotionNumb.disabled = true
+            letterEmotionNumb.value = ""
+            letterPitchNumb.disabled = true
+            letterPitchNumb.value = ""
+            letterLengthNumb.disabled = true
+            letterLengthNumb.value = ""
+        }
+    }
+
+
+    getChangedTimeStamps (startI, endI, audioSDuration) {
+
+        const adjustedLetters = Array.from(this.adjustedLetters)
+
+        // Skip this if start/end indexes are not found (new sample)
+        if ((startI==-1 || endI==-1) && !adjustedLetters.length) {
+            return undefined
+        }
+        startI = startI==-1 ? this.letters.length : parseInt(startI)
+        endI = endI==-1 ? 0 : parseInt(endI)
+
+        // Check OUTSIDE of the given changed indexes for TEXT, to see if there were other changes, to eg pitch/duration
+        if (adjustedLetters.length) {
+            startI = Math.min(startI, Math.min(adjustedLetters))
+            endI = Math.max(endI, Math.max(adjustedLetters))
+        }
+
+        const newStartI = startI
+        const newEndI = endI
+
+        // Then, look through the duration values of the audio, and get a percent into the audio where those new start/end points are
+        const totalDuration = this.dursNew.reduce((p,c)=>p+c,0)
+        const durAtStart = this.dursNew.filter((v,vi) => vi<=newStartI).reduce((p,c)=>p+c,0)
+        const durAtEnd = this.dursNew.filter((v,vi) => vi<=newEndI).reduce((p,c)=>p+c,0)
+        const startPercent = durAtStart/totalDuration
+        const endPercent = durAtEnd/totalDuration
+
+        // Then, multiply this by the seconds duration of the generated audio, and pad with ~500ms, to get the final start/end of the section of the audio to play
+        const startSeconds = Math.max(0, startPercent*audioSDuration-0.5)
+        const endSeconds = Math.min(audioSDuration, endPercent*audioSDuration+0.5)
+
+        return [startSeconds, endSeconds]
+    }
+}
+
+class Letter {
+    constructor (context, index, letter, sliderBox, centerY, left, width) {
+        this.type = "letter"
+        this.context = context
+        this.letter = letter
+        this.sliderBox = sliderBox
+        this.centerY = centerY
+        this.index = index
+
+        this.left = left
+        this.width = width
+        this.colour = "black"
+    }
+
+    render () {
+        this.context.fillStyle = this.colour
+        this.context.font = "20pt Arial"
+        this.context.textAlign = "center"
+        this.context.textBaseline = "middle"
+        this.context.fillText(this.letter, this.sliderBox.getXLeft()+this.sliderBox.width/2, this.centerY)
+    }
+}
+
+class SliderGrabber {
+
+    constructor (context, index, sliderBox, topLeftY, width, height, sliderRange) {
+        this.type = "slider"
+        this.context = context
+        this.sliderBox = sliderBox
+        this.topLeftY = topLeftY
+        this.width = width
+        this.height = height
+        this.index = index
+        this.sliderRange = sliderRange
+
+        this.isBeingDragged = false
+        this.dragStart = {x: undefined, y: undefined}
+
+        this.fillStyle = `#${window.currentGame.themeColourPrimary}`
+    }
+
+    render () {
+
+        this.context.beginPath()
+        this.context.rect(this.sliderBox.getXLeft()+1, this.topLeftY, this.width, this.height)
+        this.context.stroke()
+
+        this.context.fillStyle = this.fillStyle
+        this.context.fillRect(this.sliderBox.getXLeft()+1, this.topLeftY, this.width, this.height)
+    }
+
+    getXLeft () {
+        return this.sliderBox.getXLeft()
+    }
+
+    setValueFromCoords (topLeftY) {
+
+        this.topLeftY = topLeftY
+        this.topLeftY = Math.max(window.sequenceEditor.LETTERS_Y_OFFSET+1, this.topLeftY)
+        this.topLeftY = Math.min(this.topLeftY, window.sequenceEditor.LETTERS_Y_OFFSET+window.sequenceEditor.EDITOR_HEIGHT-this.height-1)
+
+        this.percentUp = (this.topLeftY-window.sequenceEditor.LETTERS_Y_OFFSET) / (window.sequenceEditor.EDITOR_HEIGHT-this.height)
+        window.sequenceEditor.pitchNew[this.index] = (1-this.percentUp)*(this.sliderRange*2)-this.sliderRange
+    }
+
+    setValueFromValue (value) {
+        value = Math.max(-this.sliderRange, value)
+        value = Math.min(value, this.sliderRange)
+        this.percentUp = (value+this.sliderRange)/(this.sliderRange*2)
+
+        this.topLeftY = (1-this.percentUp) * (window.sequenceEditor.EDITOR_HEIGHT-this.height) + window.sequenceEditor.LETTERS_Y_OFFSET
+    }
+
+}
+
+
+class EnergyEmotionGrabber extends SliderGrabber {
+
+    constructor (context, index, sliderBox, topLeftY, width, height, sliderRange, modelType, radius, sliderType) {
+        super(context, index, sliderBox, topLeftY, width, height, sliderRange)
+        this.type = `${sliderType}_slider`
+        this.modelType = modelType
+        this.radius = radius
+    }
+
+    render () {
+        this.context.fillStyle = this.fillStyle
+        this.context.beginPath()
+        this.context.lineWidth = 1
+        let x = this.sliderBox.getXLeft()+1 + this.sliderBox.width/2 // Centered
+        let y = this.topLeftY
+        this.context.arc(x, y, this.radius, 0, 2 * Math.PI)
+        this.context.fill()
+        this.context.stroke()
+        this.context.lineWidth = 1
+    }
+
+    setValueFromCoords (topLeftY) {
+
+        this.topLeftY = topLeftY
+        this.topLeftY = Math.max(window.sequenceEditor.LETTERS_Y_OFFSET+this.radius, this.topLeftY)
+        this.topLeftY = Math.min(this.topLeftY, window.sequenceEditor.LETTERS_Y_OFFSET+(window.sequenceEditor.EDITOR_HEIGHT-2-this.radius/2))
+
+        if (this.type=="energy_slider") {
+            if (this.modelType=="xVAPitch") {
+                this.percentUp = (this.topLeftY-window.sequenceEditor.LETTERS_Y_OFFSET)/(window.sequenceEditor.EDITOR_HEIGHT-this.radius)
+            } else {
+                this.percentUp = 1-(this.topLeftY-window.sequenceEditor.LETTERS_Y_OFFSET)/(window.sequenceEditor.EDITOR_HEIGHT-this.radius)
+            }
+            window.sequenceEditor.energyNew[this.index] = window.sequenceEditor.MAX_ENERGY - (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)*this.percentUp
+        } else if (this.type=="style_slider") {
+
+            this.percentUp = (this.topLeftY-window.sequenceEditor.LETTERS_Y_OFFSET)/(window.sequenceEditor.EDITOR_HEIGHT-this.radius)
+
+            window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+                if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+                    window.sequenceEditor.styleValuesNew[styleKey][this.index] = window.sequenceEditor.MAX_STYLES - (window.sequenceEditor.MAX_STYLES-window.sequenceEditor.MIN_STYLES)*this.percentUp
+                }
+            })
+
+        } else {
+            this.percentUp = (this.topLeftY-window.sequenceEditor.LETTERS_Y_OFFSET)/(window.sequenceEditor.EDITOR_HEIGHT-this.radius)
+            if (seq_edit_view_select.value=="emAngry") {
+                window.sequenceEditor.emAngryNew[this.index] = window.sequenceEditor.MAX_EMOTIONS - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_ENERGY)*this.percentUp
+            } else if (seq_edit_view_select.value=="emHappy") {
+                window.sequenceEditor.emHappyNew[this.index] = window.sequenceEditor.MAX_EMOTIONS - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_ENERGY)*this.percentUp
+            } else if (seq_edit_view_select.value=="emSad") {
+                window.sequenceEditor.emSadNew[this.index] = window.sequenceEditor.MAX_EMOTIONS - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_ENERGY)*this.percentUp
+            } else if (seq_edit_view_select.value=="emSurprise") {
+                window.sequenceEditor.emSurpriseNew[this.index] = window.sequenceEditor.MAX_EMOTIONS - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_ENERGY)*this.percentUp
+            }
+        }
+    }
+
+    setValueFromValue (value) {
+        if (this.type=="energy_slider") {
+            value = Math.max(window.sequenceEditor.MIN_ENERGY, value)
+            value = Math.min(value, window.sequenceEditor.MAX_ENERGY)
+            if (this.modelType=="xVAPitch") {
+                this.percentUp = ( (value-window.sequenceEditor.MIN_ENERGY) / (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)  )
+            } else {
+                this.percentUp = 1 - ( (value-window.sequenceEditor.MIN_ENERGY) / (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)  )
+            }
+        } else if (this.type=="style_slider") {
+            value = Math.max(window.sequenceEditor.MIN_STYLES, value)
+            value = Math.min(value, window.sequenceEditor.MAX_STYLES)
+            this.percentUp = ( (value-window.sequenceEditor.MIN_STYLES) / (window.sequenceEditor.MAX_STYLES-window.sequenceEditor.MIN_STYLES)  )
+        } else {
+            value = Math.max(window.sequenceEditor.MIN_EMOTIONS, value)
+            value = Math.min(value, window.sequenceEditor.MAX_EMOTIONS)
+            this.percentUp = ( (value-window.sequenceEditor.MIN_EMOTIONS) / (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_EMOTIONS)  )
+        }
+
+        this.topLeftY = (1 - this.percentUp) * (window.sequenceEditor.EDITOR_HEIGHT-2-this.radius*2) + (window.sequenceEditor.LETTERS_Y_OFFSET+1)
+    }
+}
+
+
+class SliderBox {
+    constructor (context, index, leftBox, topY, height, minLetterLength, maxLetterLength, alternateColour=false) {
+        this.type = "box"
+        this.context = context
+        this.leftBox = leftBox
+        this.topY = topY
+        this.height = height
+        this.index = index
+        this.alternateColour = alternateColour
+
+        this.LEFT_RIGHT_SEQ_PADDING = 20
+        this.MIN_LETTER_LENGTH = minLetterLength
+        this.MAX_LETTER_LENGTH = maxLetterLength
+
+        this.isBeingDragged = false
+        this.dragStart = {width: undefined, y: undefined}
+    }
+
+    render () {
+        this.context.globalAlpha = 0.3
+        this.context.fillStyle = this.alternateColour ? "white" : "black"
+        this.context.fillRect(this.LEFT_RIGHT_SEQ_PADDING+ (this.getLeftBox()?this.getLeftBox().getX():0), this.topY, this.width, this.height)
+
+        this.context.beginPath()
+        this.context.rect(this.LEFT_RIGHT_SEQ_PADDING+ (this.getLeftBox()?this.getLeftBox().getX():0), this.topY, this.width, this.height)
+        this.context.stroke()
+
+
+        this.context.globalAlpha = 1
+    }
+
+    setValueFromValue (value) {
+
+        value = value * window.sequenceEditor.pacing
+        value = Math.max(0.1, value)
+        value = Math.min(value, 20)
+
+        this.percentAcross = value/20
+        this.width = this.percentAcross * (this.MAX_LETTER_LENGTH-this.MIN_LETTER_LENGTH) + this.MIN_LETTER_LENGTH
+
+        this.grabber.width = this.width-2
+        this.letter.centerX = this.leftX + this.width/2
+    }
+
+    getLeftBox () {
+        if (this.leftBox) {
+            if (window.sequenceEditor.enabled_disabled_items[this.leftBox.index]) {
+                return this.leftBox
+            } else {
+                return this.leftBox.leftBox
+            }
+        }
+    }
+
+
+    getX () {
+        if (this.leftBox) {
+            return this.getLeftBox().getX() + this.width + 5
+        }
+        return 0 + this.width + 5
+    }
+    getXLeft () {
+        if (this.leftBox) {
+            return this.LEFT_RIGHT_SEQ_PADDING+this.getLeftBox().getX()
+        }
+        return this.LEFT_RIGHT_SEQ_PADDING
+    }
+}
+
+
+
+
+
+
+
+const infer = () => {
+    window.sequenceEditor.hasChanged = false
+    if (!isGenerating) {
+        generateVoiceButton.click()
+    }
+}
+const kickOffAutoInferTimer = () => {
+    if (window.sequenceEditor.autoInferTimer != null) {
+        clearTimeout(window.sequenceEditor.autoInferTimer)
+        window.sequenceEditor.autoInferTimer = null
+    }
+    if (autoplay_ckbx.checked) {
+        window.sequenceEditor.autoInferTimer = setTimeout(infer, 500)
+    }
+}
+
+
+// Un-select letters when clicking anywhere else
+right.addEventListener("click", event => {
+    if (event.target.nodeName=="BUTTON" || event.target.nodeName=="INPUT" || event.target.nodeName=="SVG" || event.target.nodeName=="IMG" || event.target.nodeName=="path" || event.target == window.sequenceEditor.canvas || event.target.id=="dialogueInput" || (event.target.classList && event.target.classList.contains("autocomplete_option"))) {
+        return
+    }
+    window.sequenceEditor.letterFocus.forEach(li => {
+        window.sequenceEditor.letterClasses[li].colour = "black"
+    })
+    window.sequenceEditor.letterFocus = []
+
+    letterEnergyNumb.disabled = true
+    letterEnergyNumb.value = ""
+    letterPitchNumb.disabled = true
+    letterPitchNumb.value = ""
+    letterLengthNumb.disabled = true
+    letterLengthNumb.value = ""
+    letterEmotionNumb.disabled = true
+    letterEmotionNumb.value = ""
+    letterStyleNumb.disabled = true
+    letterStyleNumb.value = ""
+})
+
+letterEnergyNumb.addEventListener("click", () => {
+    const lpnValue = parseFloat(letterEnergyNumb.value) || 0
+    if (window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+})
+letterEnergyNumb.addEventListener("input", () => {
+    const lpnValue = parseFloat(letterEnergyNumb.value) || 0
+    if (window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]] = lpnValue
+    window.sequenceEditor.energyGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    kickOffAutoInferTimer()
+})
+letterEnergyNumb.addEventListener("change", () => {
+    const lpnValue = parseFloat(letterEnergyNumb.value) || 0
+    if (window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]] = lpnValue
+    window.sequenceEditor.energyGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    kickOffAutoInferTimer()
+})
+
+letterEmotionNumb.addEventListener("click", () => {
+    const lpnValue = parseFloat(letterEmotionNumb.value) || 0
+    let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+    if (data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+})
+letterEmotionNumb.addEventListener("input", () => {
+    const lpnValue = parseFloat(letterEmotionNumb.value) || 0
+    let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+    if (window.sequenceEditor.data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.data[window.sequenceEditor.letterFocus[0]] = lpnValue
+    grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    kickOffAutoInferTimer()
+})
+letterEmotionNumb.addEventListener("change", () => {
+    const lpnValue = parseFloat(letterEmotionNumb.value) || 0
+    let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+    if (data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    data[window.sequenceEditor.letterFocus[0]] = lpnValue
+    grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    kickOffAutoInferTimer()
+})
+
+const getSelectedStyleDataAndGrabbers = () => {
+    let data, grabbers
+    window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+        if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+            data = window.sequenceEditor.styleValuesNew[styleKey]
+            grabbers = window.sequenceEditor.styleGrabbers[styleKey]
+        }
+    })
+    return [data, grabbers]
+}
+
+letterStyleNumb.addEventListener("click", () => {
+    const lpnValue = parseFloat(letterStyleNumb.value) || 0
+    let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+    if (data && data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+})
+letterStyleNumb.addEventListener("input", () => {
+    const lpnValue = parseFloat(letterStyleNumb.value) || 0
+    let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+    if (data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    data[window.sequenceEditor.letterFocus[0]] = lpnValue
+    grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    setNewDataToSelectedStyle(data)
+    kickOffAutoInferTimer()
+})
+letterStyleNumb.addEventListener("change", () => {
+    const lpnValue = parseFloat(letterStyleNumb.value) || 0
+    let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+    if (data[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    data[window.sequenceEditor.letterFocus[0]] = lpnValue
+    grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(lpnValue)
+    setNewDataToSelectedStyle(data)
+    kickOffAutoInferTimer()
+})
+
+
+letterPitchNumb.addEventListener("click", () => {
+    const lpnValue = parseFloat(letterPitchNumb.value) || 0
+    if (window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+})
+letterPitchNumb.addEventListener("input", () => {
+    const lpnValue = parseFloat(letterPitchNumb.value) || 0
+    if (window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]] = lpnValue
+    window.sequenceEditor.grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(letterPitchNumb.value)
+    kickOffAutoInferTimer()
+})
+letterPitchNumb.addEventListener("change", () => {
+    const lpnValue = parseFloat(letterPitchNumb.value) || 0
+    if (window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]!=lpnValue) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]] = lpnValue
+    window.sequenceEditor.grabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(letterPitchNumb.value)
+    kickOffAutoInferTimer()
+})
+
+resetLetter_btn.addEventListener("click", () => {
+    if (window.sequenceEditor.letterFocus.length==0) {
+        return
+    }
+
+    window.sequenceEditor.letterFocus.forEach(l => {
+        if (window.sequenceEditor.dursNew[l] != window.sequenceEditor.resetDurs[l]) {
+            window.sequenceEditor.hasChanged = true
+        }
+        window.sequenceEditor.dursNew[l] = window.sequenceEditor.resetDurs[l]
+        window.sequenceEditor.pitchNew[l] = window.sequenceEditor.resetPitch[l]
+
+        window.sequenceEditor.grabbers[l].setValueFromValue(window.sequenceEditor.resetPitch[l])
+        window.sequenceEditor.sliderBoxes[l].setValueFromValue(window.sequenceEditor.resetDurs[l])
+    })
+
+    if (window.sequenceEditor.letterFocus.length==1) {
+        letterLengthNumb.value = parseFloat(window.sequenceEditor.dursNew[window.sequenceEditor.letterFocus[0]])
+        letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]])
+
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+
+        window.sequenceEditor.emAngryNew[window.sequenceEditor.letterFocus[0]] = window.sequenceEditor.resetEmAngry[window.sequenceEditor.letterFocus[0]]
+        window.sequenceEditor.emAngryGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(window.sequenceEditor.emAngryNew[window.sequenceEditor.letterFocus[0]])
+        window.sequenceEditor.emHappyNew[window.sequenceEditor.letterFocus[0]] = window.sequenceEditor.resetEmHappy[window.sequenceEditor.letterFocus[0]]
+        window.sequenceEditor.emHappyGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(window.sequenceEditor.emHappyNew[window.sequenceEditor.letterFocus[0]])
+        window.sequenceEditor.emSadNew[window.sequenceEditor.letterFocus[0]] = window.sequenceEditor.resetEmSad[window.sequenceEditor.letterFocus[0]]
+        window.sequenceEditor.emSadGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(window.sequenceEditor.emSadNew[window.sequenceEditor.letterFocus[0]])
+        window.sequenceEditor.emSurpriseNew[window.sequenceEditor.letterFocus[0]] = window.sequenceEditor.resetEmSurprise[window.sequenceEditor.letterFocus[0]]
+        window.sequenceEditor.emSurpriseGrabbers[window.sequenceEditor.letterFocus[0]].setValueFromValue(window.sequenceEditor.emSurpriseNew[window.sequenceEditor.letterFocus[0]])
+
+        if (data) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]])
+        }
+
+        window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+            window.sequenceEditor.styleValuesNew[styleKey][window.sequenceEditor.letterFocus[0]] = window.sequenceEditor.styleValuesReset[styleKey][window.sequenceEditor.letterFocus[0]]
+            window.sequenceEditor.styleGrabbers[styleKey][window.sequenceEditor.letterFocus[0]].setValueFromValue(window.sequenceEditor.styleValuesNew[styleKey][window.sequenceEditor.letterFocus[0]])
+        })
+
+        let [styleData, styleGrabbers] = getSelectedStyleDataAndGrabbers()
+        if (styleData) {
+            letterStyleNumb.value = parseInt(styleData[window.sequenceEditor.letterFocus[0]])
+        }
+    }
+})
+const updateLetterLengthFromInput = () => {
+    if (window.sequenceEditor.dursNew[window.sequenceEditor.letterFocus[0]] != letterLengthNumb.value) {
+        window.sequenceEditor.hasChanged = true
+    }
+    window.sequenceEditor.dursNew[window.sequenceEditor.letterFocus[0]] = parseFloat(letterLengthNumb.value)
+
+    window.sequenceEditor.letterFocus.forEach(l => {
+        window.sequenceEditor.sliderBoxes[l].setValueFromValue(window.sequenceEditor.dursNew[l])
+    })
+    kickOffAutoInferTimer()
+}
+letterLengthNumb.addEventListener("input", () => {
+    updateLetterLengthFromInput()
+})
+letterLengthNumb.addEventListener("change", () => {
+    updateLetterLengthFromInput()
+})
+
+// Reset button
+window.resetEnergy = () => {
+    window.sequenceEditor.energyNew = window.sequenceEditor.resetEnergy.map(v => v)
+    window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+        slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+    })
+    if (window.sequenceEditor.letterFocus.length==1) {
+        letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+    }
+    if (window.sequenceEditor.letterFocus.length==1) {
+        letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]])
+    }
+}
+window.resetStyle = () => {
+    window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+        window.sequenceEditor.styleValuesNew[styleKey] = window.sequenceEditor.styleValuesReset[styleKey].map(v => v)
+        window.sequenceEditor.styleGrabbers[styleKey].forEach((slider, l) => slider.setValueFromValue(window.sequenceEditor.styleValuesNew[styleKey][l]))
+
+    })
+    let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+    if (data) {
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]])
+        }
+    }
+}
+window.resetEmotion = () => {
+    window.sequenceEditor.emAngryNew = window.sequenceEditor.resetEmAngry.map(v => v)
+    window.sequenceEditor.emHappyNew = window.sequenceEditor.resetEmHappy.map(v => v)
+    window.sequenceEditor.emSadNew = window.sequenceEditor.resetEmSad.map(v => v)
+    window.sequenceEditor.emSurpriseNew = window.sequenceEditor.resetEmSurprise.map(v => v)
+
+    let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+
+    window.sequenceEditor.emAngryGrabbers.forEach((slider, l) => slider.setValueFromValue(window.sequenceEditor.emAngryNew[l]))
+    window.sequenceEditor.emHappyGrabbers.forEach((slider, l) => slider.setValueFromValue(window.sequenceEditor.emHappyNew[l]))
+    window.sequenceEditor.emSadGrabbers.forEach((slider, l) => slider.setValueFromValue(window.sequenceEditor.emSadNew[l]))
+    window.sequenceEditor.emSurpriseGrabbers.forEach((slider, l) => slider.setValueFromValue(window.sequenceEditor.emSurpriseNew[l]))
+
+    if (data && window.sequenceEditor.letterFocus.length==1) {
+        letterEmotionNumb.value = parseFloat(data[window.sequenceEditor.letterFocus[0]])
+    }
+}
+window.resetPitch = () => {
+    window.sequenceEditor.pitchNew = window.sequenceEditor.resetPitch.map(p=>p)
+    // Update the editor pitch values
+    window.sequenceEditor.grabbers.forEach((slider, i) => {
+        slider.setValueFromValue(window.sequenceEditor.pitchNew[i])
+    })
+    if (window.sequenceEditor.letterFocus.length==1) {
+        letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+    }
+}
+window.resetDursPace = () => {
+
+    pace_slid.value = 1
+    paceNumbInput.value = 1
+    window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+
+    window.sequenceEditor.dursNew = window.sequenceEditor.resetDurs.map(v => v)
+    // Update the editor lengths
+    window.sequenceEditor.sliderBoxes.forEach((box,i) => {
+        box.setValueFromValue(window.sequenceEditor.dursNew[i])
+    })
+    if (window.sequenceEditor.letterFocus.length==1) {
+        letterLengthNumb.value = parseFloat(window.sequenceEditor.dursNew[window.sequenceEditor.letterFocus[0]])
+    }
+
+}
+reset_btn.addEventListener("click", () => {
+
+    if (window.shiftKeyIsPressed) {
+        if (seq_edit_edit_select.value=="energy") {
+            resetEnergy()
+            resetDursPace()
+
+        } else if (seq_edit_edit_select.value=="pitch") {
+            resetPitch()
+            resetDursPace()
+
+        } else if (seq_edit_edit_select.value=="emotion") {
+            resetEmotion()
+            resetDursPace()
+
+        } else if (seq_edit_edit_select.value=="style") {
+            resetStyle()
+            resetDursPace()
+        }
+
+        window.sequenceEditor.init()
+    } else {
+        reset_what_open_btn.click()
+    }
+})
+reset_what_confirm_btn.addEventListener("click", () => {
+    resetContainer.click()
+    if (reset_what_pitch.checked) {
+        resetPitch()
+    }
+    if (reset_what_energy.checked) {
+        resetEnergy()
+    }
+    if (reset_what_duration.checked) {
+        resetDursPace()
+    }
+    if (reset_what_emotion.checked) {
+        resetEmotion()
+    }
+    if (reset_what_style.checked) {
+        resetStyle()
+    }
+    window.sequenceEditor.init()
+})
+
+const getSelectedEmotionDataAndGrabbers = () => {
+    let data, grabbers
+    if (seq_edit_view_select.value=="emAngry") {
+        data = window.sequenceEditor.emAngryNew
+        grabbers = window.sequenceEditor.emAngryGrabbers
+    } else if (seq_edit_view_select.value=="emHappy") {
+        data = window.sequenceEditor.emHappyNew
+        grabbers = window.sequenceEditor.emHappyGrabbers
+    } else if (seq_edit_view_select.value=="emSad") {
+        data = window.sequenceEditor.emSadNew
+        grabbers = window.sequenceEditor.emSadGrabbers
+    } else if (seq_edit_view_select.value=="emSurprise") {
+        data = window.sequenceEditor.emSurpriseNew
+        grabbers = window.sequenceEditor.emSurpriseGrabbers
+    }
+    return [data, grabbers]
+}
+const setNewDataToSelectedEmotion = (data) => {
+    if (seq_edit_view_select.value=="emAngry") {
+        window.sequenceEditor.emAngryNew = data
+    } else if (seq_edit_view_select.value=="emHappy") {
+        window.sequenceEditor.emHappyNew = data
+    } else if (seq_edit_view_select.value=="emSad") {
+        window.sequenceEditor.emSadNew = data
+    } else if (seq_edit_view_select.value=="emSurprise") {
+        window.sequenceEditor.emSurpriseNew = data
+    }
+}
+const setNewDataToSelectedStyle = (data) => {
+    window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+        if (seq_edit_view_select.value.startsWith("style_") && seq_edit_view_select.value.includes(styleKey)) {
+            window.sequenceEditor.styleValuesNew[styleKey] = data
+        }
+    })
+}
+
+amplify_btn.addEventListener("click", () => {
+    if (seq_edit_edit_select.value=="pitch") {
+        window.sequenceEditor.pitchNew = window.sequenceEditor.pitchNew.map((p, pi) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(pi)==-1) {
+                return p
+            }
+            const newVal = p*1.025
+            return newVal>0 ? Math.min(window.sequenceEditor.pitchSliderRange, newVal) : Math.max(-window.sequenceEditor.pitchSliderRange, newVal)
+        })
+        window.sequenceEditor.grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.pitchNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_edit_select.value=="energy") {
+        window.sequenceEditor.energyNew = window.sequenceEditor.energyNew.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_ENERGY) - (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)/2
+            const newVal = e + distFromMiddle*0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_ENERGY, newVal) : Math.max(window.sequenceEditor.MIN_ENERGY, newVal)
+        })
+        window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_view_select.value.startsWith("style_")) {
+
+        let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+
+        data = data.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_STYLES) - (window.sequenceEditor.MAX_STYLES-window.sequenceEditor.MIN_STYLES)/2
+            const newVal = e + distFromMiddle*0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_STYLES, newVal) : Math.max(window.sequenceEditor.MIN_STYLES, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedStyle(data)
+
+    } else if (seq_edit_edit_select.value=="emotion") {
+
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+
+        data = data.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_EMOTIONS) - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_EMOTIONS)/2
+            const newVal = e + distFromMiddle*0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_EMOTIONS, newVal) : Math.max(window.sequenceEditor.MIN_EMOTIONS, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedEmotion(data)
+    }
+    kickOffAutoInferTimer()
+})
+flatten_btn.addEventListener("click", () => {
+    if (seq_edit_edit_select.value=="pitch") {
+        window.sequenceEditor.pitchNew = window.sequenceEditor.pitchNew.map((p,pi) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(pi)==-1) {
+                return p
+            }
+            return p*(1-0.025)
+        })
+        window.sequenceEditor.grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.pitchNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+
+    } else if (seq_edit_edit_select.value=="energy") {
+        window.sequenceEditor.energyNew = window.sequenceEditor.energyNew.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_ENERGY) - (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)/2
+            const newVal = e + distFromMiddle*-0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_ENERGY, newVal) : Math.max(window.sequenceEditor.MIN_ENERGY, newVal)
+        })
+        window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_view_select.value.startsWith("style_")) {
+
+        let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_STYLES) - (window.sequenceEditor.MAX_STYLES-window.sequenceEditor.MIN_STYLES)/2
+            const newVal = e + distFromMiddle*-0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_STYLES, newVal) : Math.max(window.sequenceEditor.MIN_STYLES, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedStyle(data)
+
+
+    } else if (seq_edit_edit_select.value=="emotion") {
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_EMOTIONS) - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_EMOTIONS)/2
+            const newVal = e + distFromMiddle*-0.025
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_EMOTIONS, newVal) : Math.max(window.sequenceEditor.MIN_EMOTIONS, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedEmotion(data)
+    }
+    kickOffAutoInferTimer()
+})
+
+
+jitter_btn.addEventListener("click", () => {
+    if (seq_edit_edit_select.value=="pitch") {
+        window.sequenceEditor.pitchNew = window.sequenceEditor.pitchNew.map((p, pi) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(pi)==-1) {
+                return p
+            }
+            let newVal
+            if (p==0) {
+                newVal = 1*(1+ (Math.random()*0.4+0.05) * ((Math.random()-0.5)>0 ? 1 : -1)  )
+                newVal -= 1
+            } else {
+                newVal = p*(1+ (Math.random()*0.2+0.05) * ((Math.random()-0.5)>0 ? 1 : -1)  )
+            }
+            return newVal>0 ? Math.min(window.sequenceEditor.pitchSliderRange, newVal) : Math.max(-window.sequenceEditor.pitchSliderRange, newVal)
+        })
+        window.sequenceEditor.grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.pitchNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_edit_select.value=="energy") {
+        window.sequenceEditor.energyNew = window.sequenceEditor.energyNew.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_ENERGY) - (window.sequenceEditor.MAX_ENERGY-window.sequenceEditor.MIN_ENERGY)/2
+            const newVal = e + distFromMiddle*(Math.random()*0.1+0.05) * ((Math.random()-0.5)>0 ? 1 : -1)
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_ENERGY, newVal) : Math.max(window.sequenceEditor.MIN_ENERGY, newVal)
+        })
+        window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_view_select.value.startsWith("style_")) {
+
+        let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+        data = data.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_STYLES) - (window.sequenceEditor.MAX_STYLES-window.sequenceEditor.MIN_STYLES)/2
+            const newVal = e + distFromMiddle*(Math.random()*0.1+0.05) * ((Math.random()-0.5)>0 ? 1 : -1)
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_STYLES, newVal) : Math.max(window.sequenceEditor.MIN_STYLES, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedStyle(data)
+
+    } else if (seq_edit_edit_select.value=="emotion") {
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+        data = data.map((e, ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            const distFromMiddle = (e-window.sequenceEditor.MIN_EMOTIONS) - (window.sequenceEditor.MAX_EMOTIONS-window.sequenceEditor.MIN_EMOTIONS)/2
+            const newVal = e + distFromMiddle*(Math.random()*0.1+0.05) * ((Math.random()-0.5)>0 ? 1 : -1)
+            return newVal>0 ? Math.min(window.sequenceEditor.MAX_EMOTIONS, newVal) : Math.max(window.sequenceEditor.MIN_EMOTIONS, newVal)
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedEmotion(data)
+    }
+    kickOffAutoInferTimer()
+})
+
+
+increase_btn.addEventListener("click", () => {
+    if (seq_edit_edit_select.value=="pitch") {
+        window.sequenceEditor.pitchNew = window.sequenceEditor.pitchNew.map((p,pi) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(pi)==-1) {
+                return p
+            }
+            return p+0.1
+        })
+        window.sequenceEditor.grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.pitchNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_edit_select.value=="energy") {
+        window.sequenceEditor.energyNew = window.sequenceEditor.energyNew.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return window.currentModel.modelType=="xVAPitch" ? e+0.04 : e-0.04
+        })
+        window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+
+    } else if (seq_edit_view_select.value.startsWith("style_")) {
+
+        let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return e+0.04
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedStyle(data)
+
+
+    } else if (seq_edit_edit_select.value=="emotion") {
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return e+0.04
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedEmotion(data)
+    }
+    kickOffAutoInferTimer()
+})
+decrease_btn.addEventListener("click", () => {
+    if (seq_edit_edit_select.value=="pitch") {
+        window.sequenceEditor.pitchNew = window.sequenceEditor.pitchNew.map((p,pi) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(pi)==-1) {
+                return p
+            }
+            return p-0.1
+        })
+        window.sequenceEditor.grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.pitchNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterPitchNumb.value = parseInt(window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+    } else if (seq_edit_edit_select.value=="energy") {
+        window.sequenceEditor.energyNew = window.sequenceEditor.energyNew.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return window.currentModel.modelType=="xVAPitch" ? e-0.04 : e+0.04
+        })
+        window.sequenceEditor.energyGrabbers.forEach((slider, l) => {
+            slider.setValueFromValue(window.sequenceEditor.energyNew[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEnergyNumb.value = parseInt(window.sequenceEditor.energyNew[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+
+    } else if (seq_edit_view_select.value.startsWith("style_")) {
+
+        let [data, grabbers] = getSelectedStyleDataAndGrabbers()
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return e-0.04
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterStyleNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedStyle(data)
+
+
+    } else if (seq_edit_edit_select.value=="emotion") {
+        let [data, grabbers] = getSelectedEmotionDataAndGrabbers()
+        data = data.map((e,ei) => {
+            if (window.sequenceEditor.letterFocus.length>1 && window.sequenceEditor.letterFocus.indexOf(ei)==-1) {
+                return e
+            }
+            return e-0.04
+        })
+        grabbers.forEach((slider, l) => {
+            slider.setValueFromValue(data[l])
+        })
+        if (window.sequenceEditor.letterFocus.length==1) {
+            letterEmotionNumb.value = parseInt(data[window.sequenceEditor.letterFocus[0]]*100)/100
+        }
+        setNewDataToSelectedEmotion(data)
+    }
+    kickOffAutoInferTimer()
+})
+
+pace_slid.addEventListener("input", () => {
+    paceNumbInput.value = pace_slid.value
+})
+
+pace_slid.addEventListener("change", () => {
+    editorTooltip.style.display = "none"
+    if (autoplay_ckbx.checked) {
+        generateVoiceButton.click()
+    }
+    paceNumbInput.value = pace_slid.value
+    window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+    window.sequenceEditor.init()
+})
+
+pace_slid.addEventListener("input", () => {
+    window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+    window.sequenceEditor.sliderBoxes.forEach((box, i) => {
+        box.setValueFromValue(window.sequenceEditor.dursNew[i])
+    })
+})
+paceNumbInput.addEventListener("change", () => {
+    pace_slid.value = paceNumbInput.value
+    if (autoplay_ckbx.checked) {
+        generateVoiceButton.click()
+    }
+    window.sequenceEditor.sliderBoxes.forEach((box, i) => {box.setValueFromValue(window.sequenceEditor.dursNew[i])})
+    window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+    window.sequenceEditor.init()
+})
+paceNumbInput.addEventListener("keyup", () => {
+    pace_slid.value = paceNumbInput.value
+    window.sequenceEditor.sliderBoxes.forEach((box, i) => {box.setValueFromValue(window.sequenceEditor.dursNew[i])})
+    window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+    window.sequenceEditor.init()
+})
+autoplay_ckbx.addEventListener("change", () => {
+    window.userSettings.autoplay = autoplay_ckbx.checked
+    saveUserSettings()
+})
+
+
+// Populate the languages dropdown
+window.supportedLanguages = {
+    // "am": "Amharic",
+    "ar": "Arabic",
+    "da": "Danish",
+    "de": "German",
+    "el": "Greek",
+    "en": "English",
+    "es": "Spanish",
+    "fi": "Finnish",
+    "fr": "French",
+    "ha": "Hausa",
+    "hi": "Hindi",
+    "hu": "Hungarian",
+    "it": "Italian",
+    "jp": "Japanese",
+    "ko": "Korean",
+    "la": "Latin",
+    "nl": "Dutch",
+    "pl": "Polish",
+    "pt": "Portuguese",
+    "ro": "Romanian",
+    "ru": "Russian",
+    "sv": "Swedish",
+    "sw": "Swahili",
+    // "th": "Thai",
+    "tr": "Turkish",
+    "uk": "Ukrainian",
+    "vi": "Vietnamese",
+    "wo": "Wolof",
+    "yo": "Yoruba",
+    "zh": "Chinese"
+}
+window.populateLanguagesDropdownsFromModel = (dropdown, modelJson=undefined) => {
+    dropdown.innerHTML = ""
+
+    Object.keys(window.supportedLanguages).sort((a,b)=>window.supportedLanguages[a]<window.supportedLanguages[b]?-1:1).forEach(key => {
+        if (!modelJson || !modelJson.lang_capabilities || modelJson.lang_capabilities.includes(key)) {
+            const opt = createElem("option", window.supportedLanguages[key])
+            opt.value = key
+            dropdown.appendChild(opt)
+        }
+    })
+}
+window.populateLanguagesDropdownsFromModel(base_lang_select)
+window.populateLanguagesDropdownsFromModel(voiceWorkbenchLanguageDropdown)
+base_lang_select.value = "en"
+voiceWorkbenchLanguageDropdown.value = "en"
+
+
+
+// For copying the generated ARPAbet sequence to the clipboard
+editorContainer.addEventListener("contextmenu", event => {
+    event.preventDefault()
+    ipcRenderer.send('show-context-menu-editor')
+})
+ipcRenderer.on('context-menu-command', (e, command) => {
+
+    if (command=="context-copy-editor") {
+        if (window.sequenceEditor && window.sequenceEditor.sequence && window.sequenceEditor.sequence.length && window.currentModel && window.currentModel.modelType=="xVAPitch") {
+
+            let seqARPAbet = window.sequenceEditor.sequence
+            if (seqARPAbet[0]=="_") {
+                seqARPAbet = seqARPAbet.slice(1, seqARPAbet.length)
+            }
+            if (seqARPAbet[seqARPAbet.length-1]=="_") {
+                seqARPAbet = seqARPAbet.slice(0, seqARPAbet.length-1)
+            }
+
+            seqARPAbet = seqARPAbet.filter(val => val!="<PAD>")
+            seqARPAbet = seqARPAbet.map(v => {
+                if (v=="_") {
+                    return "} {"
+                }
+                return v
+            })
+
+            clipboard.writeText("{"+seqARPAbet.join(" ")+"}")
+        }
+    }
+})
+
+
+// Audio player
+window.initWaveSurfer = (src) => {
+    if (window.wavesurfer) {
+        window.wavesurfer.stop()
+        wavesurferContainer.innerHTML = ""
+    } else {
+        window.wavesurfer = WaveSurfer.create({
+            container: '#wavesurferContainer',
+            backend: 'MediaElement',
+            waveColor: `#${window.currentGame.themeColourPrimary}`,
+            height: 100,
+            progressColor: 'white',
+            responsive: true,
+        })
+    }
+    try {
+        window.wavesurfer.setSinkId(window.userSettings.base_speaker)
+    } catch (e) {
+        console.log("Can't set sinkId")
+    }
+    if (src) {
+        window.wavesurfer.load(src)
+    }
+    window.wavesurfer.on("finish", () => {
+        samplePlayPause.innerHTML = window.i18n.PLAY
+    })
+    window.wavesurfer.on("seek", event => {
+        if (event!=0) {
+            window.wavesurfer.play()
+            samplePlayPause.innerHTML = window.i18n.PAUSE
+        }
+    })
+}
+window.samplePlayPauseHandler = event => {
+    if (window.wavesurfer) {
+        if (event.ctrlKey) {
+            if (window.wavesurfer.sink_id!=window.userSettings.alt_speaker) {
+                window.wavesurfer.setSinkId(window.userSettings.alt_speaker)
+            }
+        } else {
+            if (window.wavesurfer.sink_id!=window.userSettings.base_speaker) {
+                window.wavesurfer.setSinkId(window.userSettings.base_speaker)
+            }
+        }
+
+        if (window.wavesurfer.isPlaying()) {
+            samplePlayPause.innerHTML = window.i18n.PLAY
+            window.wavesurfer.playPause()
+        } else {
+            samplePlayPause.innerHTML = window.i18n.PAUSE
+            window.wavesurfer.playPause()
+        }
+    }
+}
+samplePlayPause.addEventListener("click", window.samplePlayPauseHandler)
+
+
+exports.Editor = Editor

javascript/embeddings.js

@@ -0,0 +1,795 @@
+"use strict"
+
+
+window.openEmbeddingsWindow = () => {
+    closeModal(undefined, embeddingsContainer).then(() => {
+        embeddingsContainer.style.opacity = 0
+        embeddingsContainer.style.display = "flex"
+        requestAnimationFrame(() => requestAnimationFrame(() => embeddingsContainer.style.opacity = 1))
+        requestAnimationFrame(() => requestAnimationFrame(() => chromeBar.style.opacity = 1))
+    })
+}
+
+window.embeddingsState = {
+    data: {},
+    allData: {},
+    clickedObject: undefined,
+    spritesOn: true,
+    gendersOn: false,
+    voiceCheckboxes: [],
+    isReady: false,
+    isOpen: false,
+    sceneData: {},
+    mouseIsDown: false,
+    rightMouseIsDown: false,
+    mousePos: {x: 0, y: 0}
+}
+
+
+
+function componentToHex(c) {
+    c = Math.min(255, c)
+    var hex = c.toString(16);
+    return hex.length == 1 ? "0" + hex : hex;
+}
+
+function rgbToHex(r, g, b) {
+    return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b);
+}
+function hexToRgb(hex, normalize) {
+    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    const colour = result ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16)
+    } : null;
+    if (normalize && colour) {
+        colour.r /= 255
+        colour.g /= 255
+        colour.b /= 255
+    }
+    return colour
+}
+
+
+window.populateGamesList = () => {
+    embeddingsGamesListContainer.innerHTML = ""
+    Object.keys(window.gameAssets).sort((a,b)=>a<b?-1:1).forEach(gameId => {
+        const gameSelectContainer = createElem("div")
+        const gameCheckbox = createElem(`input#embs_${gameId}`, {type: "checkbox"})
+        gameCheckbox.checked = true
+        const gameButton = createElem("button.fixedColour")
+        gameButton.style.setProperty("background-color", `#${window.embeddingsState.gameColours[gameId]}`, "important")
+        gameButton.style.display = "flex"
+        gameButton.style.alignItems = "center"
+        gameButton.style.margin = "auto"
+        gameButton.style.marginTop = "8px"
+        const buttonLabel = createElem("span", window.embeddingsState.gameTitles[gameId])
+
+        gameButton.addEventListener("click", e => {
+            if (e.target==gameButton || e.target==buttonLabel) {
+                gameCheckbox.click()
+                window.populateVoicesList()
+                window.computeEmbsAndDimReduction()
+            }
+        })
+        gameButton.addEventListener("contextmenu", e => {
+            if (e.target==gameButton || e.target==buttonLabel) {
+                Array.from(embeddingsGamesListContainer.querySelectorAll("input")).forEach(ckbx => ckbx.checked = false)
+                gameCheckbox.click()
+                window.populateVoicesList()
+                window.computeEmbsAndDimReduction()
+            }
+        })
+        gameCheckbox.addEventListener("click", () => {
+            window.populateVoicesList()
+            window.computeEmbsAndDimReduction()
+        })
+
+
+        gameButton.appendChild(gameCheckbox)
+        gameButton.appendChild(buttonLabel)
+        gameSelectContainer.appendChild(gameButton)
+        embeddingsGamesListContainer.appendChild(gameSelectContainer)
+    })
+}
+
+
+
+window.populateVoicesList = () => {
+    const enabledGames = Array.from(embeddingsGamesListContainer.querySelectorAll("input"))
+        .map(elem => [elem.checked, elem.id.replace("embs_", "")])
+        .filter(checkedId => checkedId[0])
+        .map(checkedId => checkedId[1].replace("embs_", ""))
+
+    const checkboxes = []
+
+    embeddingsRecordsContainer.innerHTML = ""
+    Object.keys(window.games).forEach(gameId => {
+        if (!enabledGames.includes(gameId)) {
+            return
+        }
+
+        window.games[gameId].models.forEach(model => {
+
+            model.variants.forEach(variant => {
+                const voiceRowElem = createElem("div")
+
+                const voiceCkbx = createElem(`input#embsVoice_${variant.voiceId}`, {type: "checkbox"})
+                voiceCkbx.checked = true
+                voiceCkbx.addEventListener("click", () => {
+                    window.computeEmbsAndDimReduction()
+                })
+                checkboxes.push(voiceCkbx)
+                const showVoiceBtn = createElem("button.smallButton.fixedColour", "Show")
+                showVoiceBtn.style.background = `#${window.embeddingsState.gameColours[model.gameId]}`
+                showVoiceBtn.addEventListener("click", () => {
+                    if (!voiceCkbx.checked) {
+                        return window.errorModal(window.i18n.VEMB_VOICE_NOT_ENABLED)
+                    }
+                    const point = window.embeddingsState.sceneData.points.find(point => point.data.voiceId==variant.voiceId)
+                    window.embeddingsState.sceneData.controls.target.set(point.position.x, point.position.y, point.position.z)
+
+                    const cameraPos = window.embeddingsState.sceneData.camera.position
+                    const deltaX = (point.position.x - cameraPos.x)
+                    const deltaY = (point.position.y - cameraPos.y)
+                    const deltaZ = (point.position.z - cameraPos.z)
+
+                    window.embeddingsState.sceneData.camera.position.set(cameraPos.x+deltaX/2, cameraPos.y+deltaY/2, cameraPos.z+deltaZ/2)
+
+                })
+
+                const nameElem = createElem("div", model.voiceName+(model.variants.length>1?` (${variant.variantName})`:""))
+                nameElem.title = model.voiceName
+                const gameElem = createElem("div", window.embeddingsState.gameTitles[model.gameId])
+                gameElem.title = window.embeddingsState.gameTitles[model.gameId]
+                const voiceGender = createElem("div", variant.gender)
+                voiceGender.title = variant.gender
+
+                voiceRowElem.appendChild(createElem("div", voiceCkbx))
+                voiceRowElem.appendChild(createElem("div", showVoiceBtn))
+                voiceRowElem.appendChild(nameElem)
+                voiceRowElem.appendChild(gameElem)
+                voiceRowElem.appendChild(voiceGender)
+
+                if (embeddingsSearchBar.value.length && !model.voiceName.toLowerCase().trim().includes(embeddingsSearchBar.value.toLowerCase().trim())) {
+                    return
+                }
+                embeddingsRecordsContainer.appendChild(voiceRowElem)
+            })
+        })
+    })
+
+    window.embeddingsState.voiceCheckboxes = checkboxes
+
+}
+embeddingsSearchBar.addEventListener("keyup", () => window.populateVoicesList())
+
+
+
+window.initDataMappings = () => {
+
+    window.embeddingsState.voiceIdToModel = {}
+    window.embeddingsState.gameShortIdToGameId = {}
+    window.embeddingsState.gameColours = {}
+    window.embeddingsState.gameTitles = {}
+
+
+    const idToGame = {}
+    Object.keys(window.gameAssets).forEach(gameId => {
+        const id = window.gameAssets[gameId].gameCode
+        idToGame[id] = gameId
+    })
+
+    Object.keys(window.gameAssets).forEach(gameId => {
+        // Short game ID to full game ID
+        const gameShortId = window.gameAssets[gameId].gameCode.toLowerCase()
+        window.embeddingsState.gameShortIdToGameId[gameShortId] = gameId.toLowerCase()
+
+        // Game title
+        const title = window.gameAssets[gameId].gameName
+        window.embeddingsState.gameTitles[gameId] = title
+
+        // Game colour
+        let colour = window.gameAssets[gameId].themeColourPrimary
+        colour = colour.length==3 ? `${colour[0]}${colour[0]}${colour[1]}${colour[1]}${colour[2]}${colour[2]}` : colour
+        window.embeddingsState.gameColours[gameId] = colour
+    })
+
+    Object.keys(window.games).forEach(gameId => {
+        // Voice Id to model data
+        window.games[gameId].models.forEach(model => {
+            model.variants.forEach(variant => {
+                window.embeddingsState.voiceIdToModel[variant.voiceId] = JSON.parse(JSON.stringify(model))
+                if (model.variants.length>1) {
+                    let voiceName = window.embeddingsState.voiceIdToModel[variant.voiceId].voiceName
+                    voiceName = `${voiceName} (${variant.variantName})`
+                    window.embeddingsState.voiceIdToModel[variant.voiceId].voiceName = voiceName
+                }
+            })
+        })
+    })
+}
+
+
+
+
+window.initEmbeddingsScene = () => {
+    window.initDataMappings()
+    window.populateGamesList()
+    window.populateVoicesList()
+
+    embeddingsSceneContainer.addEventListener("mousedown", (event) => {
+        window.embeddingsState.mousePos.x = parseInt(event.layerX)
+        window.embeddingsState.mousePos.y = parseInt(event.layerY)
+    })
+    embeddingsSceneContainer.addEventListener("mouseup", (event) => {
+        const mouseX = parseInt(event.layerX)
+        const mouseY = parseInt(event.layerY)
+
+        if (event.button==0) {
+            if (Math.abs(mouseX-window.embeddingsState.mousePos.x)<10 && Math.abs(mouseY-window.embeddingsState.mousePos.y)<10) {
+                window.embeddingsState.mouseIsDown = true
+                setTimeout(() => {window.embeddingsState.mouseIsDown = false}, 100)
+            }
+        } else if (event.button==2) {
+            if (Math.abs(mouseX-window.embeddingsState.mousePos.x)<10 && Math.abs(mouseY-window.embeddingsState.mousePos.y)<10) {
+                window.embeddingsState.rightMouseIsDown = true
+                setTimeout(() => {window.embeddingsState.rightMouseIsDown = false}, 100)
+            }
+        }
+    })
+    window.embeddingsState.isReady = false
+
+    const SPHERE_RADIUS = 3
+    const SPHERE_V_COUNT = 50
+
+    // Renderer
+    window.embeddingsState.renderer = new THREE.WebGLRenderer({alpha: true, antialias: true})
+    window.embeddingsState.renderer.setPixelRatio( window.devicePixelRatio )
+    window.embeddingsState.renderer.setSize(embeddingsSceneContainer.offsetWidth, embeddingsSceneContainer.offsetHeight)
+    embeddingsSceneContainer.appendChild(window.embeddingsState.renderer.domElement)
+
+    // Scene and camera
+    const scene = new THREE.Scene()
+    window.embeddingsState.sceneData.camera = new THREE.PerspectiveCamera(60, embeddingsSceneContainer.offsetWidth/embeddingsSceneContainer.offsetHeight, 0.001, 100000)
+    window.embeddingsState.sceneData.camera.position.set( -100, 0, 0 )
+
+    // Controls
+    window.embeddingsState.sceneData.controls = new THREE.OrbitControls(window.embeddingsState.sceneData.camera, window.embeddingsState.renderer.domElement)
+    window.embeddingsState.sceneData.controls2 = new THREE.TrackballControls(window.embeddingsState.sceneData.camera, window.embeddingsState.renderer.domElement)
+    window.embeddingsState.sceneData.controls.target.set(window.embeddingsState.sceneData.camera.position.x+0.15, window.embeddingsState.sceneData.camera.position.y, window.embeddingsState.sceneData.camera.position.z)
+
+
+    window.embeddingsState.sceneData.controls.enableDamping = true
+    window.embeddingsState.sceneData.controls.dampingFactor = 0.025
+    window.embeddingsState.sceneData.controls.screenSpacePanning = true
+    window.embeddingsState.sceneData.controls.rotateSpeed = 1/6
+    window.embeddingsState.sceneData.controls.panSpeed = 1
+    window.embeddingsState.sceneData.controls.minDistance = 50
+    window.embeddingsState.sceneData.controls.maxDistance = 500
+
+    window.embeddingsState.sceneData.controls2.noRotate = true
+    window.embeddingsState.sceneData.controls2.noPan = true
+    window.embeddingsState.sceneData.controls2.noZoom = true
+    window.embeddingsState.sceneData.controls2.zoomSpeed = 1/2// 1.5
+    window.embeddingsState.sceneData.controls2.dynamicDampingFactor = 0.2
+
+
+
+    const light = new THREE.DirectionalLight( 0xffffff, 0.5 )
+    light.position.set( -1, 1, 1 ).normalize()
+    scene.add(light)
+    scene.add(new THREE.AmbientLight( 0xffffff, 0.5 ))
+
+    // Mouse event ray caster
+    const raycaster = new THREE.Raycaster()
+    const mouse = new THREE.Vector2()
+    window.embeddingsState.renderer.domElement.addEventListener("mousemove", event => {
+        const sizeY = event.target.height
+        const sizeX = event.target.width
+        mouse.x = event.offsetX / sizeX * 2 - 1
+        mouse.y = -event.offsetY / sizeY * 2 + 1
+    }, false)
+
+
+    window.embeddingsState.sceneData.sprites = []
+    window.embeddingsState.sceneData.points = []
+
+    window.refreshEmbeddingsScenePoints = () => {
+
+        const enabledGames = Array.from(embeddingsGamesListContainer.querySelectorAll("input"))
+            .map(elem => [elem.checked, elem.id.replace("embs_", "")])
+            .filter(checkedId => checkedId[0])
+            .map(checkedId => checkedId[1].replace("embs_", ""))
+
+
+        const data = window.embeddingsState.data
+
+        const newDataNames = Object.keys(data)
+        const oldDataKept = []
+
+        const newSprites = []
+        const newPoints = []
+
+        // Remove any existing data
+        ;[window.embeddingsState.sceneData.points, window.embeddingsState.sceneData.sprites].forEach(dataList => {
+            dataList.forEach(object => {
+                const objectName = object.data.voiceId
+                if (newDataNames.includes(objectName)) {
+                    oldDataKept.push(objectName)
+                    const coords = {
+                        x: parseFloat(data[objectName][0]),
+                        y: parseFloat(data[objectName][1])-(object.data.type=="text"?SPHERE_RADIUS*1.5:0),
+                        z: parseFloat(data[objectName][2])
+                    }
+                    object.data.isMoving = true
+                    object.data.newPos = coords
+                    if (object.data.type=="text") {
+                        newSprites.push(object)
+                    } else {
+                        newPoints.push(object)
+                    }
+                } else {
+                    scene.remove(object)
+                }
+            })
+        })
+
+        // Add the new data
+        window.embeddingsState.sceneData.sprites = newSprites
+        window.embeddingsState.sceneData.points = newPoints
+        Object.keys(data).forEach(voiceId => {
+
+            if (oldDataKept.includes(voiceId)) {
+                return
+            }
+            const game = Object.keys(window.embeddingsState.gameShortIdToGameId).includes(voiceId.split("_")[0]) ? window.embeddingsState.gameShortIdToGameId[voiceId.split("_")[0]] : "other"
+            let gender
+            if (Object.keys(window.embeddingsState.voiceIdToModel).includes(voiceId)) {
+                gender = window.embeddingsState.voiceIdToModel[voiceId].gender || window.embeddingsState.voiceIdToModel[voiceId].variants[0].gender
+            } else {
+                gender = window.embeddingsState.allData[voiceId].voiceGender
+            }
+            gender = gender ? gender.toLowerCase() : "other"
+
+            // if (!enabledGames.includes(game)) {
+            //     return
+            // }
+
+            // Filter out data by gender
+            // if (gender=="male" && !embeddingsMalesCkbx.checked) {
+            //     return
+            // }
+            // if (gender=="female" && !embeddingsFemalesCkbx.checked) {
+            //     return
+            // }
+            // if (gender=="other" && !embeddingsOtherGendersCkbx.checked) {
+            //     return
+            // }
+
+
+            // Colour dict
+            const colour = hexToRgb("#"+window.embeddingsState.gameColours[game])
+            const genderColours = {
+                "f": {r: 200, g: 0, b: 0},
+                "m": {r: 0, g: 0, b: 200},
+                "o": {r: 85, g: 85, b: 85},
+            }
+            const coords = {
+                x: parseFloat(data[voiceId][0]),
+                y: parseFloat(data[voiceId][1]),
+                z: parseFloat(data[voiceId][2])
+            }
+
+            const genderColour = gender=="female" ? genderColours["f"] : (gender=="male" ? genderColours["m"] : genderColours["o"])
+
+
+            const pointGeometry = new THREE.SphereGeometry(SPHERE_RADIUS, SPHERE_V_COUNT, SPHERE_V_COUNT)
+            const pointMaterial = new THREE.MeshLambertMaterial({
+                color: window.embeddingsState.gendersOn ? rgbToHex(genderColour.r, genderColour.g, genderColour.b) : "#"+window.embeddingsState.gameColours[game],
+                transparent: true
+            })
+            pointMaterial.emissive.emissiveIntensity = 1
+
+
+            // Point sphere
+            const point = new THREE.Mesh(pointGeometry, pointMaterial)
+            point.position.x = coords.x
+            point.position.y = coords.y
+            point.position.z = coords.z
+            point.name = `point|${voiceId}`
+            point.data = {
+                type: "point",
+                voiceId: voiceId,
+                game: game,
+                gameColour: {r: colour.r, g: colour.g, b: colour.b},
+                genderColour: genderColour
+            }
+            window.embeddingsState.sceneData.points.push(point)
+            scene.add(point)
+
+            let voiceName
+            if (Object.keys(window.embeddingsState.voiceIdToModel).includes(voiceId)) {
+                voiceName = window.embeddingsState.voiceIdToModel[voiceId].voiceName
+            } else {
+                voiceName = window.embeddingsState.allData[voiceId].voiceName
+            }
+
+            // Text sprite
+            const sprite = new THREE.TextSprite({
+                text: voiceName,
+                fontFamily: 'Helvetica, sans-serif',
+                fontSize: 2,
+                strokeColor: '#ffffff',
+                strokeWidth: 0,
+                color: '#24ff00',
+                material: {color: "white"}
+            })
+            sprite.position.x = coords.x
+            sprite.position.y = coords.y-SPHERE_RADIUS*1.5
+            sprite.position.z = coords.z
+            sprite.name = `sprite|${voiceId}`
+            sprite.data = {type: "text", voiceId: voiceId, game: game}
+            window.embeddingsState.sceneData.sprites.push(sprite)
+            scene.add(sprite)
+        })
+    }
+    window.refreshEmbeddingsScenePoints()
+
+    let hoveredObject = undefined
+    let clickedObject = undefined
+
+    window.embeddings_render = () => {
+        if (!window.embeddingsState.isReady) {
+            return
+        }
+        requestAnimationFrame(window.embeddings_render)
+
+        const target = window.embeddingsState.sceneData.controls.target
+        window.embeddingsState.sceneData.controls.update()
+        window.embeddingsState.sceneData.controls2.target.set(target.x, target.y, target.z)
+        window.embeddingsState.sceneData.controls2.update()
+
+        window.embeddingsState.sceneData.camera.updateMatrixWorld()
+
+        raycaster.setFromCamera( mouse, window.embeddingsState.sceneData.camera );
+
+        // Move objects
+        [window.embeddingsState.sceneData.points, window.embeddingsState.sceneData.sprites].forEach(dataList => {
+            dataList.forEach(object => {
+                if (object.data.isMoving) {
+                    if (Math.abs(object.position.x-object.data.newPos.x)>0.005) {
+                        object.position.x += (object.data.newPos.x - object.position.x) / 20
+                        object.position.y += (object.data.newPos.y - object.position.y) / 20
+                        object.position.z += (object.data.newPos.z - object.position.z) / 20
+
+                    } else {
+                        object.data.isMoving = false
+                        object.data.newPos = undefined
+                    }
+                }
+            })
+        })
+
+
+        // Handle mouse events
+        let intersects = raycaster.intersectObjects(scene.children, true)
+        if (intersects.length) {
+
+            if (intersects.length>2) {
+                intersects = [intersects.find(it => it.object.data.type=="point")]
+            }
+            if (intersects.length==0 || intersects[0]==undefined || intersects[0].object==undefined || intersects[0].object.data.type=="text") {
+                window.embeddingsState.renderer.render(scene, window.embeddingsState.sceneData.camera)
+                return
+            }
+
+            window.embeddingsState.renderer.domElement.style.cursor = "pointer"
+
+            if (hoveredObject != undefined && hoveredObject.object.data.voiceId!=intersects[0].object.data.voiceId) {
+                const colour = window.embeddingsState.gendersOn ? hoveredObject.object.data.genderColour : hoveredObject.object.data.gameColour
+                hoveredObject.object.material.color.r = Math.min(1, colour.r/255)
+                hoveredObject.object.material.color.g = Math.min(1, colour.g/255)
+                hoveredObject.object.material.color.b = Math.min(1, colour.b/255)
+            }
+            hoveredObject = intersects[0]
+
+            const colour = window.embeddingsState.gendersOn ? hoveredObject.object.data.genderColour : hoveredObject.object.data.gameColour
+            hoveredObject.object.material.color.r = Math.min(1, colour.r/255*1.5)
+            hoveredObject.object.material.color.g = Math.min(1, colour.g/255*1.5)
+            hoveredObject.object.material.color.b = Math.min(1, colour.b/255*1.5)
+
+
+            // Right click does voice audio preview
+            if (window.embeddingsState.rightMouseIsDown) {
+                window.embeddingsState.rightMouseIsDown = false
+                const voiceId = hoveredObject.object.data.voiceId
+                const gameId = hoveredObject.object.data.game
+                const modelsPathForGame = window.userSettings[`modelspath_${gameId}`]
+                const audioPreviewPath = `${modelsPathForGame}/${voiceId}.wav`
+
+                if (fs.existsSync(audioPreviewPath)) {
+                    const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+                        src: audioPreviewPath
+                    }))
+                    audioPreview.setSinkId(window.userSettings.base_speaker)
+                } else {
+                    window.errorModal(window.i18n.VEMB_NO_PREVIEW)
+                }
+            }
+
+            // Left click does voice click
+            if (window.embeddingsState.mouseIsDown) {
+                if (window.embeddingsState.clickedObject==undefined || window.embeddingsState.clickedObject.voiceId!=hoveredObject.object.data.voiceId) {
+                    if (window.embeddingsState.clickedObject!=undefined) {
+                        window.embeddingsState.clickedObject.object.material.emissive.setRGB(0,0,0)
+                    }
+                    window.embeddingsState.clickedObject = {
+                        voiceId: hoveredObject.object.data.voiceId,
+                        game: hoveredObject.object.data.game,
+                        object: hoveredObject.object
+                    }
+                    hoveredObject.object.material.emissive.setRGB(0, 1, 0)
+
+                    const voiceId = window.embeddingsState.clickedObject.object.data.voiceId
+
+                    if (Object.keys(window.embeddingsState.voiceIdToModel).includes(voiceId)) {
+                        embeddingsVoiceGameDisplay.innerHTML = window.embeddingsState.gameTitles[window.embeddingsState.clickedObject.object.data.game]
+                        embeddingsVoiceNameDisplay.innerHTML = window.embeddingsState.voiceIdToModel[voiceId].voiceName
+                        embeddingsVoiceGenderDisplay.innerHTML = window.embeddingsState.voiceIdToModel[voiceId].gender || window.embeddingsState.voiceIdToModel[voiceId].variants[0].gender
+                    } else {
+                        embeddingsVoiceGameDisplay.innerHTML = window.embeddingsState.gameTitles[window.embeddingsState.clickedObject.object.data.game]
+                        embeddingsVoiceNameDisplay.innerHTML = window.embeddingsState.allData[voiceId].voiceName
+                        embeddingsVoiceGenderDisplay.innerHTML = window.embeddingsState.allData[voiceId].voiceGender
+                    }
+                }
+            }
+
+
+        } else {
+            window.embeddingsState.renderer.domElement.style.cursor = "default"
+            if (hoveredObject != undefined) {
+                const colour = window.embeddingsState.gendersOn ? hoveredObject.object.data.genderColour : hoveredObject.object.data.gameColour
+                hoveredObject.object.material.color.r = Math.min(1, colour.r/255)
+                hoveredObject.object.material.color.g = Math.min(1, colour.g/255)
+                hoveredObject.object.material.color.b = Math.min(1, colour.b/255)
+            }
+            if (window.embeddingsState.mouseIsDown && window.embeddingsState.clickedObject!=undefined) {
+                window.embeddingsState.clickedObject.object.material.emissive.setRGB(0,0,0)
+                window.embeddingsState.clickedObject = undefined
+
+                embeddingsVoiceGameDisplay.innerHTML = ""
+                embeddingsVoiceNameDisplay.innerHTML = ""
+                embeddingsVoiceGenderDisplay.innerHTML = ""
+            }
+        }
+
+        window.embeddingsState.renderer.render(scene, window.embeddingsState.sceneData.camera)
+    }
+    window.embeddingsState.isReady = true
+    window.embeddings_render()
+
+
+    window.toggleSprites = () => {
+        window.embeddingsState.spritesOn = !window.embeddingsState.spritesOn
+        window.embeddingsState.sceneData.sprites.forEach(sprite => {
+            sprite.material.visible = window.embeddingsState.spritesOn
+        })
+    }
+
+    window.toggleGenders = () => {
+        window.embeddingsState.gendersOn = !window.embeddingsState.gendersOn
+        window.embeddingsState.sceneData.points.forEach(point => {
+            const colour = window.embeddingsState.gendersOn ? point.data.genderColour : point.data.gameColour
+            point.material.color.r = Math.min(1, colour.r/255)
+            point.material.color.g = Math.min(1, colour.g/255)
+            point.material.color.b = Math.min(1, colour.b/255)
+        })
+    }
+    window.addEventListener("resize", () => {
+        if (window.embeddingsState.isOpen) {
+            window.embeddings_updateSize()
+        }
+    })
+}
+window.embeddings_updateSize = () => {
+    if (window.embeddingsState.isReady) {
+        window.embeddingsState.sceneData.camera.aspect = embeddingsSceneContainer.offsetWidth/embeddingsSceneContainer.offsetHeight
+        window.embeddingsState.sceneData.camera.updateProjectionMatrix()
+        window.embeddingsState.renderer.setSize(embeddingsSceneContainer.offsetWidth, embeddingsSceneContainer.offsetHeight)
+    }
+}
+
+
+embeddingsPreviewButton.addEventListener("click", () => {
+    if (window.embeddingsState.clickedObject) {
+
+        const voiceId = window.embeddingsState.clickedObject.object.data.voiceId
+        const gameId = window.embeddingsState.clickedObject.object.data.game
+        const modelsPathForGame = window.userSettings[`modelspath_${gameId}`]
+        const audioPreviewPath = `${modelsPathForGame}/${voiceId}.wav`
+
+        if (fs.existsSync(audioPreviewPath)) {
+            const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+                src: audioPreviewPath
+            }))
+            audioPreview.setSinkId(window.userSettings.base_speaker)
+        } else {
+            window.errorModal(window.i18n.VEMB_NO_PREVIEW)
+        }
+    } else {
+        window.errorModal(window.i18n.VEMB_SELECT_VOICE_FIRST)
+    }
+})
+embeddingsLoadButton.addEventListener("click", () => {
+    if (window.embeddingsState.clickedObject) {
+
+        const voiceId = window.embeddingsState.clickedObject.object.data.voiceId
+        const gameId = window.embeddingsState.clickedObject.object.data.game
+        const modelsPathForGame = window.userSettings[`modelspath_${gameId}`]
+        const modelPath = `${modelsPathForGame}/${voiceId}.pt`
+
+        if (fs.existsSync(modelPath)) {
+
+            window.changeGame(window.gameAssets[gameId])
+
+            // Simulate voice loading through the UI
+            let voiceName
+            window.games[gameId].models.forEach(model => {
+                model.variants.forEach(variant => {
+                    if (variant.voiceId==voiceId) {
+                        voiceName = model.voiceName
+                    }
+                })
+            })
+            const voiceButton = Array.from(voiceTypeContainer.children).find(button => button.innerHTML==voiceName)
+            voiceButton.click()
+            closeModal().then(() => {
+                generateVoiceButton.click()
+            })
+
+        } else {
+            window.errorModal(window.i18n.VEMB_NO_MODEL)
+        }
+    } else {
+        window.errorModal(window.i18n.VEMB_SELECT_VOICE_FIRST)
+    }
+})
+
+embeddingsKey.addEventListener("change", () => {
+    if (embeddingsKey.value=="embsKey_game" && window.embeddingsState.gendersOn) {
+        window.toggleGenders()
+    } else if (embeddingsKey.value=="embsKey_gender" && !window.embeddingsState.gendersOn) {
+        window.toggleGenders()
+    }
+})
+embeddingsMalesCkbx.addEventListener("change", () => window.computeEmbsAndDimReduction())
+embeddingsFemalesCkbx.addEventListener("change", () => window.computeEmbsAndDimReduction())
+embeddingsOtherGendersCkbx.addEventListener("change", () => window.computeEmbsAndDimReduction())
+embeddingsOnlyInstalledCkbx.addEventListener("change", () => window.computeEmbsAndDimReduction())
+embeddingsAlgorithm.addEventListener("change", () => window.computeEmbsAndDimReduction())
+
+
+window.computeEmbsAndDimReduction = (includeAllVoices=false) => {
+
+    const enabledGames = Array.from(embeddingsGamesListContainer.querySelectorAll("input"))
+        .map(elem => [elem.checked, elem.id.replace("embs_", "")])
+        .filter(checkedId => checkedId[0])
+        .map(checkedId => checkedId[1].replace("embs_", ""))
+
+    const enabledVoices = window.embeddingsState.voiceCheckboxes
+        .map(elem => [elem.checked, elem.id.replace("embsVoice_", "")])
+        .filter(checkedId => checkedId[0])
+        .map(checkedId => checkedId[1].replace("embsVoice_", ""))
+
+    if (enabledVoices.length<=2) {
+        return window.errorModal(window.i18n.EMBEDDINGS_NEED_AT_LEAST_3)
+    }
+
+
+    // Get together a list of voiceId->.wav path mappings
+    const mappings = []
+
+    if (includeAllVoices) {
+
+        Object.keys(window.games).forEach(gameId => {
+            const modelsPathForGame = window.userSettings[`modelspath_${gameId}`]
+
+            window.games[gameId].models.forEach(model => {
+                model.variants.forEach(variant => {
+                    const audioPreviewPath = `${modelsPathForGame}/${variant.voiceId}.wav`
+                    if (fs.existsSync(audioPreviewPath)) {
+                        mappings.push(`${variant.voiceId}=${audioPreviewPath}=${model.voiceName}=${variant.gender}=${gameId}`)
+                    }
+                })
+            })
+        })
+
+    } else {
+        Object.keys(window.embeddingsState.allData).forEach(voiceId => {
+            try {
+                const voiceMeta = window.embeddingsState.allData[voiceId]
+                const gender = voiceMeta.voiceGender.toLowerCase()
+
+                // Filter game-level voices
+                if (!enabledGames.includes(voiceMeta.gameId)) {
+                    return
+                }
+                // Filter out by voice
+                if (!enabledVoices.includes(voiceId)) {
+                    return
+                }
+                // Filter out data by gender
+                if (gender=="male" && !embeddingsMalesCkbx.checked) {
+                    return
+                }
+                if (gender=="female" && !embeddingsFemalesCkbx.checked) {
+                    return
+                }
+                if (gender=="other" && !embeddingsOtherGendersCkbx.checked) {
+                    return
+                }
+
+                const modelsPathForGame = window.userSettings[`modelspath_${voiceMeta.gameId}`]
+                let audioPreviewPath = `${modelsPathForGame}/${voiceId}.wav`
+
+                if (!fs.existsSync(audioPreviewPath)) {
+                    audioPreviewPath = ""
+                }
+
+                mappings.push(`${voiceId}=${audioPreviewPath}=${voiceMeta.voiceName}=${voiceMeta.voiceGender.toLowerCase()}=${voiceMeta.gameId}`)
+
+            } catch (e) {console.log(e)}
+        })
+    }
+
+    if (mappings.length<=2) {
+        return window.errorModal(window.i18n.EMBEDDINGS_NEED_AT_LEAST_3)
+    }
+
+
+    window.spinnerModal(window.i18n.VEMB_RECOMPUTING)
+
+    doFetch(`http://localhost:8008/computeEmbsAndDimReduction`, {
+        method: "Post",
+        body: JSON.stringify({
+            mappings: mappings.join("\n"),
+            onlyInstalled: embeddingsOnlyInstalledCkbx.checked,
+            algorithm: embeddingsAlgorithm.value.split("_")[1],
+            includeAllVoices
+        })
+    }).then(r=>r.text()).then(res => {
+        window.embeddingsState.data = {}
+        res.split("\n").forEach(voiceMetaAndCoords => {
+            const voiceId = voiceMetaAndCoords.split("=")[0]
+            const voiceName = voiceMetaAndCoords.split("=")[1]
+            const voiceGender = voiceMetaAndCoords.split("=")[2]
+            const gameId = voiceMetaAndCoords.split("=")[3]
+            const coords = voiceMetaAndCoords.split("=")[4].split(",").map(v => parseFloat(v))
+            window.embeddingsState.data[voiceId] = coords
+            if (includeAllVoices) {
+                window.embeddingsState.allData[voiceId] = {
+                    voiceName,
+                    voiceGender,
+                    coords,
+                    gameId
+                }
+            }
+        })
+        window.refreshEmbeddingsScenePoints()
+        closeModal(undefined, embeddingsContainer)
+
+    }).catch(e => {
+        console.log(e)
+        if (e.code =="ENOENT") {
+            closeModal(null, modalContainer).then(() => {
+                window.errorModal(window.i18n.ERR_SERVER)
+            })
+        }
+    })
+}
+
+embeddingsCloseHelpUI.addEventListener("click", () => {
+    embeddingsHelpUI.style.display = "none"
+})

javascript/i18n.js

@@ -0,0 +1,1070 @@
+
+window.i18n = {}
+
+window.i18n.setEnglish = () => {
+    window.i18n.SELECT_GAME = "Select Game"
+    window.i18n.SEARCH_VOICES = "Search voices..."
+    window.i18n.SELECT_VOICE = "Select voice"
+    window.i18n.SELECT_VOICE_TYPE = "Select Voice Type"
+    window.i18n.KEEP_SAMPLE = "Keep Sample"
+    window.i18n.GENERATE = "Generate"
+    window.i18n.GENERATE_VOICE = "Generate Voice"
+    window.i18n.RENAME_THE_FILE = "Rename the file"
+    window.i18n.DELETE_FILE = "Delete file"
+
+    window.i18n.PITCH_AND_ENERGY = "Pitch+Energy"
+    window.i18n.PITCH = "Pitch"
+    window.i18n.ENERGY = "Energy"
+    window.i18n.EMOTION = "Emotion"
+    window.i18n.DURATIONS = "Durations"
+    window.i18n.MANAGE = "Manage"
+    window.i18n.DEFAULT = "Default"
+    window.i18n.ENABLED = "Enabled"
+    window.i18n.ACTIONS = "Actions"
+    window.i18n.DESCRIPTION = "Description"
+    window.i18n.UNKNOWN = "Unknown"
+
+    window.i18n.VIEW_IS = "View:"
+    window.i18n.PITCH_IS = "Pitch:"
+    window.i18n.ENERGY_IS = "Energy:"
+    window.i18n.EMOTION_IS_ANGRY = "Emotion: Angry"
+    window.i18n.EMOTION_IS_HAPPY = "Emotion: Happy"
+    window.i18n.EMOTION_IS_SAD = "Emotion: Sad"
+    window.i18n.EMOTION_IS_SURPRISE = "Emotion: Surprise"
+    window.i18n.DURATION_IS = "Duration:"
+    window.i18n.EMOTION_IS = "Emotion:"
+    window.i18n.LENGTH = "Length:"
+    window.i18n.RESET_LETTER = "Reset Letter"
+    window.i18n.AUTO_REGEN = "Auto regenerate"
+    window.i18n.VOCODER = "Vocoder:"
+    window.i18n.BASE_LANGUAGE = "Base Language"
+    window.i18n.BASE_LANGUAGE_IS = "Base Language:"
+    window.i18n.USE_SR = "Use SR"
+    window.i18n.USE_SR_IS = "Use SR:"
+    window.i18n.USE_CLEANUP = "Use Clean-up"
+    window.i18n.USE_CLEANUP_IS = "Use Clean-up:"
+    window.i18n.USE_SR_TITLE = "Super-resolution (Hz) - SLOW ON CPU"
+    window.i18n.USE_SR_HINT = "Super-resolution improves the quality of your audio through Super-resolution of 22050Hz audio into 48000Hz audio. To be able to hear the difference, you need to make sure your ffmpeg settings don't then convert the audio back down to something low like 22050, in the post-processing. Keep the Hz setting to something higher like 48000 or 44100.<br><br>Also to note, this is a fairly slow process on the CPU, but it's pretty quick on the GPU, so I'd recommend switching on GPU usage if you have an NVIDIA card.<br><br>Hide this notice in the future?"
+    window.i18n.BASE_STYLE_EMB_IS = "Base Style:"
+    window.i18n.STYLE_EMB_IS = "Style:"
+    window.i18n.VARIANT_IS = "Variant:"
+
+    window.i18n.SEARCH_GAMES = "Search games..."
+    window.i18n.SEARCH_SETTINGS = "Search settings..."
+    window.i18n.SEARCH_N_VOICES = "Search _ voices..."
+    window.i18n.SEARCH_N_GAMES_WITH_N2_VOICES = "Search _1 games with _2 voices..."
+    window.i18n.RESET = "Reset"
+    window.i18n.AMPLIFY = "Amplify"
+    window.i18n.JITTER = "Jitter"
+    window.i18n.FLATTEN = "Flatten"
+    window.i18n.RAISE = "Raise"
+    window.i18n.LOWER = "Lower"
+    window.i18n.PACING = "Pacing"
+    window.i18n.OPEN = "Open"
+    window.i18n.DOWNLOAD = "Download"
+    window.i18n.VRAM_USAGE = "VRAM usage:"
+
+    window.i18n.SETTINGS = "Settings"
+    window.i18n.SETTINGS_GPU = "Use GPU (requires CUDA)"
+    window.i18n.SETTINGS_AUTOPLAY = "Autoplay generated audio"
+    window.i18n.SETTINGS_DEFAULT_HIFI = "Default to loading the HiFi vocoder on voice change, if available"
+    window.i18n.SETTINGS_KEEP_PACING = "Keep the same pacing value on new text generations"
+    window.i18n.SETTINGS_TOOLTIP = "Show the sliders tooltip"
+
+    window.i18n.SETTINGS_SHOW_DISCORD = "Show Discord status"
+    window.i18n.SETTINGS_DARKMODE = "Dark mode text prompt"
+    window.i18n.SETTINGS_PROMPTSIZE = "Text prompt font size"
+    window.i18n.SETTINGS_BG_FADE = "Background image fade opacity"
+    window.i18n.SETTINGS_AUTORELOADVOICES = "Auto-reload voices on files changes"
+    window.i18n.SETTINGS_KEEPEDITORSTATE = "Keep editor state on voice change"
+    window.i18n.SETTINGS_PITCHRANGEOVERRIDE = "Pitch range over-ride"
+    window.i18n.SETTINGS_OUTPUTJSON = "Output .json (needed for editing)"
+    window.i18n.SETTINGS_SEQNUMBERING = "Use sequential numbering for file names"
+    window.i18n.SETTINGS_SPACEPADDING = "Automatically pad text sequence with spaces (better quality, usually)"
+    window.i18n.SETTINGS_BASE_SPEAKER = "Base app output device"
+    window.i18n.SETTINGS_ALT_SPEAKER = "Alternate output device (ctrl+click play)"
+    window.i18n.SETTINGS_EXTERNALEDIT = "External program for editing audio"
+    window.i18n.SETTINGS_FFMPEG = "Use ffmpeg post-processing"
+    window.i18n.SETTINGS_FFMPEG_FORMAT = "Audio format (wav, mp3, etc)"
+    window.i18n.SETTINGS_FFMPEG_HZ = "Audio sample rate (Hz)"
+    window.i18n.SETTINGS_FFMPEG_PADSTART = "Silence padding start (ms)"
+    window.i18n.SETTINGS_FFMPEG_PADEND = "Silence padding end (ms)"
+    window.i18n.SETTINGS_FFMPEG_PITCHMULT = "Pitch multiplier"
+    window.i18n.SETTINGS_FFMPEG_TEMPO = "Tempo"
+    window.i18n.SETTINGS_FFMPEG_DEESSING = "De-essing"
+    window.i18n.SETTINGS_FFMPEG_BITDEPTH = "Audio bit depth"
+    window.i18n.SETTINGS_FFMPEG_NR = "Noise Reduction (db)"
+    window.i18n.SETTINGS_FFMPEG_NF = "Noise Floor (db)"
+    window.i18n.SETTINGS_FFMPEG_AMPLITUDE = "Amplitude multiplier"
+    window.i18n.SETTINGS_BATCH_JSON = "Output .json editor data for batch lines"
+    // window.i18n.SETTINGS_BATCH_FASTMODE = "Use fast mode for Batch synth (start next batch in parallel to current batch outputting via ffmpeg)"
+    // window.i18n.SETTINGS_BATCH_FASTMODE_MAX_PARALLELIZATIONS = "Maximum parallelizations of lines for Fast mode (lower this if running out of RAM)"
+    window.i18n.SETTINGS_BATCH_USEMULTIP = "Use multi-processing for batch mode ffmpeg output"
+    window.i18n.SETTINGS_BATCH_MULTIPCOUNT = "Number of processes (0 for cpu threads count -1)"
+    window.i18n.SETTINGS_MICROPHONE = "Microphone"
+    // window.i18n.SETTINGS_S2S_VOICE = "Speech-to-Speech voice"
+    window.i18n.SETTINGS_AUTOGENERATEVOICE = "Automatically generate voice"
+    window.i18n.SETTINGS_S2S_PREADJUST_PITCH = "Pre-adjust the input audio average pitch to match the xVASpeech model voice's"
+    window.i18n.SETTINGS_S2S_BGNOISE = "Remove background noise from microphone. You need to record a background noise clip first. (requires sox >= v14.4.2) "
+    window.i18n.SETTINGS_S2S_RECNOISE = "Record noise"
+    window.i18n.SETTINGS_S2S_BGNOISE_STRENGTH = "Noise removal strength (0.2-0.3 recommended)"
+    window.i18n.SETTINGS_VC_STRENGTH = "Voice Conversion strength (1-2 recommended)"
+    window.i18n.SETTINGS_MODELS_PATH = "models path"
+    window.i18n.SETTINGS_OUTPUT_PATH = "output path"
+    window.i18n.SETTINGS_RESET_SETTINGS = "Reset Settings"
+    window.i18n.SETTINGS_RESET_PATHS = "Reset Paths"
+    window.i18n.RESET_WHAT_PROMPT = "What would you like to reset?"
+    window.i18n.RESET_WHAT_TIP = "Shift+click the Reset button to reset all 3."
+    window.i18n.BATCH_METADATA_CONFIRM = "Please confirm the voice details"
+    window.i18n.BATCH_METADATA_TIP = "Select the voice in the main app, to pre-fill these"
+    window.i18n.SAVE_TO_CSV = "Save to CSV"
+
+    window.i18n.UPDATES_VERSION = "This app version: 1.0.0"
+    window.i18n.THIS_APP_VERSION = "This app version"
+    window.i18n.CHECK_FOR_UPDATES = "Check for updates now"
+    window.i18n.CANT_REACH_SERVER = "Can't reach server"
+    window.i18n.CHECKING_FOR_UPDATES = "Checking for updates..."
+    window.i18n.UPDATE_AVAILABLE = "Update available"
+    window.i18n.UPTODATE = "Up-to-date."
+    window.i18n.UPDATES_LOG = "Updates log:"
+    window.i18n.UPDATES_CHECK = "Check for updates now"
+
+    window.i18n.AVAILABLE = "Available"
+    window.i18n.PLUGINS = "Plugins"
+    window.i18n.PLUGINS_TRUSTED = "Download plugins only from trusted sources"
+    window.i18n.PLUGINSH_ENABLED = "Enabled"
+    window.i18n.PLUGINSH_ORDER = "Order"
+    window.i18n.PLUGINSH_NAME = "Plugin Name"
+    window.i18n.PLUGINSH_AUTHOR = "Author"
+    window.i18n.PLUGINSH_VERSION = "Plugin Version"
+    window.i18n.PLUGINSH_TYPE = "Type"
+    window.i18n.PLUGINSH_MINV = "Min App Version"
+    window.i18n.PLUGINSH_MAXV = "Max App Version"
+    window.i18n.PLUGINSH_DESCRIPTION = "Description"
+    window.i18n.PLUGINSH_PLUGINID = "Plugin Id"
+    window.i18n.PLUGINS_MOVEUP = "Move Up"
+    window.i18n.PLUGINS_MOVEDOWN = "Move Down"
+    window.i18n.PLUGINS_APPLY = "Apply"
+
+    window.i18n.APP_INFO = "App info"
+    window.i18n.APP_INFO_INSTR_1 = "For instructions on how to use the app, please watch"
+    window.i18n.APP_INFO_INSTR_2 = "this short video"
+    window.i18n.APP_INFO_INSTR_3 = "showcase on YouTube."
+    window.i18n.APP_INFO_INSTR_4 = "You can also view and/or contribute to the community guide on GitHub "
+    window.i18n.APP_INFO_INSTR_5 = "here"
+
+    window.i18n.KEYBOARD_REFERENCE = "Keyboard shortcuts reference"
+    window.i18n.KEYBOARD_ENTER = "Enter"
+    window.i18n.KEYBOARD_ENTER_DO = "Generate the audio"
+    window.i18n.KEYBOARD_ESCAPE = "Escape"
+    window.i18n.KEYBOARD_ESCAPE_DO = "Close modals and menus"
+    window.i18n.KEYBOARD_SPACE = "Space"
+    window.i18n.KEYBOARD_SPACE_DO = "Bring focus to the input textarea"
+    window.i18n.KEYBOARD_CTRLS = "Ctrl+S"
+    window.i18n.KEYBOARD_CTRLS_DO = "Keep sample"
+    window.i18n.KEYBOARD_CTRLSHIFTS = "Ctrl+Shift-S"
+    window.i18n.KEYBOARD_CTRLSHIFTS_DO = "Keep sample (but with naming prompt)"
+    window.i18n.KEYBOARD_YN = "Y/N"
+    window.i18n.KEYBOARD_YN_DO = "Yes/No options in prompt modals"
+    window.i18n.KEYBOARD_LR = "Left/Right arrows"
+    window.i18n.KEYBOARD_LR_DO = "Move left/right along which letter is focused"
+    window.i18n.KEYBOARD_SHIFT_LR = "Shift-Left/Right arrows"
+    window.i18n.KEYBOARD_SHIFT_LR_DO = "Create multi-letter selection range"
+    window.i18n.KEYBOARD_ALT_CTRL_LR = "Alt-Ctrl-Left/Right arrows"
+    window.i18n.KEYBOARD_ALT_CTRL_LR_DO = "Adjust width of letter selection"
+    window.i18n.KEYBOARD_UD = "Up/Down arrows"
+    window.i18n.KEYBOARD_UD_DO = "Move pitch up/down for the letter(s) selected"
+    window.i18n.KEYBOARD_CTRL_LR = "Ctrl+Left/Right arrows"
+    window.i18n.KEYBOARD_CTRL_LR_DO = "Move the sequence-wide pacing slider"
+    window.i18n.KEYBOARD_CTRL_UD = "Ctrl+Up/Down arrows"
+    window.i18n.KEYBOARD_CTRL_UD_DO = "Pitch increase/decrease buttons"
+    window.i18n.KEYBOARD_CTRLSHIFTUD = "Ctrl+Shift+Up/Down arrows"
+    window.i18n.KEYBOARD_CTRLSHIFTUD_DO = "Pitch amplify/flatten buttons"
+    window.i18n.KEYBOARD_CTRLENTER = "Ctrl+Enter"
+    window.i18n.KEYBOARD_CTRLENTER_DO = "Manually re-generate a line"
+    window.i18n.KEYBOARD_CTRLA = "Ctrl+A"
+    window.i18n.KEYBOARD_CTRLA_DO = "Select all editor sequence letters"
+
+    window.i18n.SUPPORT = "Support"
+    window.i18n.SUPPORT_LINK = "You can support 'xVASynth' development on patreon"
+    window.i18n.SUPPORT_THANKS = "Special thanks to all xVASynth supporters:"
+
+    window.i18n.SUPPORT_GAMES = "Search games..."
+
+    window.i18n.EULA_ACCEPT = "I accept the EULA"
+    window.i18n.EULA_CLOSE = "Close"
+
+    window.i18n.BATCH_SYNTHESIS = "Batch Synthesis"
+    window.i18n.BATCH_SIZE = "Batch Size"
+    window.i18n.BATCH_INSTR1 = `Place the .csv batch file(s) into the box below. The mandatory columns are "game_id", "voice_id", and "text", but you can also specify output filename/filepath under "out_path", pacing under "pacing", and vocoder under "vocoder" (Available options: 'hifi', 'quickanddirty', 'waveglow', 'waveglowBIG'). Click the "Generate sample" button to generate an example .csv file if you need one. Watch`
+    window.i18n.BATCH_INSTR2 = "this short video"
+    window.i18n.BATCH_INSTR3 = "for a demo and more instructions."
+    window.i18n.BATCH_GEN_SAMPLE = "Generate Sample"
+    window.i18n.BATCH_INSTRUCTIONS = "Instructions"
+    window.i18n.BATCH_DROPZONE = "Drag and drop .csv files here"
+
+    window.i18n.BATCHH_NUM = "#"
+    window.i18n.BATCHH_STATUS = "Status"
+    window.i18n.BATCHH_ACTIONS = "Actions"
+    window.i18n.BATCHH_GAME = "Game"
+    window.i18n.BATCHH_VOICE = "Voice"
+    window.i18n.BATCHH_TEXT = "Text or <i>VC content</i>"
+    window.i18n.BATCHH_VC_STYLE = "VC Style"
+    window.i18n.BATCHH_VOCODER = "Vocoder"
+    window.i18n.BATCHH_OUTPATH = "Out Path"
+    window.i18n.BATCHH_PACING = "Pacing"
+    window.i18n.BATCHH_PITCH_AMP = "Pitch Amp."
+    window.i18n.BATCHH_BASE_LANG = "Base lang"
+    window.i18n.BATCH_ABS_DIR_PLACEHOLDER = "Complete absolute directory path to output"
+
+    window.i18n.BATCH_CLEAR_DIR = "Clear out the directory first"
+    window.i18n.BATCH_SKIP = "Skip existing output"
+    window.i18n.BATCH_OUTPUTNUMERICALLY = "Output file names in numerical order"
+    window.i18n.BATCH_CURRENTLYDOING = "currently doing..."
+    window.i18n.BATCH_SYNTHESIZE = "Synthesize Batch"
+    window.i18n.BATCH_PAUSE = "Pause"
+    window.i18n.BATCH_STOP = "Stop"
+    window.i18n.BATCH_CLEAR = "Clear"
+    window.i18n.BATCH_OPENOUT = "Open Output"
+
+    window.i18n.S2S_RECORD_SAMPLE = "Record sample"
+    window.i18n.FEMALE = "Female"
+    window.i18n.MALE = "Male"
+    window.i18n.S2S_OTHER = "Other"
+    window.i18n.VC_ONLY_FOR_V3 = "Voice conversion only available for v3 models."
+
+
+    window.i18n.VW_INPUT_TEXTAREA_PLACEHOLDER = "Enter a sentence to use for generating preview samples of your crafted voice with the current embedding and proposed delta change"
+    window.i18n.CURRENT = "Current"
+    window.i18n.CURRENT_EMB = "Current Embedding"
+    window.i18n.CURRENT_DELTA = "Current Delta"
+    window.i18n.STRENGTH = "Strength"
+    window.i18n.APPLY_DELTA = "Apply Delta"
+    window.i18n.VW_REF_FILE_A = "Reference Audio File A:"
+    window.i18n.VW_REF_FILE_B = "Reference Audio File B:"
+    window.i18n.VW_BASE_MODEL = "Base Model (v3 models only)"
+    window.i18n.NAME_OF_YOUR_VOICE = "Name of your voice"
+    window.i18n.UNIQUE_ID_FOR_VOICE = "A unique identifier for your voice (eg: f4_nate)"
+    window.i18n.YOUR_NAME_FOR_CREDITS = "Your name for credits"
+
+
+
+
+
+    // Dynamic
+    window.i18n.SOMETHING_WENT_WRONG = "Something went wrong"
+    window.i18n.THERE_WAS_A_PROBLEM = "There was a problem"
+    window.i18n.ENTER_DIR_PATH = "Please enter a directory path"
+    window.i18n.SURE_RESET_SETTINGS = `Are you sure you'd like to reset your settings?`
+    window.i18n.SURE_RESET_PATHS = `Are you sure you'd like to reset your paths? This includes the paths for models, and output.`
+    window.i18n.LOAD_MODEL = "Load model"
+    window.i18n.LOAD_TARGET_MODEL = "Please load a target voice from the panel on the left, first."
+    window.i18n.NO_XVASPEECH_MODELS = "No FastPitch1.1 models are installed"
+    window.i18n.ONLY_WAV_S2S = "Only .wav files are supported for speech-to-speech file input at the moment."
+    window.i18n.NO_MODELS_IN = "No models in"
+    window.i18n.NO_MODELS_FOUND = "No models found"
+    window.i18n.MODEL_REQUIRES_VERSION = `This model requires app version`
+    window.i18n.OPEN_CONTAINING_FOLDER = "Open containing folder"
+    window.i18n.ADJUST_SAMPLE_IN_EDITOR = "Adjust sample in the editor"
+    window.i18n.ENTER_NEW_FILENAME_UNCHANGED_CANCEL = "Enter new file name, or submit unchanged to cancel."
+    window.i18n.EDIT_IN_EXTERNAL_PROGRAM = "Edit in external program"
+    window.i18n.FOLLOWING_PATH_NOT_VALID = "The following program path is not valid"
+    window.i18n.SPECIFY_EDIT_TOOL = "Specify your audio editing tool in the settings"
+    window.i18n.SURE_DELETE = "Are you sure you'd like to delete this file?"
+    window.i18n.LOADING_VOICE = "Loading voice"
+    window.i18n.ERR_SERVER = "There was an issue connecting to the python server.<br><br>Try again in a few seconds. If the issue persists, make sure localhost port 8008 is free, or send the server.log file to me on GitHub or Nexus."
+    window.i18n.ABOUT_TO_SAVE_FROM_N1_TO_N2_WITH_OPTIONS = `About to save file from _1 to _2 with options`
+    window.i18n.SAVING_AUDIO_FILE = "Saving the audio file..."
+    window.i18n.TEMP_FILE_NOT_EXIST = "The temporary file does not exist at this file path"
+    window.i18n.OUT_DIR_NOT_EXIST = "The output directory does not exist at this file path"
+    window.i18n.YOU_CAN_CHANGE_IN_SETTINGS = "You can change this in the settings."
+    window.i18n.FILE_EXISTS_ADJUST = `File already exists. Adjust the file name here, or submit without changing to overwrite the old file.`
+    window.i18n.ENTER_FILE_NAME = `Enter file name`
+    window.i18n.WAVEGLOW_NOT_FOUND = "WaveGlow model not found. Download it also (separate download), and place the .pt file in the models folder."
+    window.i18n.BATCH_MODEL_NOT_FOUND = "Model not found."
+    window.i18n.BATCH_DOWNLOAD_WAVEGLOW = "Download WaveGlow files separately if you haven't, or check the path in the settings."
+    window.i18n.ERR_LOADING_MODELS_FOR_GAME = "ERROR loading models for game"
+    window.i18n.ERR_LOADING_MODELS_FOR_GAME_WITH_FILENAME = "ERROR loading models for game _1 with filename:"
+    window.i18n.ERR_XVASPEECH_MODEL_VERSION = `This xVASpeech model needs minimum app version _1. Your app version:`
+    window.i18n.ERR_ARPABET_NOT_EXIST = `The following ARPAbet symbol does not exist: _1`
+
+    window.i18n.ENTER_VOICE_NAME = "Please enter a voice name"
+    window.i18n.ENTER_VOICE_ID = "Please enter a voice ID"
+    window.i18n.VOICE_CREATED_AT = "Voice successfully saved at the following location:<br><br>_1"
+    window.i18n.CONFIRM_DELETE_CRAFTED_VOICE = "Are you sure you'd like to delete the crafted voice '_1' at the following location?<br><br>_2"
+    window.i18n.SUCCESSFULLY_DELETED_CRAFTED_VOICE = "Successfully deleted the crafted voice model."
+    window.i18n.ENTER_VOICE_CRAFTING_STARTING_EMB = "Please provide a starting embedding. Drag and drop a .wav audio file over the 'Current Embedding' field below."
+
+    window.i18n.CHANGING_MODELS = "Changing models..."
+    window.i18n.CHANGING_DEVICE = "Changing device..."
+    window.i18n.PROCESSING_DATA = "Processing data..."
+    window.i18n.DELETING_FILE = "Deleting file"
+    window.i18n.DELETING_NEW_FILE = "Deleting new file"
+    window.i18n.FAILED = "Failed"
+    window.i18n.DONE = "Done"
+    window.i18n.READY = "Ready"
+    window.i18n.RUNNING = "Running"
+    window.i18n.PAUSED = "Paused"
+    window.i18n.PAUSE = "Pause"
+    window.i18n.PLAY = "Play"
+    window.i18n.EDIT = "Edit"
+    window.i18n.EDIT_IS = "Edit:"
+    window.i18n.RESUME = "Resume"
+    window.i18n.STOPPED = "Stopped"
+    window.i18n.SYNTHESIZING = "Synthesizing"
+    window.i18n.LINES = "lines"
+    window.i18n.LINE = "Line"
+    window.i18n.ERROR = "Error"
+    window.i18n.MISSING = "Missing"
+    window.i18n.INPUT = "Input"
+    window.i18n.OUTPUT = "Output"
+    window.i18n.OUTPUTTING = "Outputting"
+    window.i18n.SUBMIT = "Submit"
+    window.i18n.CLOSE = "Close"
+    window.i18n.YES = "Yes"
+    window.i18n.NO = "No"
+    window.i18n.VOICE = "voice"
+    window.i18n.VOICE_PLURAL = "voices"
+    window.i18n.NEW = "new"
+    window.i18n.PAGE = "Page:"
+    window.i18n.NEXT = "Next"
+    window.i18n.PREVIOUS = "Previous"
+    window.i18n.LOADING = "Loading"
+    window.i18n.MAY_TAKE_A_MINUTE = "May take a minute (but not much more)"
+    window.i18n.BUILDING_FASTPITCH = "Building FastPitch model"
+    window.i18n.LOADING_WAVEGLOW = "Loading WaveGlow model"
+    window.i18n.STARTING_PYTHON = "Starting up the python backend"
+    window.i18n.NOT_USING_GPU = "Not using GPU"
+
+    window.i18n.BATCH_CHANGING_MODEL_TO = "Changing voice model to"
+    window.i18n.BATCH_CHANGING_VOCODER_TO = "Changing vocoder to"
+    window.i18n.BATCH_OUTPUTTING_FFMPEG = `Outputting audio via ffmpeg...`
+
+    window.i18n.BATCH_ERR_NO_VOICES = "No voice models available in the app. Load at least one."
+    window.i18n.BATCH_ERR_GAMEID = "does not match any available games"
+    window.i18n.BATCH_ERR_VOICEID = "does not match any in the game"
+    window.i18n.BATCH_ERR_VOCODER1 = "does not exist. Available options"
+    window.i18n.BATCH_ERR_VOCODER2 = "(or leaving it blank)"
+    window.i18n.BATCH_ERR_CUDA_OOM = "CUDA OOM: There is not enough VRAM to run this. Try lowering the batch size, or shortening very long sentences."
+    window.i18n.BATCH_ERR_IN_PROGRESS = "Batch synthesis is in progress. Loading a model in the main app now would break things."
+    window.i18n.BATCH_ERR_EDIT = "Batch synthesis is in progress. Pause or stop it first to enable editor."
+    window.i18n.BATCH_ERR_SKIPPEDALL = "No records imported, but _1 were skipped as they already exist."
+
+    window.i18n.ERR_LOADING_PLUGIN = "Error loading plugin"
+    window.i18n.SUCCESSFULLY_INITIALIZED = "Successfully initialized"
+    window.i18n.FAILED_INIT_FOLLOWING = "Failed to initialize the following"
+    window.i18n.CHECK_SERVERLOG = "Check the server.log file for detailed error traces"
+    window.i18n.SUCC_NO_ACTIVE_PLUGINS = "Success. No plugins active."
+    window.i18n.APP_RESTART_NEEDED = "App restart is required for at least one of the plugins to take effect."
+    window.i18n.ERR_LOADING_CSS = "Error loading style file for plugin"
+    window.i18n.PLUGIN = "Plugin"
+    window.i18n.PLUGINS = "Plugins"
+    window.i18n.CANT_IMPORT_FILE_FOR_HOOK_TASK_ENTRYPOINT = "Cannot import _1 file for _2 _3 entry-point"
+    window.i18n.ONLY_JS = "Only JavaScript files are supported right now."
+    window.i18n.PLUGIN_RUN_ERROR = "Plugin run error at event"
+
+    window.i18n.MONDAY = "Monday"
+    window.i18n.TUESDAY = "Tuesday"
+    window.i18n.WEDNESDAY = "Wednesday"
+    window.i18n.THURSDAY = "Thursday"
+    window.i18n.FRIDAY = "Friday"
+    window.i18n.SATURDAY = "Saturday"
+    window.i18n.SUNDAY = "Sunday"
+
+    window.i18n.EMBEDDINGS = "Embeddings"
+    window.i18n.EMB_NAME = "Embedding Name"
+    window.i18n.EMB_DESCRIPTION = "Embedding description"
+    window.i18n.EMB_ID = "Embedding ID"
+    window.i18n.STYLE_EMB_ID = "Embedding ID (Write a short, descriptive, alpha-numerical ID you think will be unique)"
+    window.i18n.EMB_ID = "Emb ID"
+    window.i18n.STYLE_EMBEDDINGS = "Style Embeddings"
+    window.i18n.STYLE_EMB_WAVPATH = "Wav file path"
+    window.i18n.STYLE_EMB_WAVPATH_PLACEHOLDER = "Drag+drop or full file path"
+    window.i18n.ERROR_FILE_MUST_BE_WAV = "File type must be .wav"
+    window.i18n.ERROR_NEED_WAV_FILE = "Add a wav file path"
+    window.i18n.STYLE_EMB_VALUES = "Style embedding values"
+    window.i18n.ERROR_MISSING_FIELDS = "Missing values for the following fields: _1"
+    window.i18n.CONFIRM_DELETE_STYLE_EMB = "Are you sure you want to delete this style embedding forever?"
+
+
+    window.i18n.TOTD_1 = "You can right-click a voice on the left to hear a preview of the voice"
+    window.i18n.TOTD_2 = "You can right-click the microphone icon after a recording, to hear back the audio you recorded/inserted"
+    window.i18n.TOTD_3 = "There are a number of keyboard shortcuts you can use. Check the info tab for a reference"
+    window.i18n.TOTD_4 = "Check the community guide for tips for how to get the best quality out of the tool. This is linked in the info (i) menu"
+    window.i18n.TOTD_5 = "You can create a multi-letter selection in the editor by Ctrl+clicking several letters"
+    window.i18n.TOTD_6 = "You can shift-click the 'Keep Sample' button (or Ctrl+Shift+S) to first give your file a custom name before saving"
+    window.i18n.TOTD_7 = "You can alt+click editor letters to make a multi-letter selection for the entire word you click on"
+    window.i18n.TOTD_8 = "You can drag+drop multiple .csv or .txt files into batch mode"
+    window.i18n.TOTD_9 = "You can use .txt files in batch mode instead of .csv files, if you first click a voice in the main app to assign the lines to"
+    window.i18n.TOTD_10 = "If you have a compatible NVIDIA GPU, and CUDA installed, you can switch to the CPU+GPU installation. Using the GPU is much faster, especially for batch mode."
+    window.i18n.TOTD_11 = "The HiFi-GAN vocoder (v1 and v2 models) is normally the best quality, but you can also download and use WaveGlow vocoders, if you'd like."
+    window.i18n.TOTD_12 = "(v1 and v2 models) If the 'Keep editor state on voice changes' option is ticked on, you can generate a line using one voice, then switch to a different voice, and click the 'Generate Voice' button again to generate a line using the new voice, but using a similar speaking style to the first voice."
+    window.i18n.TOTD_13 = "If you set the 'Alternative Output device' to something other than the default device, you can Ctrl-click when playing audio, to have it play on a different speaker. You can couple this with something like Voicemeeter Banana split, to have the app speak for you over the microphone, for voice chat, or other audio recording."
+    window.i18n.TOTD_14 = "If you add the path to an audio editing program to the 'External Program for Editing audio' setting, you can open generated audio straight in that program in one click, from the output records on the main page"
+    window.i18n.TOTD_15 = "FFmpeg automatically directly applies a few different audio post processing tasks on the generated audio. This can include Hz resampling, silence padding to the start and/or end of the audio, bit depth, loudness, noise reduction, de-essing, pitch and tempo modifiers, and different audio formats. Play with these to get the best quality for a particular voice"
+    window.i18n.TOTD_16 = "You can tick on the 'Fast mode' for batch mode to parallelize the audio generation and the audio output (via ffmpeg for example)"
+    window.i18n.TOTD_17 = "You can enable multiprocessing for ffmpeg file output in batch mode, to speed up the output process. This is especially useful if you use a large batch size, and your CPU has plenty of threads. This can be used together with Fast Mode."
+    window.i18n.TOTD_18 = "If you're having trouble formatting a .csv file for batch mode, you can change the delimiter in the settings to something else (for example a pipe symbol '|')"
+    window.i18n.TOTD_19 = "You can change the folder location of your output files, as well as the models. I'd recommend keeping your model files on an SSD, to reduce the loading time."
+    window.i18n.TOTD_20 = "Use the voice embeddings search menu to get a 3D visualisation of all the voices in the app (including some 'officially' trained voices not downloaded yet). You can use this as a reference for voice similarly search, to see what other voices there are, which sound similar to a particular voice."
+    window.i18n.TOTD_21 = "You can right click on the points in the 3D voice embeddings visualisation, to hear a preview of that voice. This will only work for the voices you have installed, locally."
+    window.i18n.TOTD_22 = "The app is customisable via third-party plugins. Plugins can be managed from the plugins menu, and they can change, or add to the front end app functionality/looks (the UI), as well as the python back-end (the machine learning code). If you're interested in developing such a plugin, there is a full developer reference on the GitHub wiki, here: https://github.com/DanRuta/xvasynth-community-guide"
+    window.i18n.TOTD_23 = "If you log into nexusmods.com from within the app, you can check for new and updated voice models on your chosen Nexus pages. You can also endorse these, as well as any plugins configured with a nexus link. If you have a premium membership for the Nexus, you can also download (or batch download) all available voices, and have them installed automatically."
+    window.i18n.TOTD_24 = "You can manage the list of Nexus pages to check for voice models by clicking the 'Manage Repos' button in the Nexus menu, or by editing the repositories.txt file"
+    window.i18n.TOTD_25 = "You can enable/disable error sounds in the settings. You can also pick a different sound, if you'd prefer something else"
+    window.i18n.TOTD_26 = "You can resize the window by dragging one of the bottom corners"
+    window.i18n.TOTD_27 = "You can right-click game buttons in the nexus window 'Games' list and voice embeddings 'Games' list, to de-select all other games apart from the one you right-clicked"
+    window.i18n.TOTD_28 = "With v3 models, you can change the default speaking style of your voice by creating an embedding for it. You do so by drag+dropping an example audio file (usually from the same original voice) into the Management menu."
+    window.i18n.TOTD_29 = "The v3 models don't pre-generate pitch or energy values. Instead, the values in the editor are multipliers rather than absolute values. So initially, tney are set to 1, and you can CHANGE what they are rather than setting values like for v1 and v2 models."
+    window.i18n.TOTD_30 = "To get the absolute highest quality from an audio file, you should enable the 'Use SR' option, to run super-resolution from the default 22050Hz into 48000Hz. It's best to use the GPU mode for this, else it can be quite slow. You also need to make sure that you didn't set the ffmpeg Hz post-processing value to something low like 22050, else you won't hear the benefits."
+    window.i18n.TOTD_31 = "With v3 models, you can right click the sliders editor to open the context menu, where you can select to copy the final symbol sequence to clipboard."
+    window.i18n.TOTD_32 = "You can use the Ctrl+Enter shortcut to manually kick offf re-generating a line."
+
+    window.i18n.TOTD_NO_UNSEEN = "There are no unseen tips left to show. Untick the 'Only show unseen tips' setting to show all tips."
+
+
+    window.i18n.LINES_PER_SECOND = "lines per second"
+    window.i18n.ETA_FINISHED = "Estimated time until finished:"
+    window.i18n.LOGGED_IN_AS = "Logged in as: "
+    window.i18n.GAMES = "Games"
+    window.i18n.MODELS = "Models"
+    window.i18n.SHOW_NEW_UPDATED = "Show only new/updated"
+    window.i18n.CHECK_NOW = "Check now"
+    window.i18n.MANAGE_REPOS = "Manage repos"
+    window.i18n.LOG_IN = "Log in"
+    window.i18n.LOG_OUT = "Log out"
+    window.i18n.NAME = "Name"
+    window.i18n.AUTHOR = "Author"
+    window.i18n.VERSION = "Version"
+    window.i18n.DATE = "Date"
+    window.i18n.TYPE = "Type"
+    window.i18n.NOTES = "Notes"
+    window.i18n.DOWNLOADING = "Downloading:"
+    window.i18n.INSTALLING = "Installing:"
+    window.i18n.FINISHED = "Finished:"
+    window.i18n.DOWNLOAD_ALL = "Download All"
+    window.i18n.REPOSITORIES = "Repositories"
+    window.i18n.ADD = "Add"
+    window.i18n.REMOVE = "Remove"
+    window.i18n.V_EMB_VIS = "Voice embeddings visualiser"
+    window.i18n.VOICES = "Voices"
+    window.i18n.SHOW = "Show"
+    window.i18n.GAME = "Game"
+    window.i18n.GENDER = "Gender"
+    window.i18n.GENDER_IS = "Gender:"
+    window.i18n.GAME_IS = "Game:"
+    window.i18n.PREVIEW = "Preview"
+    window.i18n.LOAD = "Load"
+
+    window.i18n.VOICE_NAME = "Voice Name"
+    window.i18n.VOICE_NAME_IS = "Voice Name:"
+
+    window.i18n.VEMB_INSTR_1 = "Left click drag to rotate"
+    window.i18n.VEMB_INSTR_2 = "Right click drag to pan"
+    window.i18n.VEMB_INSTR_3 = "Mouse wheel scroll to zoom"
+    window.i18n.VEMB_INSTR_4 = "Left click on voice to select"
+    window.i18n.VEMB_INSTR_5 = "Right click on voice to play sample"
+
+    window.i18n.MALES = "Males"
+    window.i18n.FEMALES = "Females"
+    window.i18n.OTHER = "Other"
+
+    window.i18n.SHOW_ONLY_INSTALED = "Show only installed voices"
+    window.i18n.KEY_IS = "Key:"
+    window.i18n.ALGORITHM = "Algorithm"
+
+    window.i18n.TOTD = "Tip of the day"
+    window.i18n.TOTD_SHOW = "Show tip of the day"
+    window.i18n.TOTD_SHOW_UNSEEN = "Only show unseen tips"
+    window.i18n.TOTD_PREV_TIP = "Previous tip"
+    window.i18n.TOTD_NEXT_TIP = "Next tip"
+
+    window.i18n.ENDORSE = "Endorse"
+    window.i18n.GET_MORE_VOICES = "Get more voices"
+
+    window.i18n.CURR_INSTALL = "Current installation:"
+    window.i18n.CHANGE_TO_GPU = "Change to CPU+GPU"
+    window.i18n.CHANGE_TO_CPU = "Change to CPU"
+    window.i18n.USE_SOUND_ERR = "Use sound for errors"
+    window.i18n.ERR_SOUNDFILE = "Error sound file"
+    window.i18n.SHOW_NOW = "Show now"
+    window.i18n.SETTINGS_PLAYCHANGEDAUDIO = "Play only changed audio, when regenerating"
+    window.i18n.SETTINGS_PREAPPLY_FFMPEG = "(recommended) Pre-apply ffmpeg effects to the preview sample"
+    window.i18n.SETTINGS_USE_NR = "Use noise reduction (recommended when using SR)"
+    window.i18n.SETTINGS_DOUBLE_AMP_DISPLAY = "Also display amplitude setting in the editor"
+    window.i18n.SETTINGS_CSV_DELIMITER = "CSV delimiter"
+    window.i18n.SETTINGS_PAGINATION_SIZE_BATCH = "Batch pagination size"
+    window.i18n.SETTINGS_PAGINATION_SIZE_ARPABET = "ARPAbet pagination size"
+    window.i18n.SETTINGS_MAX_FILENAME_LENGTH = "Maximum filename characters (trimming for maximum windows filepath length)"
+    window.i18n.SETTINGS_CLEAR_TEXT_AFTER_GENERATION = "Clear the text input after generation"
+    window.i18n.SETTINGS_GROUP_VOICEID = "Group voices by voiceId and vocoder in preprocessing to minimize model switching"
+    window.i18n.SETTINGS_GROUP_VOCODER = "Also do a secondary group by the vocoder - can take long to do with big files (100k+ lines)"
+    window.i18n.SETTING_HIGHLIGHT_ONLY_MODELS_V = "Highlight only models with at least this version"
+    window.i18n.SETTING_OUTPUTFILES_PAGINATION = "Output records pagination size"
+
+
+    window.i18n.SEARCH_OUTPUT = "Search output file names..."
+    window.i18n.SEARCH_OUTPUT_PROMPT = "Search prompts..."
+    window.i18n.DELETE = "Delete"
+    window.i18n.DELETE_ALL = "Delete all"
+    window.i18n.DELETE_ALL_FILES_CONFIRM = "Are you sure you'd like to delete all files for this voice? This will delete all _1 files in the following output directory:<br>_2"
+    window.i18n.DELETE_ALL_FILES_ERR_NO_FILES = "There are no files in the following output directory:<br>_1"
+    window.i18n.SORT_BY = "Sort by"
+    window.i18n.ASCENDING = "Ascending"
+    window.i18n.DESCENDING = "Descending"
+    window.i18n.TIME = "Time"
+
+    window.i18n.ERR_LOGGING_INTO_NEXUS = "Error attempting to log into nexusmods"
+    window.i18n.LOGGING_INTO_NEXUS = "Logging into nexusmods (check your browser)..."
+    window.i18n.NEXUS_PREMIUM = "Nexus requires premium membership for using their API for file downloads"
+    window.i18n.NEXUS_ORIG_ERR = "Original error message"
+    window.i18n.FAILED_DOWNLOAD = "Failed to download"
+    window.i18n.DONE_INSTALLING = "Done installing"
+    window.i18n.CHECKING_NEXUS = "Checking nexusmods.com..."
+    window.i18n.NEXUS_NOT_DOWNLOADED_MOD = "You need to first download something from this repo to be able to endorse it."
+    window.i18n.NEXUS_TOO_SOON_AFTER_DOWNLOAD = "Nexus requires you to wait at least 15 mins (at the time of writing) before you can endorse."
+    window.i18n.NEXUS_IS_OWN_MOD = "Nexus does not allow you to rate your own content."
+    window.i18n.YOURS = "Yours"
+    window.i18n.NEXUS_ENTER_LINK = "Enter the nexusmods.com link to use as a repository"
+    window.i18n.NEXUS_LINK_EXISTS = "This link already exists."
+    window.i18n.ERROR_FROM_NEXUS = "<h3>Error using Nexus API. Their response:</h3> <br>_1"
+
+    window.i18n.VEMB_VOICE_NOT_ENABLED = "This voice is not enabled"
+    window.i18n.VEMB_NO_PREVIEW = "No preview audio file available"
+    window.i18n.VEMB_SELECT_VOICE_FIRST = "Select a voice from the scene below first."
+    window.i18n.VEMB_NO_MODEL = "No model file available. Download it if you haven't already."
+    window.i18n.VEMB_RECOMPUTING = "Re-computing embeddings and dimensionality reduction on voices. May take a minute the first time, subsequent runs should be instant."
+
+    window.i18n.SETTINGS_FOR_PLUGIN = "Settings for plugin: <i>_1</i>"
+    window.i18n.EMBEDDINGS_NEED_AT_LEAST_3 = "You need at least 3 voices to run dimensionality reduction for the plot"
+
+
+
+    window.i18n.ARPABET_ERROR_BAD_SYMBOLS = "Found non-ARPAbet symbols: _1"
+    window.i18n.ARPABET_ERROR_EMPTY_INPUT = "Words or ARPAbet symbols can't be left empty"
+    window.i18n.PAGINATION_X_OF_Y = "_1 of _2"
+    window.i18n.ARPABET_CONFIRM_ENABLE_ALL = "Are you sure you'd like to enable ALL words for the following dictionary?<br><br><i>_1</i>"
+    window.i18n.ARPABET_CONFIRM_DISABLE_ALL = "Are you sure you'd like to disable ALL words for the following dictionary?<br><br><i>_1</i>"
+    window.i18n.ARPABET_CONFIRM_DELETE_WORD = "Are you sure you'd like to delete the following word?<br><br><i>_1</i>"
+    window.i18n.ARPABET_CONFIRM_SAME_WORD = "The word '_1' already exists in the following dictionaries:<br><br><i>_2</i><br><br>Are you sure you'd like to add it?"
+
+    window.i18n.ONLY_ENABLED = "Only enabled"
+
+    window.i18n.DICTIONARIES = "Dictionaries"
+    window.i18n.CANCEL = "Cancel"
+    window.i18n.START = "Start"
+    window.i18n.SAVE = "Save"
+    window.i18n.WORDS = "Words"
+    window.i18n.WORD_IS = "Word:"
+    window.i18n.WORD = "Word"
+    window.i18n.REFERENCE = "Reference"
+    window.i18n.SEARCH_WORDS = "Search words..."
+    window.i18n.ENABLE_ALL = "Enable All"
+    window.i18n.DISABLE_ALL = "Disable All"
+    window.i18n.PREV = "Prev"
+    window.i18n.LOADING_DICTIONARIES = "Loading ARPAbet dictionaries..."
+
+    window.i18n.ALL = "All"
+    window.i18n.MOD_NAME = "Mod name"
+    window.i18n.MOD_TITLE = "Mod title"
+    window.i18n.SEARCH_NEXUS = "Search Nexus"
+    window.i18n.MOD_REPOS_USED = "Mod repos used"
+    window.i18n.LINK = "Link"
+    window.i18n.ENDORSEMENTS = "Endorsements"
+    window.i18n.DOWNLOADS = "Downloads"
+
+    window.i18n.CONFIRM = "Confirm"
+    window.i18n.GAME_ID = "Game ID"
+    window.i18n.VOICE_ID = "Voice ID"
+    window.i18n.VOICE_ID_IS = "Voice ID:"
+    window.i18n.APP_VERSION_IS = "App version:"
+    window.i18n.MODEL_VERSION_IS = "Model version:"
+    window.i18n.MODEL_TYPE_IS = "Model type:"
+    window.i18n.LANGUAGE_IS = "Language:"
+    window.i18n.TRAINED_BY_IS = "Trained by:"
+    window.i18n.LICENSE_IS = "License:"
+
+    window.i18n.X_WORKSHOP_VOICES_INSTALLED = "_1 workshop voices installed"
+    window.i18n.WORKSHOP_GAMES_NOT_RECOGNISED = "The following workshop games were not recognised. Do you have the asset file installed?<i>_1</i>"
+
+    window.i18n.YOU_MUST_BE_LOGGED_IN = "You must be logged in to check what voices there are available on the nexus."
+    window.i18n.JOIN_DISCORD = "Join xVASynth server"
+
+    window.i18n.GETTING_SPEAKER_EMBEDDING = "Getting speaker embedding..."
+
+    window.i18n.INFO = "Info"
+    window.i18n.VOICE_CRAFTING_WORKBENCH = "Voice Crafting Workbench"
+    window.i18n.WORKBENCH = "Workbench"
+    window.i18n.FROM_FILE_IS_DRAG_N_DROP = "From file: (Drag and drop a .wav file)"
+    window.i18n.FROM_FILE_IS_FILEPATH = "From file: _1"
+
+
+    window.i18n.BATCH_CHANGE_DELIMITER = "The .csv delimiter is not found in the data. The delimiter in the settings is '_1', but the one in the .csv file is potentially '_2'. Do you want to change the delimiter used, and try again using this?"
+    window.i18n.BATCH_TOCSV_DONE = "Saved all lines to csv file at:"
+    window.i18n.PAGINATION_TOTAL_OF = "of _1"
+
+
+    window.i18n.VC_TOO_SHORT = "Recorded sample is too short and/or empty"
+
+    window.i18n.MODEL_INSTALL_DRAGDROP_INCOMPLETE = "Some of the loose files given were not complete models. Each model needs at least a .json file and a .pt file. Loose model files not complete:<br><br>_1"
+    window.i18n.MODEL_INSTALL_DRAGDROP_SUCCESS = "_1 models installed successfully. "
+    window.i18n.MODEL_INSTALL_DRAGDROP_FAILED = "_1 models failed to install:<br><br>_2"
+
+    // Useful during developing, to see if there are any strings left un-i18n-ed
+    // Object.keys(window.i18n).forEach(key => {
+    //     if (!["setEnglish", "updateUI"].includes(key)) {
+    //         window.i18n[key] = ""
+    //     }
+    // })
+}
+
+
+window.i18n.updateUI = () => {
+
+
+
+    i18n_voiceInfo_name.innerHTML = window.i18n.VOICE_NAME_IS
+    i18n_voiceInfo_id.innerHTML = window.i18n.VOICE_ID_IS
+    i18n_voiceInfo_gender.innerHTML = window.i18n.GENDER_IS
+    i18n_voiceInfo_appVersion.innerHTML = window.i18n.APP_VERSION_IS
+    i18n_voiceInfo_modelVersion.innerHTML = window.i18n.MODEL_VERSION_IS
+    i18n_voiceInfo_modelType.innerHTML = window.i18n.MODEL_TYPE_IS
+    i18n_voiceInfo_lang.innerHTML = window.i18n.LANGUAGE_IS
+    i18n_voiceInfo_author.innerHTML = window.i18n.TRAINED_BY_IS
+    i18n_voiceInfo_license.innerHTML = window.i18n.LICENSE_IS
+
+
+    i18n_nexusRepos_mod_name.innerHTML = window.i18n.MOD_NAME
+    nexusReposSearchBar.placeholder = window.i18n.MOD_TITLE
+    i18n_nexusRepos_all.innerHTML = window.i18n.ALL
+    searchNexusButton.innerHTML = window.i18n.SEARCH_NEXUS
+    i18n_nexusRepos_game.innerHTML = window.i18n.GAME_IS
+    i18n_nexusRepos_modReposUsed.innerHTML = window.i18n.MOD_REPOS_USED
+
+    i18n_nexus_searchh_add.innerHTML = window.i18n.ADD
+    i18n_nexus_searchh_link.innerHTML = window.i18n.LINK
+    i18n_nexus_searchh_game.innerHTML = window.i18n.GAME
+    i18n_nexus_searchh_name.innerHTML = window.i18n.NAME
+    i18n_nexus_searchh_author.innerHTML = window.i18n.AUTHOR
+    i18n_nexus_searchh_endorsements.innerHTML = window.i18n.ENDORSEMENTS
+    i18n_nexus_searchh_downloads.innerHTML = window.i18n.DOWNLOADS
+
+    i18n_nexus_reposUsedh_link.innerHTML = window.i18n.LINK
+    i18n_nexus_reposUsedh_game.innerHTML = window.i18n.GAME
+    i18n_nexus_reposUsedh_name.innerHTML = window.i18n.NAME
+    i18n_nexus_reposUsedh_author.innerHTML = window.i18n.AUTHOR
+    i18n_nexus_reposUsedh_endorsements.innerHTML = window.i18n.ENDORSEMENTS
+    i18n_nexus_reposUsedh_downloads.innerHTML = window.i18n.DOWNLOADS
+    i18n_nexus_reposUsedh_remove.innerHTML = window.i18n.REMOVE
+
+
+
+    i18n_arpabet_dictionaries.innerHTML = window.i18n.DICTIONARIES
+    i18n_arpabet_words.innerHTML = window.i18n.WORDS
+    i18n_arpabet_reference.innerHTML = window.i18n.REFERENCE
+    arpabet_word_search_input.placeholder = window.i18n.SEARCH_WORDS
+    i18n_arpabet_ckbx_only_enabled.placeholder = window.i18n.ONLY_ENABLED
+    i18n_arpabet_word_is.innerHTML = window.i18n.WORD_IS
+    arpabet_save.innerHTML = window.i18n.SAVE
+    i18n_arpabetWordsListh_word.innerHTML = window.i18n.WORD
+    i18n_arpabetWordsListh_delete.innerHTML = window.i18n.DELETE
+    arpabet_enableall_button.innerHTML = window.i18n.ENABLE_ALL
+    arpabet_disableall_button.innerHTML = window.i18n.DISABLE_ALL
+    arpabet_prev_btn.innerHTML = window.i18n.PREV
+    arpabet_next_btn.innerHTML = window.i18n.NEXT
+
+
+    selectedGameDisplay.innerHTML = window.i18n.SELECT_GAME
+    voiceSearchInput.placeholder = window.i18n.SEARCH_VOICES
+    titleName.innerHTML = window.i18n.SELECT_VOICE_TYPE
+    generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE
+    keepSampleButton.innerHTML = window.i18n.KEEP_SAMPLE
+
+    i18n_seq_edit_edit.innerHTML = window.i18n.EDIT_IS
+    i18n_seq_edit_view.innerHTML = window.i18n.VIEW_IS
+    i18n_pitch.innerHTML = window.i18n.PITCH_IS
+    i18n_energy.innerHTML = window.i18n.ENERGY_IS
+    i18n_duration.innerHTML = window.i18n.DURATION_IS
+    i18n_emotion.innerHTML = window.i18n.EMOTION_IS
+    i18n_emotion_is.innerHTML = window.i18n.EMOTION_IS
+    seq_edit_view_pitch_energy.innerHTML = window.i18n.PITCH_AND_ENERGY
+    seq_edit_view_pitch.innerHTML = window.i18n.PITCH
+    seq_edit_view_energy.innerHTML = window.i18n.ENERGY
+    seq_edit_view_emAngry.innerHTML = window.i18n.EMOTION_IS_ANGRY
+    seq_edit_view_emHappy.innerHTML = window.i18n.EMOTION_IS_HAPPY
+    seq_edit_view_emSad.innerHTML = window.i18n.EMOTION_IS_SAD
+    seq_edit_view_emSurprise.innerHTML = window.i18n.EMOTION_IS_SURPRISE
+    seq_edit_edit_pitch.innerHTML = window.i18n.PITCH
+    seq_edit_edit_energy.innerHTML = window.i18n.ENERGY
+    seq_edit_edit_emotion.innerHTML = window.i18n.EMOTION
+
+    i18n_vramUsage.innerHTML = window.i18n.VRAM_USAGE
+    i18n_length.innerHTML = window.i18n.LENGTH
+    resetLetter_btn.innerHTML = window.i18n.RESET_LETTER
+    i18n_autoregen.innerHTML = window.i18n.AUTO_REGEN
+    i18n_vocoder.innerHTML = window.i18n.VOCODER
+    i18n_use_SR.innerHTML = window.i18n.USE_SR_IS
+    i18n_batch_useSR.innerHTML = window.i18n.USE_SR
+    i18n_use_SR.title = window.i18n.USE_SR_TITLE
+    i18n_use_cleanup.innerHTML = window.i18n.USE_CLEANUP_IS
+    i18n_batch_useCleanUp.innerHTML = window.i18n.USE_CLEANUP
+    i18n_base_lang.innerHTML = window.i18n.BASE_LANGUAGE_IS
+    i18n_style_emb_is.innerHTML = window.i18n.STYLE_EMB_IS
+    i18n_style.innerHTML = window.i18n.STYLE_EMB_IS
+    i18n_base_style_emb_is.innerHTML = window.i18n.BASE_STYLE_EMB_IS
+    default_opt_style_emb.innerHTML = window.i18n.DEFAULT
+    style_emb_manage_btn.innerHTML = window.i18n.MANAGE
+
+    batch_paginationPrev.innerHTML = window.i18n.PREVIOUS
+    main_paginationPrev.innerHTML = window.i18n.PREVIOUS
+    batch_paginationNext.innerHTML = window.i18n.NEXT
+    main_paginationNext.innerHTML = window.i18n.NEXT
+    i18n_page.innerHTML = window.i18n.PAGE
+    i18n_page_main.innerHTML = window.i18n.PAGE
+    i18n_batchLPS.innerHTML = window.i18n.LINES_PER_SECOND
+    i18n_etaFinished.innerHTML = window.i18n.ETA_FINISHED
+    nexusNameDisplay.innerHTML = window.i18n.LOGGED_IN_AS
+    i18n_games.innerHTML = window.i18n.GAMES
+    nexusGamesListEnableAllBtn.innerHTML = window.i18n.ENABLE_ALL
+    nexusGamesListDisableAllBtn.innerHTML = window.i18n.DISABLE_ALL
+    i18n_models.innerHTML = window.i18n.MODELS
+    i18n_showNewUpdated.innerHTML = window.i18n.SHOW_NEW_UPDATED
+    nexusCheckNow.innerHTML = window.i18n.CHECK_NOW
+    nexusManageReposButton.innerHTML = window.i18n.MANAGE_REPOS
+    nexusLogInButton.innerHTML = window.i18n.LOG_IN
+    i18n_nexush_name.innerHTML = window.i18n.NAME
+    i18n_nexush_author.innerHTML = window.i18n.AUTHOR
+    i18n_nexush_version.innerHTML = window.i18n.VERSION
+    i18n_nexush_date.innerHTML = window.i18n.DATE
+    i18n_nexush_type.innerHTML = window.i18n.TYPE
+    i18n_nexush_notes.innerHTML = window.i18n.NOTES
+    i18n_nexusDownloading.innerHTML = window.i18n.DOWNLOADING
+    i18n_nexusInstalling.innerHTML = window.i18n.INSTALLING
+    i18n_nexusFinished.innerHTML = window.i18n.FINISHED
+    nexusDownloadAllBtn.innerHTML = window.i18n.DOWNLOAD_ALL
+    i18n_repositories.innerHTML = window.i18n.REPOSITORIES
+
+
+
+    i18n_settings_curr_install.innerHTML = window.i18n.CURR_INSTALL
+    setting_change_installation.innerHTML = window.i18n.CHANGE_TO_GPU
+    i18n_settings_useSound.innerHTML = window.i18n.USE_SOUND_ERR
+    i18n_settings_err_soundfile.innerHTML = window.i18n.ERR_SOUNDFILE
+    i18n_settings_showTOTD.innerHTML = window.i18n.TOTD_SHOW
+    setting_btnShowTOTD.innerHTML = window.i18n.SHOW_NOW
+    i18n_settings_unseenTOTD.innerHTML = window.i18n.TOTD_SHOW_UNSEEN
+    i18n_settings_playChangedAudio.innerHTML = window.i18n.SETTINGS_PLAYCHANGEDAUDIO
+    // i18n_setting_ffmpeg_preapply.innerHTML = window.i18n.SETTINGS_PREAPPLY_FFMPEG
+    i18n_setting_useNR.innerHTML = window.i18n.SETTINGS_USE_NR
+    i18n_settings_doubleAmpDisplay.innerHTML = window.i18n.SETTINGS_DOUBLE_AMP_DISPLAY
+    i18n_settings_csv_delimiter.innerHTML = window.i18n.SETTINGS_CSV_DELIMITER
+    i18n_settings_paginationSize.innerHTML = window.i18n.SETTINGS_PAGINATION_SIZE_BATCH
+    i18n_settings_arpabetPagination.innerHTML = window.i18n.SETTINGS_PAGINATION_SIZE_ARPABET
+    i18n_settings_max_filename_chars.innerHTML = window.i18n.SETTINGS_MAX_FILENAME_LENGTH
+    i18n_settings_clear_text_after_synth.innerHTML = window.i18n.SETTINGS_CLEAR_TEXT_AFTER_GENERATION
+    i18n_settings_groupVoiceID.innerHTML = window.i18n.SETTINGS_GROUP_VOICEID
+    i18n_settings_groupVocoder.innerHTML = window.i18n.SETTINGS_GROUP_VOCODER
+
+
+    voiceSamplesSearch.placeholder = window.i18n.SEARCH_OUTPUT
+    voiceSamplesSearchPrompt.placeholder = window.i18n.SEARCH_OUTPUT_PROMPT
+    i18n_sortByOutput.innerHTML = window.i18n.SORT_BY
+    voiceRecordsOrderByButton.innerHTML = window.i18n.NAME
+    voiceRecordsOrderByOrderButton.innerHTML = window.i18n.ASCENDING
+    voiceRecordsDeleteAllButton.innerHTML = window.i18n.DELETE_ALL
+
+    i18n_pluginsh_endorse.innerHTML = window.i18n.ENDORSE
+
+    i18n_vembVis.innerHTML = window.i18n.V_EMB_VIS
+    i18n_games_vemb.innerHTML = window.i18n.GAMES
+    i18n_voices.innerHTML = window.i18n.VOICES
+    i18n_vembShow.innerHTML = window.i18n.SHOW
+    i18n_vembName.innerHTML = window.i18n.NAME
+    i18n_vembGame.innerHTML = window.i18n.GAME
+    i18n_vembGender.innerHTML = window.i18n.GENDER
+    embeddingsSearchBar.placeholder = window.i18n.SEARCH_VOICES
+    nexusSearchBar.placeholder = window.i18n.SEARCH_VOICES
+    i18n_voiceName.innerHTML = window.i18n.VOICE_NAME_IS
+    i18n_genderIs.innerHTML = window.i18n.GENDER_IS
+    i18n_vemb_game.innerHTML = window.i18n.GAME_IS
+    embeddingsPreviewButton.innerHTML = window.i18n.PREVIEW
+    embeddingsLoadButton.innerHTML = window.i18n.LOAD
+
+    i18n_vemb_instr1.innerHTML = window.i18n.VEMB_INSTR_1
+    i18n_vemb_instr2.innerHTML = window.i18n.VEMB_INSTR_2
+    i18n_vemb_instr3.innerHTML = window.i18n.VEMB_INSTR_3
+    i18n_vemb_instr4.innerHTML = window.i18n.VEMB_INSTR_4
+    i18n_vemb_instr5.innerHTML = window.i18n.VEMB_INSTR_5
+
+    i18n_vemb_males.innerHTML = window.i18n.MALES
+    i18n_vemb_females.innerHTML = window.i18n.FEMALES
+    i18n_vemb_other.innerHTML = window.i18n.OTHER
+
+    i18n_showOnlyInstalled.innerHTML = window.i18n.SHOW_ONLY_INSTALED
+    i18n_vemb_keyIs.innerHTML = window.i18n.KEY_IS
+    i18n_vemb_game_option.innerHTML = window.i18n.GAME
+    i18n_vemb_gender_option.innerHTML = window.i18n.GENDER
+    i18n_algorithm.innerHTML = window.i18n.ALGORITHM
+
+    i18n_totd.innerHTML = window.i18n.TOTD
+    i18n_totd_show.innerHTML = window.i18n.TOTD_SHOW
+    i18n_totd_show_unseen.innerHTML = window.i18n.TOTD_SHOW_UNSEEN
+    totdPrevTipBtn.innerHTML = window.i18n.TOTD_PREV_TIP
+    totdNextTipBtn.innerHTML = window.i18n.TOTD_NEXT_TIP
+    totd_close.innerHTML = window.i18n.CLOSE
+    embeddingsCloseHelpUI.innerHTML = window.i18n.CLOSE
+    nexusMenuButton.innerHTML = window.i18n.GET_MORE_VOICES
+
+    i18n_embeddings.innerHTML = window.i18n.STYLE_EMBEDDINGS
+    i18n_style_emb_wavpath.innerHTML = window.i18n.STYLE_EMB_WAVPATH
+    i18n_style_emb_author.innerHTML = window.i18n.AUTHOR
+    i18n_style_emb_gameId.innerHTML = window.i18n.GAME_ID
+    i18n_style_emb_voiceId.innerHTML = window.i18n.VOICE_ID
+    i18n_style_emb_name.innerHTML = window.i18n.EMB_NAME
+    i18n_style_emb_description.innerHTML = window.i18n.EMB_DESCRIPTION
+    i18n_style_emb_id.innerHTML = window.i18n.STYLE_EMB_ID
+    wavFilepathForEmbComputeInput.placeholder = window.i18n.STYLE_EMB_WAVPATH_PLACEHOLDER
+    i18n_style_emb_values.innerHTML = window.i18n.STYLE_EMB_VALUES
+    i18n_styleembsh_enabled.innerHTML = window.i18n.ENABLED
+    i18n_styleembsh_name.innerHTML = window.i18n.EMB_NAME
+    i18n_styleembsh_gameID.innerHTML = window.i18n.GAME_ID
+    i18n_styleembsh_voiceID.innerHTML = window.i18n.VOICE_ID
+    // i18n_styleembsh_actions.innerHTML = window.i18n.ACTIONS
+    i18n_styleembsh_description.innerHTML = window.i18n.DESCRIPTION
+    i18n_styleembsh_embId.innerHTML = window.i18n.EMB_ID
+    i18n_styleembsh_version.innerHTML = window.i18n.VERSION
+    // i18n_styleembsh_endorse.innerHTML = window.i18n.ENDORSE
+    styleEmbSave.innerHTML = window.i18n.SAVE
+    styleEmbDelete.innerHTML = window.i18n.DELETE
+
+
+    reset_btn.innerHTML = window.i18n.RESET
+    amplify_btn.innerHTML = window.i18n.AMPLIFY
+    jitter_btn.innerHTML = window.i18n.JITTER
+    flatten_btn.innerHTML = window.i18n.FLATTEN
+    increase_btn.innerHTML = window.i18n.RAISE
+    decrease_btn.innerHTML = window.i18n.LOWER
+    i18n_pacing.innerHTML = window.i18n.PACING
+
+    i18n_settings.innerHTML = window.i18n.SETTINGS
+    i18n_setting_gpu.innerHTML = window.i18n.SETTINGS_GPU
+    i18n_setting_autoplay.innerHTML = window.i18n.SETTINGS_AUTOPLAY
+    i18n_setting_defaulthifi.innerHTML = window.i18n.SETTINGS_DEFAULT_HIFI
+    i18n_setting_keeppacing.innerHTML = window.i18n.SETTINGS_KEEP_PACING
+    // i18n_setting_tooltip.innerHTML = window.i18n.SETTINGS_TOOLTIP
+
+    i18n_showDiscordStatus.innerHTML = window.i18n.SETTINGS_SHOW_DISCORD
+    // i18n_setting_darkmode.innerHTML = window.i18n.SETTINGS_DARKMODE
+    i18n_setting_promptfontsize.innerHTML = window.i18n.SETTINGS_PROMPTSIZE
+    i18n_setting_bg_fade.innerHTML = window.i18n.SETTINGS_BG_FADE
+    i18n_setting_autoreloadvoices.innerHTML = window.i18n.SETTINGS_AUTORELOADVOICES
+    i18n_setting_keepeditorstate.innerHTML = window.i18n.SETTINGS_KEEPEDITORSTATE
+    i18n_setting_pitchrangeoverride.innerHTML = window.i18n.SETTINGS_PITCHRANGEOVERRIDE
+    i18n_setting_outputjson.innerHTML = window.i18n.SETTINGS_OUTPUTJSON
+    i18n_setting_seqnumbering.innerHTML = window.i18n.SETTINGS_SEQNUMBERING
+    i18n_setting_spacepadding.innerHTML = window.i18n.SETTINGS_SPACEPADDING
+    i18n_setting_base_speaker.innerHTML = window.i18n.SETTINGS_BASE_SPEAKER
+    i18n_setting_alt_speaker.innerHTML = window.i18n.SETTINGS_ALT_SPEAKER
+    i18n_setting_external_edit.innerHTML = window.i18n.SETTINGS_EXTERNALEDIT
+    i18n_setting_ffmpeg.innerHTML = window.i18n.SETTINGS_FFMPEG
+    i18n_setting_ffmpeg_format.innerHTML = window.i18n.SETTINGS_FFMPEG_FORMAT
+    i18n_setting_ffmpeg_hz.innerHTML = window.i18n.SETTINGS_FFMPEG_HZ
+    i18n_setting_ffmpeg_padstart.innerHTML = window.i18n.SETTINGS_FFMPEG_PADSTART
+    i18n_setting_ffmpeg_padend.innerHTML = window.i18n.SETTINGS_FFMPEG_PADEND
+    i18n_setting_ffmpeg_pitchMult.innerHTML = window.i18n.SETTINGS_FFMPEG_PITCHMULT
+    i18n_setting_ffmpeg_tempo.innerHTML = window.i18n.SETTINGS_FFMPEG_TEMPO
+    i18n_setting_ffmpeg_deessing.innerHTML = window.i18n.SETTINGS_FFMPEG_DEESSING
+    i18n_setting_ffmpeg_bitdepth.innerHTML = window.i18n.SETTINGS_FFMPEG_BITDEPTH
+    i18n_setting_ffmpeg_nr.innerHTML = window.i18n.SETTINGS_FFMPEG_NR
+    i18n_setting_ffmpeg_nf.innerHTML = window.i18n.SETTINGS_FFMPEG_NF
+    i18n_setting_ffmpeg_amplitude.innerHTML = window.i18n.SETTINGS_FFMPEG_AMPLITUDE
+    i18n_setting_batch_json.innerHTML = window.i18n.SETTINGS_BATCH_JSON
+    // i18n_setting_batch_fastmode.innerHTML = window.i18n.SETTINGS_BATCH_FASTMODE
+    // i18n_settings_batch_mp_max_parallelizations.innerHTML = window.i18n.SETTINGS_BATCH_FASTMODE_MAX_PARALLELIZATIONS
+    i18n_setting_batch_multip.innerHTML = window.i18n.SETTINGS_BATCH_USEMULTIP
+    i18n_setting_batch_multip_count.innerHTML = window.i18n.SETTINGS_BATCH_MULTIPCOUNT
+    i18n_setting_microphone.innerHTML = window.i18n.SETTINGS_MICROPHONE
+    // i18n_setting_autogeneratevoice.innerHTML = window.i18n.SETTINGS_AUTOGENERATEVOICE
+    i18n_setting_s2s_bgnoise.innerHTML = window.i18n.SETTINGS_S2S_BGNOISE
+    s2s_settingsRecNoiseBtn.innerHTML = window.i18n.SETTINGS_S2S_RECNOISE
+    // i18n_setting_s2s_bgnoise_strength.innerHTML = window.i18n.SETTINGS_S2S_BGNOISE_STRENGTH
+    i18n_vc_strength.innerHTML = window.i18n.SETTINGS_VC_STRENGTH
+    reset_settings_btn.innerHTML = window.i18n.SETTINGS_RESET_SETTINGS
+    reset_paths_btn.innerHTML = window.i18n.SETTINGS_RESET_PATHS
+
+    updatesVersions.innerHTML = window.i18n.UPDATES_VERSION
+    i18n_updateslog.innerHTML = window.i18n.UPDATES_LOG
+    checkUpdates.innerHTML = window.i18n.UPDATES_CHECK
+
+    i18n_plugins.innerHTML = window.i18n.PLUGINS
+    i18n_plugins_trusted.innerHTML = window.i18n.PLUGINS_TRUSTED
+
+    i18n_pluginsh_enabled.innerHTML = window.i18n.PLUGINSH_ENABLED
+    i18n_pluginsh_order.innerHTML = window.i18n.PLUGINSH_ORDER
+    i18n_pluginsh_name.innerHTML = window.i18n.PLUGINSH_NAME
+    i18n_pluginsh_author.innerHTML = window.i18n.PLUGINSH_AUTHOR
+    i18n_pluginsh_version.innerHTML = window.i18n.PLUGINSH_VERSION
+    i18n_pluginsh_type.innerHTML = window.i18n.PLUGINSH_TYPE
+    i18n_pluginsh_minv.innerHTML = window.i18n.PLUGINSH_MINV
+    i18n_pluginsh_maxv.innerHTML = window.i18n.PLUGINSH_MAXV
+    i18n_pluginsh_description.innerHTML = window.i18n.PLUGINSH_DESCRIPTION
+    i18n_pluginsh_pluginid.innerHTML = window.i18n.PLUGINSH_PLUGINID
+    plugins_moveUpBtn.innerHTML = window.i18n.PLUGINS_MOVEUP
+    plugins_moveDownBtn.innerHTML = window.i18n.PLUGINS_MOVEDOWN
+    plugins_applyBtn.innerHTML = window.i18n.PLUGINS_APPLY
+
+    i18n_appinfo.innerHTML = window.i18n.APP_INFO
+    i18n_appinfo_instr_1.innerHTML = window.i18n.APP_INFO_INSTR_1
+    i18n_appinfo_instr_2.innerHTML = window.i18n.APP_INFO_INSTR_2
+    i18n_appinfo_instr_3.innerHTML = window.i18n.APP_INFO_INSTR_3
+    i18n_appinfo_instr_4.innerHTML = window.i18n.APP_INFO_INSTR_4
+    i18n_appinfo_instr_5.innerHTML = window.i18n.APP_INFO_INSTR_5
+
+    i18n_keyboard_reference.innerHTML = window.i18n.KEYBOARD_REFERENCE
+    i18n_keyboard_enter.innerHTML = window.i18n.KEYBOARD_ENTER
+    i18n_keyboard_enter_do.innerHTML = window.i18n.KEYBOARD_ENTER_DO
+    i18n_keyboard_escape.innerHTML = window.i18n.KEYBOARD_ESCAPE
+    i18n_keyboard_escape_do.innerHTML = window.i18n.KEYBOARD_ESCAPE_DO
+    i18n_keyboard_space.innerHTML = window.i18n.KEYBOARD_SPACE
+    i18n_keyboard_space_do.innerHTML = window.i18n.KEYBOARD_SPACE_DO
+    i18n_keyboard_ctrls.innerHTML = window.i18n.KEYBOARD_CTRLS
+    i18n_keyboard_ctrls_do.innerHTML = window.i18n.KEYBOARD_CTRLS_DO
+    i18n_keyboard_ctrlshifts.innerHTML = window.i18n.KEYBOARD_CTRLSHIFTS
+    i18n_keyboard_ctrlshifts_do.innerHTML = window.i18n.KEYBOARD_CTRLSHIFTS_DO
+    i18n_keyboard_yn.innerHTML = window.i18n.KEYBOARD_YN
+    i18n_keyboard_yn_do.innerHTML = window.i18n.KEYBOARD_YN_DO
+    i18n_keyboard_lr.innerHTML = window.i18n.KEYBOARD_LR
+    i18n_keyboard_lr_do.innerHTML = window.i18n.KEYBOARD_LR_DO
+    i18n_keyboard_shift_lr.innerHTML = window.i18n.KEYBOARD_SHIFT_LR
+    i18n_keyboard_shift_lr_do.innerHTML = window.i18n.KEYBOARD_SHIFT_LR_DO
+
+    i18n_keyboard_alt_ctrl_lr.innerHTML = window.i18n.KEYBOARD_ALT_CTRL_LR
+    i18n_keyboard_alt_ctrl_lr_do.innerHTML = window.i18n.KEYBOARD_ALT_CTRL_LR_DO
+    i18n_keyboard_ctrla.innerHTML = window.i18n.KEYBOARD_CTRLA
+    i18n_keyboard_ctrla_do.innerHTML = window.i18n.KEYBOARD_CTRLA_DO
+
+    i18n_keyboard_ud.innerHTML = window.i18n.KEYBOARD_UD
+    i18n_keyboard_ud_do.innerHTML = window.i18n.KEYBOARD_UD_DO
+    i18n_keyboard_ctrl_lr.innerHTML = window.i18n.KEYBOARD_CTRL_LR
+    i18n_keyboard_ctrl_lr_do.innerHTML = window.i18n.KEYBOARD_CTRL_LR_DO
+    i18n_keyboard_ctrl_ud.innerHTML = window.i18n.KEYBOARD_CTRL_UD
+    i18n_keyboard_ctrl_ud_do.innerHTML = window.i18n.KEYBOARD_CTRL_UD_DO
+    i18n_keyboard_ctrlshiftud.innerHTML = window.i18n.KEYBOARD_CTRLSHIFTUD
+    i18n_keyboard_ctrlshiftud_do.innerHTML = window.i18n.KEYBOARD_CTRLSHIFTUD_DO
+    i18n_keyboard_ctrlenter.innerHTML = window.i18n.KEYBOARD_CTRLENTER
+    i18n_keyboard_ctrlenter_do.innerHTML = window.i18n.KEYBOARD_CTRLENTER_DO
+
+    i18n_support.innerHTML = window.i18n.SUPPORT
+    // i18n_support_link.innerHTML = window.i18n.SUPPORT_LINK
+    i18n_support_thanks.innerHTML = window.i18n.SUPPORT_THANKS
+
+    searchGameInput.placeholder = window.i18n.SEARCH_GAMES
+    searchSettingsInput.placeholder = window.i18n.SEARCH_SETTINGS
+
+    i18n_eula_accept.innerHTML = window.i18n.EULA_ACCEPT
+    EULA_closeButon.innerHTML = window.i18n.EULA_CLOSE
+
+    i18n_batch_synthesis.innerHTML = window.i18n.BATCH_SYNTHESIS
+    i18n_batchsize.innerHTML = window.i18n.BATCH_SIZE
+    batch_generateSample.innerHTML = window.i18n.BATCH_GEN_SAMPLE
+    batch_instructions_btn.innerHTML = window.i18n.BATCH_INSTRUCTIONS
+    batchDropZoneNote.innerHTML = window.i18n.BATCH_DROPZONE
+
+    i18n_batchh_num.innerHTML = window.i18n.BATCHH_NUM
+    i18n_batchh_status.innerHTML = window.i18n.BATCHH_STATUS
+    i18n_batchh_actions.innerHTML = window.i18n.BATCHH_ACTIONS
+    i18n_nexush_actions.innerHTML = window.i18n.BATCHH_ACTIONS
+    i18n_batchh_game.innerHTML = window.i18n.BATCHH_GAME
+    i18n_nexush_game.innerHTML = window.i18n.BATCHH_GAME
+    i18n_batchh_voice.innerHTML = window.i18n.BATCHH_VOICE
+    i18n_batchh_text.innerHTML = window.i18n.BATCHH_TEXT
+    i18n_batchh_vocoder.innerHTML = window.i18n.BATCHH_VOCODER
+    i18n_batchh_vc_style.innerHTML = window.i18n.BATCHH_VC_STYLE
+    i18n_batchh_outpath.innerHTML = window.i18n.BATCHH_OUTPATH
+    i18n_batchh_pacing.innerHTML = window.i18n.BATCHH_PACING
+    i18n_batchh_pitch_amp.innerHTML = window.i18n.BATCHH_PITCH_AMP
+    i18n_batchh_base_lang.innerHTML = window.i18n.BATCHH_BASE_LANG
+    batch_outputFolderInput.placeholder = window.i18n.BATCH_ABS_DIR_PLACEHOLDER
+
+    i18n_batch_cleardir.innerHTML = window.i18n.BATCH_CLEAR_DIR
+    i18n_batch_skip.innerHTML = window.i18n.BATCH_SKIP
+    i18n_batch_outputNumerically.innerHTML = window.i18n.BATCH_OUTPUTNUMERICALLY
+    batch_progressNotes.innerHTML = window.i18n.BATCH_CURRENTLYDOING
+    batch_synthesizeBtn.innerHTML = window.i18n.BATCH_SYNTHESIZE
+    batch_pauseBtn.innerHTML = window.i18n.BATCH_PAUSE
+    batch_stopBtn.innerHTML = window.i18n.BATCH_STOP
+    batch_clearBtn.innerHTML = window.i18n.BATCH_CLEAR
+    batch_openDirBtn.innerHTML = window.i18n.BATCH_OPENOUT
+
+    s2s_voiceId_selected_label.innerHTML = window.i18n.VC_ONLY_FOR_V3
+    i18n_settings_model_version_highlight.innerHTML = window.i18n.SETTING_HIGHLIGHT_ONLY_MODELS_V
+    i18n_setting_output_files_pagination_size.innerHTML = window.i18n.SETTING_OUTPUTFILES_PAGINATION
+
+    openDiscord.innerHTML = window.i18n.JOIN_DISCORD
+
+    i18n_workbench.innerHTML = window.i18n.VOICE_CRAFTING_WORKBENCH
+    voiceWorkbenchRefAFilePath.innerHTML = window.i18n.FROM_FILE_IS_DRAG_N_DROP
+    voiceWorkbenchRefBFilePath.innerHTML = window.i18n.FROM_FILE_IS_DRAG_N_DROP
+
+    voiceWorkbenchInputTextArea.innerHTML = window.i18n.VW_INPUT_TEXTAREA_PLACEHOLDER
+
+    voiceWorkbenchGenerateSampleButton.innerHTML = window.i18n.GENERATE
+    i18n_vw_current.innerHTML = window.i18n.CURRENT
+    voiceWorkbenchAudioCurrentPlayPauseBtn.innerHTML = window.i18n.PLAY
+    voiceWorkbenchAudioCurrentSaveBtn.innerHTML = window.i18n.SAVE
+    voiceWorkbenchAudioNewPlayBtn.innerHTML = window.i18n.PLAY
+    voiceWorkbenchAudioNewSaveBtn.innerHTML = window.i18n.SAVE
+
+    i18n_vw_current_emb.innerHTML = window.i18n.CURRENT_EMB
+    i18n_vw_current_delta.innerHTML = window.i18n.CURRENT_DELTA
+    i18n_vw_strength.innerHTML = window.i18n.STRENGTH
+    voiceWorkshopApplyDeltaButton.innerHTML = window.i18n.APPLY_DELTA
+    i18n_refAF_a.innerHTML = window.i18n.VW_REF_FILE_A
+    i18n_refAF_b.innerHTML = window.i18n.VW_REF_FILE_B
+
+    i18n_vw_basemodel.innerHTML = window.i18n.VW_BASE_MODEL
+    i18n_vw_game.innerHTML = window.i18n.GAME
+    i18n_vw_voicename.innerHTML = window.i18n.VOICE_NAME
+    i18n_vw_voiceid.innerHTML = window.i18n.VOICE_ID
+    voiceWorkbenchVoiceNameInput.placeholder = window.i18n.NAME_OF_YOUR_VOICE
+    voiceWorkbenchVoiceIDInput.placeholder = window.i18n.UNIQUE_ID_FOR_VOICE
+    i18n_vw_gender.innerHTML = window.i18n.GENDER
+    i18n_vw_author.innerHTML = window.i18n.AUTHOR
+
+    voiceWorkbenchAuthorInput.placeholder = window.i18n.YOUR_NAME_FOR_CREDITS
+
+    i18n_vw_baselang.innerHTML = window.i18n.BASE_LANGUAGE
+    voiceWorkbenchStartButton.innerHTML = window.i18n.START
+    voiceWorkbenchCancelButton.innerHTML = window.i18n.CANCEL
+    voiceWorkbenchDeleteButton.innerHTML = window.i18n.DELETE
+    voiceWorkbenchSaveButton.innerHTML = window.i18n.SAVE
+
+
+    splashNextButton1.innerHTML = window.i18n.NEXT
+
+    i18n_variant.innerHTML = window.i18n.VARIANT_IS
+    i18n_reset_what_prompt.innerHTML = window.i18n.RESET_WHAT_PROMPT
+    i18n_reset_what_tip.innerHTML = window.i18n.RESET_WHAT_TIP
+    reset_what_confirm_btn.innerHTML = window.i18n.RESET
+    i18n_batch_metadata_confirm.innerHTML = window.i18n.BATCH_METADATA_CONFIRM
+    i18n_batch_metadata_tip.innerHTML = window.i18n.BATCH_METADATA_TIP
+    i18n_batch_metadata_voiceID.innerHTML = window.i18n.VOICE_ID
+    i18n_batch_metadata_gameID.innerHTML = window.i18n.GAME_ID
+    i18n_batch_metadata_confirm_btn.innerHTML = window.i18n.CONFIRM
+    batch_saveToCSV.innerHTML = window.i18n.SAVE_TO_CSV
+
+    arpabetIcon.title = "ARPAbet"
+    embeddingsIcon.title = "Embeddings visualiser"
+    pluginsIcon.title = window.i18n.PLUGINS
+    batchIcon.title = "Batch mode"
+    updatesIcon.title = "Changelog"
+    patreonIcon.title = "Patreon"
+    infoIcon.title = window.i18n.INFO
+    settingsCog.title = "Settings"
+    workbenchIcon.title = window.i18n.WORKBENCH
+
+}
+
+
+window.i18n.setEnglish()
+window.i18n.updateUI()

javascript/nexus.js

@@ -0,0 +1,983 @@
+"use strict"
+
+window.nexusModelsList = []
+window.endorsedRepos = new Set()
+window.nexusState = {
+    key: null,
+    applicationSlug: "xvasynth",
+    socket: null,
+    uuid: null,
+    token: null,
+    downloadQueue: [],
+    installQueue: [],
+    finished: 0,
+    repoLinks: [],
+    primaryColumnSort: "game",
+    columnSortModifier: -1
+}
+
+// TEMP, maybe move to utils
+// ==========================
+const http = require("http")
+const https = require("https")
+
+// Utility for printing out in the dev console all the numerical game IDs on the Nexus
+window.nexusGameIdToGameName = {}
+window.getAllNexusGameIDs = (gameName) => {
+    return new Promise((resolve) => {
+        getData("", undefined, "GET").then(results => {
+            results = gameName ? results.filter(x=>x.name.toLowerCase().includes(gameName)) : results
+            resolve(results)
+        })
+    })
+}
+
+window.mod_search_nexus = (game_id, query) => {
+    return new Promise(resolve => {
+        doFetch(`https://search.nexusmods.com/mods/?game_id=${game_id}&terms=${encodeURI(query.split(' ').toString())}&include_adult=true`)
+        .then(r=>r.text())
+        .then(r => {
+            try {
+                const data = JSON.parse(r).results.map(res => {
+                    return {
+                        downloads: res.downloads,
+                        endorsements: res.endorsements,
+                        game_id: res.game_id,
+                        name: res.name,
+                        author: res.username,
+                        url: `https://www.nexusmods.com/${res.game_name}/mods/${res.mod_id}`
+                    }
+                })
+
+                resolve([r.total, data])
+            } catch (e) {
+                window.appLogger.log(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+                window.errorModal(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+            }
+        })
+    })
+}
+
+window.nexusDownload = (url, dest) => {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest)
+
+        const request = https.get(url.replace("http:", "https:"), (response) => {
+            // check if response is success
+            if (response.statusCode !== 200) {
+                console.log("url", url)
+                console.log("Response status was " + response.statusCode, response)
+                resolve()
+                return
+            }
+
+            response.pipe(file)
+        })
+
+        file.on("finish", () => {
+            file.close()
+            resolve()
+        })
+
+        // check for request error too
+        request.on("error", (err) => {
+            fs.unlink(dest)
+            return reject(err.message)
+        })
+
+        file.on("error", (err) => { // Handle errors
+            fs.unlink(dest) // Delete the file async. (But we don't check the result)
+            return reject(err.message)
+        })
+    })
+}
+
+window.initNexus = () => {
+    const data = fs.readFileSync(`${window.path}/repositories.json`, "utf8")
+    window.nexusReposList = JSON.parse(data)
+    return new Promise((resolve) => {
+
+        window.nexusState.key = localStorage.getItem("nexus_API_key")
+
+        if (window.nexusState.key) {
+            window.showUserName()
+            nexusLogInButton.innerHTML = window.i18n.LOG_OUT
+            resolve()
+        } else {
+            try {
+                window.nexusState.socket = new WebSocket("wss://sso.nexusmods.com")
+            } catch (e) {
+                console.log(e)
+            }
+
+            window.nexusState.socket.onclose = event => {
+                console.log("socket closed")
+                if (!window.nexusState.key) {
+                    setTimeout(() => {window.initNexus()}, 5000)
+                }
+            }
+
+            window.nexusState.socket.onmessage = event => {
+                const response = JSON.parse(event.data)
+
+                if (response && response.success) {
+                    if (response.data.hasOwnProperty('connection_token')) {
+                        localStorage.setItem('connection_token', response.data.connection_token)
+                    } else if (response.data.hasOwnProperty('api_key')) {
+                        console.log("API Key Received: " + response.data.api_key)
+                        window.nexusState.key = response.data.api_key
+                        localStorage.setItem('uuid', window.nexusState.uuid)
+                        localStorage.setItem('nexus_API_key', window.nexusState.key)
+                        window.showUserName()
+                        window.pluginsManager.updateUI()
+                        closeModal(undefined, nexusContainer)
+                        nexusLogInButton.innerHTML = window.i18n.LOG_OUT
+                        resolve()
+                    }
+                } else {
+                    window.errorModal(`${window.i18n.ERR_LOGGING_INTO_NEXUS}: ${response.error}`)
+                    reject()
+                }
+            }
+        }
+    })
+}
+nexusLogInButton.addEventListener("click", () => {
+
+    if (nexusLogInButton.innerHTML==window.i18n.LOG_IN) {
+        window.spinnerModal(window.i18n.LOGGING_INTO_NEXUS)
+
+        window.nexusState.uuid = localStorage.getItem("uuid")
+        window.nexusState.token = localStorage.getItem("connection_token")
+
+        if (window.nexusState.uuid==null) {
+            window.nexusState.uuid = uuidv4()
+        }
+
+        const data = {
+            id: window.nexusState.uuid,
+            token: window.nexusState.token,
+            protocol: 2
+        }
+        window.nexusState.socket.send(JSON.stringify(data))
+
+        shell.openExternal(`https://www.nexusmods.com/sso?id=${window.nexusState.uuid}&application=${window.nexusState.applicationSlug}`)
+
+    } else {
+        nexusNameDisplayContainer.style.opacity = 0
+        localStorage.removeItem("nexus_API_key")
+        localStorage.removeItem("uuid")
+        localStorage.removeItem("connection_token")
+        nexusAvatar.innerHTML = ""
+        nexusUserName.innerHTML = ""
+        nexusLogInButton.innerHTML = window.i18n.LOG_IN
+        window.nexusState.uuid = null
+        window.nexusState.key = null
+        window.pluginsManager.updateUI()
+    }
+})
+
+
+
+window.downloadFile = ([nexusGameId, nexusRepoId, outputFileName, fileId]) => {
+    nexusDownloadLog.appendChild(createElem("div", `Downloading: ${outputFileName}`))
+    return new Promise(async (resolve, reject) => {
+        if (!fs.existsSync(`${window.path}/downloads`)) {
+            fs.mkdirSync(`${window.path}/downloads`)
+        }
+
+        const downloadLink = await getData(`${nexusGameId}/mods/${nexusRepoId}/files/${fileId}/download_link.json`)
+        if (!downloadLink.length && downloadLink.code==403) {
+
+            window.errorModal(`${window.i18n.NEXUS_PREMIUM}<br><br>${window.i18n.NEXUS_ORIG_ERR}:<br>${downloadLink.message}`).then(() => {
+                const queueIndex = window.nexusState.downloadQueue.findIndex(it => it[1]==fileId)
+                window.nexusState.downloadQueue.splice(queueIndex, 1)
+                nexusDownloadingCount.innerHTML = window.nexusState.downloadQueue.length
+
+                nexusDownloadLog.appendChild(createElem("div", `${window.i18n.FAILED_DOWNLOAD}: ${outputFileName}`))
+
+                reject()
+            })
+
+        } else {
+            await window.nexusDownload(downloadLink[0].URI.replace("https", "http"), `${window.path}/downloads/${outputFileName}.zip`)
+
+            const queueIndex = window.nexusState.downloadQueue.findIndex(it => it[1]==fileId)
+            window.nexusState.downloadQueue.splice(queueIndex, 1)
+            nexusDownloadingCount.innerHTML = window.nexusState.downloadQueue.length
+
+            resolve()
+        }
+    })
+
+}
+window.installDownloadedModel = ([game, zipName]) => {
+    nexusDownloadLog.appendChild(createElem("div", `${window.i18n.INSTALLING} ${zipName}`))
+    return new Promise(resolve => {
+        try {
+            const modelsFolder = window.userSettings[`modelspath_${game}`]
+
+            const unzipper = require('unzipper')
+            const zipPath = `${window.path}/downloads/${zipName}.zip`
+
+            if (!fs.existsSync(modelsFolder)) {
+                fs.mkdirSync(modelsFolder)
+            }
+
+            if (!fs.existsSync(`${window.path}/downloads`)) {
+                fs.mkdirSync(`${window.path}/downloads`)
+            }
+
+            fs.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", entry => {
+                const fileName = entry.path
+                const dirOrFile = entry.type
+
+                if (/\/$/.test(fileName)) { // It's a directory
+                    return
+                }
+
+                let fileContainerFolderPath = fileName.split("/").reverse()
+                const justFileName = fileContainerFolderPath[0]
+
+                entry.pipe(fs.createWriteStream(`${modelsFolder}/${justFileName}`))
+            })
+            .promise()
+            .then(() => {
+                window.appLogger.log(`${window.i18n.DONE_INSTALLING} ${zipName}`)
+
+                const queueIndex = window.nexusState.installQueue.findIndex(it => it[1]==zipName)
+                window.nexusState.installQueue.splice(queueIndex, 1)
+                nexusInstallingCount.innerHTML = window.nexusState.installQueue.length
+
+                nexusDownloadLog.appendChild(createElem("div", `${window.i18n.FINISHED} ${zipName}`))
+                resolve()
+            }, e => {
+                console.log(e)
+                window.appLogger.log(e)
+                window.errorModal(e.message)
+            })
+        } catch (e) {
+            console.log(e)
+            window.appLogger.log(e)
+            window.errorModal(e.message)
+            resolve()
+        }
+    })
+}
+
+nexusDownloadAllBtn.addEventListener("click", async () => {
+
+    for (let mi=0; mi<window.nexusState.filteredDownloadableModels.length; mi++) {
+        const modelMeta = window.nexusState.filteredDownloadableModels[mi]
+        window.nexusState.downloadQueue.push([modelMeta.voiceId, modelMeta.nexus_file_id])
+        nexusDownloadingCount.innerHTML = window.nexusState.downloadQueue.length
+    }
+
+    for (let mi=0; mi<window.nexusState.filteredDownloadableModels.length; mi++) {
+
+        const modelMeta = window.nexusState.filteredDownloadableModels[mi]
+        await window.downloadFile([modelMeta.nexusGameId, modelMeta.nexusRepoId, modelMeta.voiceId, modelMeta.nexus_file_id])
+
+        // Install the downloaded voice
+        window.nexusState.installQueue.push([modelMeta.game, modelMeta.voiceId])
+        nexusInstallingCount.innerHTML = window.nexusState.installQueue.length
+        await window.installDownloadedModel([modelMeta.game, modelMeta.voiceId])
+
+        fs.unlinkSync(`${window.path}/downloads/${modelMeta.voiceId}.zip`)
+
+        window.nexusState.finished += 1
+        nexusFinishedCount.innerHTML = window.nexusState.finished
+        window.displayAllModels(true)
+        window.loadAllModels(true).then(() => {
+            changeGame(window.currentGame)
+        })
+    }
+})
+
+
+const getJSONData = (url) => {
+    return new Promise(resolve => {
+        doFetch(url).then(r=>r.json())
+    })
+}
+
+window.showUserName = async () => {
+    const data = await getuserData("validate.json")
+    const img = createElem("img")
+    img.src = data.profile_url
+    img.style.height = "40px"
+    nexusAvatar.innerHTML = ""
+    img.addEventListener("load", () => {
+        nexusAvatar.appendChild(img)
+        nexusUserName.innerHTML = data.name
+        nexusNameDisplayContainer.style.opacity = 1
+    })
+}
+
+const getuserData = (url, data) => {
+    return new Promise(resolve => {
+        doFetch(`https://api.nexusmods.com/v1/users/${url}`, {
+            method: "GET",
+            headers: {
+                apikey: window.nexusState.key
+            }
+        })
+        .then(r=>r.text())
+        .then(r => {
+            try {
+                resolve(JSON.parse(r))
+            } catch (e) {
+                window.appLogger.log(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+                window.errorModal(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+            }
+        })
+        .catch(err => {
+            console.log("err", err)
+            resolve()
+        })
+    })
+}
+const getData = (url, data, type="GET") => {
+    return new Promise(resolve => {
+        const payload = {
+            method: type,
+            headers: {
+                apikey: window.nexusState.key
+            }
+        }
+        if (type=="POST") {
+            const params = new URLSearchParams()
+            Object.keys(data).forEach(key => {
+                params.append(key, data[key])
+            })
+            payload.body = params
+        }
+
+        doFetch(`https://api.nexusmods.com/v1/games/${url}`, payload)
+        .then(r=>r.text())
+        .then(r => {
+            try {
+                resolve(JSON.parse(r))
+            } catch (e) {
+                window.appLogger.log(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+                window.errorModal(window.i18n.ERROR_FROM_NEXUS.replace("_1", r))
+            }
+        })
+        .catch(err => {
+            console.log("err", err)
+            resolve()
+        })
+    })
+}
+window.nexus_getData = getData
+// ==========================
+
+
+
+
+let hasPopulatedNexusGameListDropdown = false
+window.openNexusWindow = () => {
+    closeModal(undefined, nexusContainer).then(() => {
+        nexusContainer.style.opacity = 0
+        nexusContainer.style.display = "flex"
+        requestAnimationFrame(() => requestAnimationFrame(() => nexusContainer.style.opacity = 1))
+        requestAnimationFrame(() => requestAnimationFrame(() => chromeBar.style.opacity = 1))
+    })
+
+    const gameColours = {}
+    Object.keys(window.gameAssets).forEach(gameId => {
+        const colour = window.gameAssets[gameId].themeColourPrimary
+        gameColours[gameId] = colour
+    })
+
+    nexusGamesList.innerHTML = ""
+    Object.keys(window.gameAssets).sort((a,b)=>a<b?-1:1).forEach(gameId => {
+        const gameSelectContainer = createElem("div")
+        const gameCheckbox = createElem(`input#ngl_${gameId}`, {type: "checkbox"})
+        gameCheckbox.checked = true
+        const gameButton = createElem("button.fixedColour")
+        gameButton.style.setProperty("background-color", `#${gameColours[gameId]}`, "important")
+        gameButton.style.display = "flex"
+        gameButton.style.alignItems = "center"
+        gameButton.style.margin = "auto"
+        gameButton.style.marginTop = "8px"
+        const buttonLabel = createElem("span", window.gameAssets[gameId].gameName)
+
+        gameButton.addEventListener("contextmenu", e => {
+            if (e.target==gameButton || e.target==buttonLabel) {
+                Array.from(nexusGamesList.querySelectorAll("input")).forEach(ckbx => ckbx.checked = false)
+                gameCheckbox.click()
+                window.displayAllModels()
+            }
+        })
+
+        gameButton.addEventListener("click", e => {
+            if (e.target==gameButton || e.target==buttonLabel) {
+                gameCheckbox.click()
+                window.displayAllModels()
+            }
+        })
+        gameCheckbox.addEventListener("change", () => {
+            window.displayAllModels()
+        })
+
+        gameButton.appendChild(gameCheckbox)
+        gameButton.appendChild(buttonLabel)
+        gameSelectContainer.appendChild(gameButton)
+        nexusGamesList.appendChild(gameSelectContainer)
+    })
+
+    // Populate the game IDs for the Nexus repo searching
+    if (!hasPopulatedNexusGameListDropdown) {
+        window.getAllNexusGameIDs().then(results => {
+            if (results && results.length) {
+                results = results.sort((a,b)=>a.name.toLowerCase()<b.name.toLowerCase()?-1:1)
+                results.forEach(res => {
+
+                    window.nexusGameIdToGameName[res.id] = res.name
+
+                    const opt = createElem("option", {value: res.id})
+                    opt.innerHTML = res.name
+                    nexusAllGamesSelect.appendChild(opt)
+                })
+                if (fs.existsSync(`${window.path}/repositories.json`)) {
+                    const data = fs.readFileSync(`${window.path}/repositories.json`, "utf8")
+                    window.nexusReposList = JSON.parse(data)
+                    window.nexusUpdateModsUsedPanel()
+                }
+                hasPopulatedNexusGameListDropdown = true
+            }
+        })
+    }
+
+}
+window.setupModal(nexusMenuButton, nexusContainer, window.openNexusWindow)
+
+nexusGamesListEnableAllBtn.addEventListener("click", () => {
+    Array.from(nexusGamesList.querySelectorAll("input")).forEach(ckbx => ckbx.checked = true)
+    window.displayAllModels()
+})
+nexusGamesListDisableAllBtn.addEventListener("click", () => {
+    Array.from(nexusGamesList.querySelectorAll("input")).forEach(ckbx => ckbx.checked = false)
+    window.displayAllModels()
+})
+
+
+
+nexusSearchBar.addEventListener("keyup", () => {
+    window.displayAllModels()
+})
+
+
+window.getLatestModelsList = async () => {
+    if (!nexusState.key) {
+        return window.errorModal(window.i18n.YOU_MUST_BE_LOGGED_IN)
+    } else {
+        try {
+            window.spinnerModal(window.i18n.CHECKING_NEXUS)
+            window.nexusModelsList = []
+
+            const idToGame = {}
+            Object.keys(window.gameAssets).forEach(gameId => {
+                const id = window.gameAssets[gameId].gameCode.toLowerCase()
+                idToGame[id] = gameId
+            })
+
+            const repoLinks = window.nexusReposList.repos.filter(r=>r.enabled).map(r=>r.url)
+
+            for (let li=0; li<repoLinks.length; li++) {
+
+                const link = repoLinks[li].replace("\r","")
+                const repoInfo = await getData(`${link.split(".com/")[1]}.json`)
+                const author = repoInfo.author
+                const nexusRepoId = repoInfo.mod_id
+                const nexusRepoVersion = repoInfo.version
+                const nexusGameId = repoInfo.domain_name
+
+                const files = await getData(`${link.split(".com/")[1]}/files.json`)
+                files["files"].forEach(file => {
+
+                    if (file.category_name=="OPTIONAL" || file.category_name=="OPTIONAL") {
+
+                        if (!file.description.includes("Voice model")) {
+                            return
+                        }
+
+                        const description = file.description
+                        const parts = description.split("<br />")
+                        let voiceId = parts.filter(line => line.startsWith("Voice ID:") || line.startsWith("VoiceID:"))[0]
+                        voiceId = voiceId.includes("Voice ID: ") ? voiceId.split("Voice ID: ")[1].split(" ")[0] : voiceId.split("VoiceID: ")[1].split(" ")[0]
+                        const game = idToGame[voiceId.split("_")[0]]
+                        const name = parts.filter(line => line.startsWith("Voice model"))[0].split(" - ")[1]
+                        const date = file.uploaded_time
+                        const nexus_file_id = file.file_id
+
+                        if (repoInfo.endorsement.endorse_status=="Endorsed") {
+                            window.endorsedRepos.add(game)
+                        }
+
+                        const hasT2 = description.includes("Tacotron2")
+                        const hasHiFi = description.includes("HiFi-GAN")
+                        const version = file.version
+
+                        let type
+                        if (description.includes("Model:")) {
+                            type = parts.filter(line => line.startsWith("Model: "))[0].split("Model: ")[1]
+                        } else {
+                            type = "FastPitch"
+                            if (type=="FastPitch") {
+                                if (hasT2) {
+                                    type = "T2+"+type
+                                }
+                            }
+                            if (hasHiFi) {
+                                type += "+HiFi"
+                            }
+                        }
+
+                        const notes = description.includes("Notes:") ? parts.filter(line => line.startsWith("Notes: "))[0].split("Notes: ")[1] : ""
+                        const meta = {author, description, version, voiceId, game, name, type, notes, date, nexusRepoId, nexusRepoVersion, nexusGameId, nexus_file_id, repoLink: link}
+                        window.nexusModelsList.push(meta)
+                    }
+                })
+            }
+
+            window.closeModal(undefined, nexusContainer)
+            window.displayAllModels()
+
+        } catch (e) {
+            console.log(e)
+            window.appLogger.log(e)
+            window.errorModal(e.message)
+        }
+    }
+}
+
+const clearColumsFocus = () => {
+    nexusRecordsHeader.querySelectorAll("div").forEach(elem => elem.style.textDecoration = "none")
+}
+const setColumnSort = (elem, key) => {
+    clearColumsFocus()
+    elem.style.textDecoration = "underline"
+    if (window.nexusState.primaryColumnSort==key) {
+        window.nexusState.columnSortModifier = window.nexusState.columnSortModifier * -1
+    }
+    window.nexusState.primaryColumnSort = key
+    window.displayAllModels()
+}
+i18n_nexush_game.addEventListener("click", () => setColumnSort(i18n_nexush_game, "game"))
+i18n_nexush_name.addEventListener("click", () => setColumnSort(i18n_nexush_game, "name"))
+i18n_nexush_author.addEventListener("click", () => setColumnSort(i18n_nexush_author, "author"))
+i18n_nexush_version.addEventListener("click", () => setColumnSort(i18n_nexush_version, "version"))
+i18n_nexush_date.addEventListener("click", () => setColumnSort(i18n_nexush_date, "date"))
+i18n_nexush_type.addEventListener("click", () => setColumnSort(i18n_nexush_type, "type"))
+
+
+const runNestedSort = (modelsList, primKey) => {
+    // Perform the primary sorting
+    const primaryGroup = {}
+    let modelsOrder = []
+    modelsList.forEach(item => {
+        if (!Object.keys(primaryGroup).includes(item[primKey]||"")) {
+            modelsOrder.push(item[primKey]||"")
+            primaryGroup[item[primKey]||""] = []
+        }
+        primaryGroup[item[primKey]||""].push(item)
+    })
+
+    // Sort the primary key in the correct direction
+    modelsOrder = modelsOrder.sort((a,b) => a<b?window.nexusState.columnSortModifier:-window.nexusState.columnSortModifier)
+
+    // Sort the secondary criteria (the voice names) within the primary groups
+    modelsOrder.forEach(primaryKey => {
+        primaryGroup[primaryKey] = primaryGroup[primaryKey].sort((a,b) => (a.name||"").toLowerCase()<(b.name||"").toLowerCase()?window.nexusState.columnSortModifier:-window.nexusState.columnSortModifier)
+    })
+    // Collate everything back into the final order
+    const finalOrder = []
+    modelsOrder.forEach(primaryKey => {
+        primaryGroup[primaryKey].forEach(record => finalOrder.push(record))
+    })
+    return finalOrder
+}
+
+window.displayAllModels = (forceUpdate=false) => {
+
+    if (!forceUpdate && window.nexusState.installQueue.length) {
+        return
+    }
+
+    const enabledGames = Array.from(nexusGamesList.querySelectorAll("input"))
+        .map(elem => [elem.checked, elem.id.replace("ngl_", "")])
+        .filter(checkedId => checkedId[0])
+        .map(checkedId => checkedId[1])
+
+    const gameColours = {}
+    Object.keys(window.gameAssets).forEach(gameId => {
+        const colour = window.gameAssets[gameId].themeColourPrimary
+        gameColours[gameId] = colour
+    })
+    const gameTitles = {}
+    Object.keys(window.gameAssets).forEach(gameId => {
+        const title = window.gameAssets[gameId].gameName
+        gameTitles[gameId] = title
+    })
+
+    nexusRecordsContainer.innerHTML = ""
+
+    window.nexusState.filteredDownloadableModels = []
+
+
+    let sortedModelsList = []
+    // Allow sorting by another column. But should still sort based on voice name alphabetically, as a secondary criteria
+    // Primary sortable columns: Game, VoiceName, Author, Version, Date, Type
+    if (window.nexusState.primaryColumnSort=="name") {
+        sortedModelsList = window.nexusModelsList.sort((a,b) => (a.name||"").toLowerCase()<(b.name||"").toLowerCase()?window.nexusState.columnSortModifier:-window.nexusState.columnSortModifier)
+    } else {
+        sortedModelsList = runNestedSort(window.nexusModelsList, window.nexusState.primaryColumnSort)
+    }
+
+    sortedModelsList.forEach(modelMeta => {
+        if (!enabledGames.includes(modelMeta.game)) {
+            return
+        }
+        if (nexusSearchBar.value.toLowerCase().trim().length && !modelMeta.name.toLowerCase().includes(nexusSearchBar.value.toLowerCase().trim())) {
+            return
+        }
+        let existingModel = undefined
+        if (Object.keys(window.games).includes(modelMeta.game)) {
+            for (let mi=0; mi<window.games[modelMeta.game].models.length; mi++) {
+                if (existingModel) continue
+
+                const variants = window.games[modelMeta.game].models[mi].variants
+
+                for (let vi=0; vi<variants.length; vi++) {
+                    if (variants[vi].voiceId==modelMeta.voiceId) {
+                        existingModel = variants[vi]
+                        break
+                    }
+                }
+            }
+        }
+
+        if (existingModel && nexusOnlyNewUpdatedCkbx.checked && (window.checkVersionRequirements(modelMeta.version, String(existingModel.modelVersion)) || (modelMeta.version.replace(".0","")==String(existingModel.modelVersion))) ){
+            return
+        }
+
+
+
+        const recordRow = createElem("div")
+        const actionsElem = createElem("div")
+
+        // Open link to the repo in the browser
+        const openButton = createElem("button.smallButton.fixedColour", window.i18n.OPEN)
+        openButton.style.setProperty("background-color", `#${gameColours[modelMeta.game]}`, "important")
+        openButton.addEventListener("click", () => {
+            shell.openExternal(modelMeta.repoLink)
+        })
+        actionsElem.appendChild(openButton)
+
+
+
+        // Download
+        const downloadButton = createElem("button.smallButton.fixedColour", window.i18n.DOWNLOAD)
+        downloadButton.style.setProperty("background-color", `#${gameColours[modelMeta.game]}`, "important")
+        downloadButton.addEventListener("click", async () => {
+            // Download the voice
+            window.nexusState.downloadQueue.push([modelMeta.voiceId, modelMeta.nexus_file_id])
+            nexusDownloadingCount.innerHTML = window.nexusState.downloadQueue.length
+            try {
+                await window.downloadFile([modelMeta.nexusGameId, modelMeta.nexusRepoId, modelMeta.voiceId, modelMeta.nexus_file_id])
+
+                // Install the downloaded voice
+                window.nexusState.installQueue.push([modelMeta.game, modelMeta.voiceId])
+                nexusInstallingCount.innerHTML = window.nexusState.installQueue.length
+                await window.installDownloadedModel([modelMeta.game, modelMeta.voiceId])
+
+                window.nexusState.finished += 1
+                nexusFinishedCount.innerHTML = window.nexusState.finished
+                window.displayAllModels()
+                window.loadAllModels(true).then(() => {
+                    changeGame(window.currentGame)
+                })
+
+            } catch (e) {}
+
+        })
+        if (existingModel && (modelMeta.version.replace(".0","")==String(existingModel.modelVersion) || window.checkVersionRequirements(modelMeta.version, String(existingModel.modelVersion)) ) ) {
+        } else {
+            window.nexusState.filteredDownloadableModels.push(modelMeta)
+            actionsElem.appendChild(downloadButton)
+        }
+
+
+        // Endorse
+        const endorsed = window.endorsedRepos.has(modelMeta.game)
+        const endorseButton = createElem("button.smallButton.fixedColour", endorsed?"Unendorse":"Endorse")
+        if (endorsed) {
+            endorseButton.style.background = "none"
+            endorseButton.style.border = `2px solid #${gameColours[modelMeta.game]}`
+        } else {
+            endorseButton.style.setProperty("background-color", `#${gameColours[modelMeta.game]}`, "important")
+        }
+        endorseButton.addEventListener("click", async () => {
+            let response
+            if (endorsed) {
+                response = await getData(`${modelMeta.nexusGameId}/mods/${modelMeta.nexusRepoId}/abstain.json`, {
+                    game_domain_name: modelMeta.nexusGameId,
+                    id: modelMeta.nexusRepoId,
+                    version: modelMeta.nexusRepoVersion
+                }, "POST")
+            } else {
+                response = await getData(`${modelMeta.nexusGameId}/mods/${modelMeta.nexusRepoId}/endorse.json`, {
+                    game_domain_name: modelMeta.nexusGameId,
+                    id: modelMeta.nexusRepoId,
+                    version: modelMeta.nexusRepoVersion
+                }, "POST")
+            }
+            if (response && response.message && response.status=="Error") {
+                if (response.message=="NOT_DOWNLOADED_MOD") {
+                    response.message = window.i18n.NEXUS_NOT_DOWNLOADED_MOD
+                } else if (response.message=="TOO_SOON_AFTER_DOWNLOAD") {
+                    response.message = window.i18n.NEXUS_TOO_SOON_AFTER_DOWNLOAD
+                } else if (response.message=="IS_OWN_MOD") {
+                    response.message = window.i18n.NEXUS_IS_OWN_MOD
+                }
+
+                window.errorModal(response.message)
+            } else {
+                if (endorsed) {
+                    window.endorsedRepos.delete(modelMeta.game)
+                } else {
+                    window.endorsedRepos.add(modelMeta.game)
+                }
+                window.displayAllModels()
+            }
+        })
+        actionsElem.appendChild(endorseButton)
+
+
+
+        const gameElem = createElem("div", gameTitles[modelMeta.game])
+        gameElem.title = gameTitles[modelMeta.game]
+        const nameElem = createElem("div", modelMeta.name)
+        nameElem.title = modelMeta.name
+        const authorElem = createElem("div", modelMeta.author)
+        authorElem.title = modelMeta.author
+        let versionElemText
+        if (existingModel) {
+            const yoursVersion = String(existingModel.modelVersion).includes(".") ? existingModel.modelVersion : existingModel.modelVersion+".0"
+            versionElemText = `${modelMeta.version} (${window.i18n.YOURS}: ${yoursVersion})`
+        } else {
+            versionElemText = modelMeta.version
+        }
+        const versionElem = createElem("div", versionElemText)
+        versionElem.title = versionElemText
+
+        const date = new Date(modelMeta.date)
+        const dateString = `${date.getDate()}/${date.getMonth()+1}/${date.getYear()+1900}`
+        const dateElem = createElem("div", dateString)
+        dateElem.title = dateString
+
+        const typeElem = createElem("div", modelMeta.type)
+        typeElem.title = modelMeta.type
+        const notesElem = createElem("div", modelMeta.notes)
+        notesElem.title = modelMeta.notes
+
+
+        recordRow.appendChild(actionsElem)
+        recordRow.appendChild(gameElem)
+        recordRow.appendChild(nameElem)
+        recordRow.appendChild(authorElem)
+        recordRow.appendChild(versionElem)
+        recordRow.appendChild(dateElem)
+        recordRow.appendChild(typeElem)
+        recordRow.appendChild(notesElem)
+
+        nexusRecordsContainer.appendChild(recordRow)
+    })
+}
+
+
+nexusCheckNow.addEventListener("click", () => window.getLatestModelsList())
+
+window.setupModal(nexusManageReposButton, nexusReposContainer)
+
+window.nexusUpdateModsUsedPanel = () => {
+    nexusReposUsedContainer.innerHTML = ""
+
+    window.nexusReposList.repos.forEach((repo, ri) => {
+        const row = createElem("div")
+
+        const enabledCkbx = createElem("input", {type: "checkbox"})
+        enabledCkbx.checked = repo.enabled
+        enabledCkbx.addEventListener("click", () => {
+            window.nexusReposList.repos[ri].enabled = enabledCkbx.checked
+            fs.writeFileSync(`${window.path}/repositories.json`, JSON.stringify(window.nexusReposList, null, 4), "utf8")
+        })
+        const enabledCkbxElem = createElem("div", enabledCkbx)
+
+        const removeButton = createElem("button.smallButton", window.i18n.REMOVE)
+        removeButton.style.background = `#${window.currentGame.themeColourPrimary}`
+        const removeButtonElem = createElem("div", removeButton)
+        const linkButton = createElem("button.smallButton", window.i18n.OPEN)
+        linkButton.style.background = `#${window.currentGame.themeColourPrimary}`
+        linkButton.addEventListener("click", () => {
+            shell.openExternal(repo.url)
+        })
+        const linkButtonElem = createElem("div", linkButton)
+        const gameElem = createElem("div", window.nexusGameIdToGameName[repo.game_id])
+        gameElem.title = window.nexusGameIdToGameName[repo.game_id]
+        const nameElem = createElem("div", repo.name)
+        nameElem.title = repo.name
+        const authorElem = createElem("div", repo.author)
+        authorElem.title = repo.author
+        const endorsementsElem = createElem("div", String(repo.endorsements))
+        const downloadsElem = createElem("div", String(repo.downloads))
+
+        endorsementsElem.style.display = "none" // TEMP
+        downloadsElem.style.display = "none" // TEMP
+
+        row.appendChild(enabledCkbxElem)
+        row.appendChild(linkButtonElem)
+        row.appendChild(gameElem)
+        row.appendChild(nameElem)
+        row.appendChild(authorElem)
+        row.appendChild(endorsementsElem)
+        row.appendChild(downloadsElem)
+        row.appendChild(removeButtonElem)
+        nexusReposUsedContainer.appendChild(row)
+    })
+}
+
+
+window.addRepoToApp = (repo) => {
+    repo.enabled = true
+    window.nexusReposList.repos.push(repo)
+    window.nexusReposList.repos = window.nexusReposList.repos.sort((a,b)=>a.endorsements<b.endorsements?1:-1)
+    fs.writeFileSync(`${window.path}/repositories.json`, JSON.stringify(window.nexusReposList, null, 4), "utf8")
+    window.nexusUpdateModsUsedPanel()
+}
+
+
+
+
+nexusReposSearchBar.addEventListener("keydown", e => {
+    if (e.key.toLowerCase()=="enter" && nexusReposSearchBar.value.length) {
+        searchNexusButton.click()
+    }
+})
+searchNexusButton.addEventListener("click", () => {
+    const gameId = nexusAllGamesSelect.value ? parseInt(nexusAllGamesSelect.value) : undefined
+    const query = nexusReposSearchBar.value
+    nexusSearchContainer.innerHTML = ""
+    window.mod_search_nexus(gameId, query).then(results => {
+
+        const numResults = results[0]
+        results = results[1]
+
+        results.forEach(repo => {
+
+            const row = createElem("div")
+            const addButton = createElem("button.smallButton", window.i18n.ADD)
+            const addButtonElem = createElem("div", addButton)
+            addButton.style.background = `#${window.currentGame.themeColourPrimary}`
+            if (window.nexusReposList.repos.find(r=>r.url==repo.url)) {
+                addButton.disabled = true
+            }
+            addButton.addEventListener("click", () => {
+                window.addRepoToApp(repo)
+                addButton.disabled = true
+            })
+
+            const linkButton = createElem("button.smallButton", window.i18n.OPEN)
+            linkButton.style.background = `#${window.currentGame.themeColourPrimary}`
+            linkButton.addEventListener("click", () => {
+                shell.openExternal(repo.url)
+            })
+            const linkButtonElem = createElem("div", linkButton)
+            const gameElem = createElem("div", window.nexusGameIdToGameName[repo.game_id])
+            gameElem.title = window.nexusGameIdToGameName[repo.game_id]
+            const nameElem = createElem("div", repo.name)
+            nameElem.title = repo.name
+            const authorElem = createElem("div", repo.author)
+            authorElem.title = repo.author
+            const endorsementsElem = createElem("div", String(repo.endorsements))
+            const downloadsElem = createElem("div", String(repo.downloads))
+
+
+            row.appendChild(addButtonElem)
+            row.appendChild(linkButtonElem)
+            row.appendChild(gameElem)
+            row.appendChild(nameElem)
+            row.appendChild(authorElem)
+            row.appendChild(endorsementsElem)
+            row.appendChild(downloadsElem)
+            nexusSearchContainer.appendChild(row)
+        })
+
+    })
+})
+
+nexusOnlyNewUpdatedCkbx.addEventListener("change", () => window.displayAllModels())
+window.initNexus()
+
+
+// The app will support voice installation via Steam workshop. However, workshop installations can only install voices into the game directory
+// Moreover, users can pick their own locations for voice models. To handle this, I'll have all voices go into the "workshop" folder. From here,
+// the app will (on start-up) check if there's anything there, and it will move it to the correct location
+window.checkForWorkshopInstallations = () => {
+
+    let voicesInstalled = 0
+    let badGameIDs = []
+
+    if (fs.existsSync(`${window.path}/workshop`) && fs.existsSync(`${window.path}/workshop/voices`)) {
+
+        const gameFolders = fs.readdirSync(`${window.path}/workshop/voices`)
+
+        gameFolders.forEach(gameId => {
+
+            const userModelDir = window.userSettings[`modelspath_${gameId}`]
+
+            if (!userModelDir) {
+                badGameIDs.push(gameId)
+                return
+            }
+
+            const voiceIDs_jsons = fs.readdirSync(`${window.path}/workshop/voices/${gameId}`).filter(fName => fName.endsWith(".json"))
+
+            voiceIDs_jsons.forEach(voiceIDs_json => {
+                const voiceID = voiceIDs_json.replace(".json", "")
+                const voiceFiles = fs.readdirSync(`${window.path}/workshop/voices/${gameId}`).filter(fName => fName.includes(voiceID))
+
+                voiceFiles.forEach(voiceFileName => {
+                    if (!fs.existsSync(`${userModelDir}/${voiceFileName}`)) {
+                        fs.copyFileSync(`${window.path}/workshop/voices/${gameId}/${voiceFileName}`, `${userModelDir}/${voiceFileName}`)
+                    }
+                    fs.unlinkSync(`${window.path}/workshop/voices/${gameId}/${voiceFileName}`)
+                })
+
+                voicesInstalled++
+            })
+        })
+    }
+
+    if (voicesInstalled || badGameIDs.length) {
+        setTimeout(() => {
+
+            let modalMessage = ""
+
+            if (voicesInstalled) {
+                modalMessage += window.i18n.X_WORKSHOP_VOICES_INSTALLED.replace("_1", voicesInstalled)
+            }
+            if (voicesInstalled && badGameIDs.length) {
+                modalMessage += "<br><br>"
+            }
+            if (badGameIDs) {
+                modalMessage += window.i18n.WORKSHOP_GAMES_NOT_RECOGNISED.replace("_1", badGameIDs.join(","))
+            }
+
+            createModal("error", modalMessage)
+            window.updateGameList()
+        }, 1000)
+    }
+}

javascript/outputFiles.js

@@ -0,0 +1,412 @@
+"use strict"
+
+const spawn = require("child_process").spawn
+
+window.outputFilesState = {
+    paginationIndex: 0,
+    records: [],
+    totalPages: 0
+}
+
+window.initMainPagePagination = (directory) => {
+    window.outputFilesState.records = []
+    window.outputFilesState.totalPages = 0
+    window.resetPagination()
+
+    if (!fs.existsSync(directory)) {
+        return
+    }
+
+    const records = []
+    const files = fs.readdirSync(directory)
+    files.forEach(file => {
+        if (!["wav", "mp3", "ogg", "opus", "wma", "xwm"].includes(file.split(".").reverse()[0].toLowerCase())) {
+            return
+        }
+
+        let jsonData
+
+        if (fs.existsSync(`${directory}/${file}.json`)) {
+            try {
+                const lineMeta = fs.readFileSync(`${directory}/${file}.json`, "utf8")
+                jsonData = JSON.parse(lineMeta)
+            } catch (e) {
+                // console.log(e)
+            }
+        }
+
+        const record = {}
+        record.fileName = file
+        record.lastChanged = fs.statSync(`${directory}/${file}`).mtime
+        record.jsonPath = `${directory}/${file}`
+        records.push([record, jsonData])
+    })
+
+    window.outputFilesState.records = records
+    window.reOrderMainPageRecords()
+}
+window.resetPagination = () => {
+    window.outputFilesState.paginationIndex = 0
+    const numPages = Math.ceil(window.outputFilesState.records.length/window.userSettings.output_files_pagination_size)
+    main_total_pages.innerHTML = window.i18n.PAGINATION_TOTAL_OF.replace("_1", numPages)
+    window.outputFilesState.totalPages = numPages
+    main_pageNum.value = 1
+}
+window.reOrderMainPageRecords = () => {
+    const reverse = window.userSettings.voiceRecordsOrderByOrder=="ascending"
+    const sortBy = window.userSettings.voiceRecordsOrderBy
+
+    window.outputFilesState.records = window.outputFilesState.records.sort((a,b) => {
+        if (sortBy=="name") {
+            return a[0].fileName.toLowerCase()<b[0].fileName.toLowerCase() ? (reverse?-1:1) : (reverse?1:-1)
+        } else if (sortBy=="time") {
+            return a[0].lastChanged<b[0].lastChanged ? (reverse?-1:1) : (reverse?1:-1)
+        } else {
+            console.warn("sort by type not recognised", sortBy)
+        }
+    })
+}
+
+window.makeSample = (src, newSample) => {
+    const fileName = src.split("/").reverse()[0].split("%20").join(" ")
+    const fileFormat = fileName.split(".").reverse()[0]
+    const fileNameElem = createElem("div", fileName)
+    const promptText = createElem("div.samplePromptText")
+
+    if (fs.existsSync(src+".json")) {
+        try {
+            const lineMeta = fs.readFileSync(src+".json", "utf8")
+            promptText.innerHTML = JSON.parse(lineMeta).inputSequence
+            if (promptText.innerHTML.length > 130) {
+                promptText.innerHTML = promptText.innerHTML.slice(0, 130)+"..."
+            }
+        } catch (e) {
+            // console.log(e)
+        }
+    }
+    const sample = createElem("div.sample", createElem("div", fileNameElem, promptText))
+    const audioControls = createElem("div.sampleAudioControls")
+    const audio = createElem("audio", {controls: true}, createElem("source", {
+        src: src,
+        type: `audio/${fileFormat}`
+    }))
+    audio.addEventListener("play", () => {
+        if (window.ctrlKeyIsPressed) {
+            audio.setSinkId(window.userSettings.alt_speaker)
+        } else {
+            audio.setSinkId(window.userSettings.base_speaker)
+        }
+    })
+    audio.setSinkId(window.userSettings.base_speaker)
+
+    const audioSVG = window.getAudioPlayTriangleSVG()
+    audioSVG.addEventListener("click", () => {
+        audio.play()
+    })
+
+    const openFileLocationButton = createElem("div", {title: window.i18n.OPEN_CONTAINING_FOLDER})
+    openFileLocationButton.innerHTML = `<svg class="openFolderSVG" id="svg" version="1.1" xmlns="http:\/\/www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="400" height="350" viewBox="0, 0, 400,350"><g id="svgg"><path id="path0" d="M39.960 53.003 C 36.442 53.516,35.992 53.635,30.800 55.422 C 15.784 60.591,3.913 74.835,0.636 91.617 C -0.372 96.776,-0.146 305.978,0.872 310.000 C 5.229 327.228,16.605 339.940,32.351 345.172 C 40.175 347.773,32.175 347.630,163.000 347.498 L 281.800 347.378 285.600 346.495 C 304.672 342.065,321.061 332.312,330.218 319.944 C 330.648 319.362,332.162 317.472,333.581 315.744 C 335.001 314.015,336.299 312.420,336.467 312.200 C 336.634 311.980,337.543 310.879,338.486 309.753 C 340.489 307.360,342.127 305.341,343.800 303.201 C 344.460 302.356,346.890 299.375,349.200 296.575 C 351.510 293.776,353.940 290.806,354.600 289.975 C 355.260 289.144,356.561 287.505,357.492 286.332 C 358.422 285.160,359.952 283.267,360.892 282.126 C 362.517 280.153,371.130 269.561,375.632 264.000 C 376.789 262.570,380.427 258.097,383.715 254.059 C 393.790 241.689,396.099 237.993,398.474 230.445 C 403.970 212.972,394.149 194.684,376.212 188.991 C 369.142 186.747,368.803 186.724,344.733 186.779 C 330.095 186.812,322.380 186.691,322.216 186.425 C 322.078 186.203,321.971 178.951,321.977 170.310 C 321.995 146.255,321.401 141.613,317.200 133.000 C 314.009 126.457,307.690 118.680,303.142 115.694 C 302.560 115.313,301.300 114.438,300.342 113.752 C 295.986 110.631,288.986 107.881,282.402 106.704 C 280.540 106.371,262.906 106.176,220.400 106.019 L 161.000 105.800 160.763 98.800 C 159.961 75.055,143.463 56.235,120.600 52.984 C 115.148 52.208,45.292 52.225,39.960 53.003 M120.348 80.330 C 130.472 83.988,133.993 90.369,133.998 105.071 C 134.003 120.968,137.334 127.726,147.110 131.675 L 149.400 132.600 213.800 132.807 C 272.726 132.996,278.392 133.071,280.453 133.690 C 286.872 135.615,292.306 141.010,294.261 147.400 C 294.928 149.578,294.996 151.483,294.998 168.000 L 295.000 186.200 292.800 186.449 C 291.590 186.585,254.330 186.725,210.000 186.759 C 163.866 186.795,128.374 186.977,127.000 187.186 C 115.800 188.887,104.936 192.929,96.705 198.458 C 95.442 199.306,94.302 200.000,94.171 200.000 C 93.815 200.000,89.287 203.526,87.000 205.583 C 84.269 208.039,80.083 212.649,76.488 217.159 C 72.902 221.657,72.598 222.031,70.800 224.169 C 70.030 225.084,68.770 226.620,68.000 227.582 C 67.230 228.544,66.054 229.977,65.387 230.766 C 64.720 231.554,62.727 234.000,60.957 236.200 C 59.188 238.400,56.346 241.910,54.642 244.000 C 52.938 246.090,50.163 249.510,48.476 251.600 C 44.000 257.146,36.689 266.126,36.212 266.665 C 35.985 266.921,34.900 268.252,33.800 269.623 C 32.700 270.994,30.947 273.125,29.904 274.358 C 28.861 275.591,28.006 276.735,28.004 276.900 C 28.002 277.065,27.728 277.200,27.395 277.200 C 26.428 277.200,26.700 96.271,27.670 93.553 C 30.020 86.972,35.122 81.823,40.800 80.300 C 44.238 79.378,47.793 79.296,81.800 79.351 L 117.800 79.410 120.348 80.330 M369.400 214.800 C 374.239 217.220,374.273 222.468,369.489 228.785 C 367.767 231.059,364.761 234.844,364.394 235.200 C 364.281 235.310,362.373 237.650,360.154 240.400 C 357.936 243.150,354.248 247.707,351.960 250.526 C 347.732 255.736,346.053 257.821,343.202 261.400 C 341.505 263.530,340.849 264.336,334.600 271.965 C 332.400 274.651,330.204 277.390,329.720 278.053 C 329.236 278.716,328.246 279.945,327.520 280.785 C 326.794 281.624,325.300 283.429,324.200 284.794 C 323.100 286.160,321.726 287.845,321.147 288.538 C 320.568 289.232,318.858 291.345,317.347 293.233 C 308.372 304.449,306.512 306.609,303.703 309.081 C 299.300 312.956,290.855 317.633,286.000 318.886 C 277.958 320.960,287.753 320.819,159.845 320.699 C 33.557 320.581,42.330 320.726,38.536 318.694 C 34.021 316.276,35.345 310.414,42.386 301.647 C 44.044 299.583,45.940 297.210,46.600 296.374 C 47.260 295.538,48.340 294.169,49.000 293.332 C 49.660 292.495,51.550 290.171,53.200 288.167 C 54.850 286.164,57.100 283.395,58.200 282.015 C 59.300 280.635,60.920 278.632,61.800 277.564 C 62.680 276.496,64.210 274.617,65.200 273.389 C 66.190 272.162,67.188 270.942,67.418 270.678 C 67.649 270.415,71.591 265.520,76.179 259.800 C 80.767 254.080,84.634 249.310,84.773 249.200 C 84.913 249.090,87.117 246.390,89.673 243.200 C 92.228 240.010,95.621 235.780,97.213 233.800 C 106.328 222.459,116.884 215.713,128.200 213.998 C 129.300 213.832,183.570 213.719,248.800 213.748 L 367.400 213.800 369.400 214.800 " stroke="none" fill="#050505" fill-rule="evenodd"></path><path id="path1" d="M0.000 46.800 C 0.000 72.540,0.072 93.600,0.159 93.600 C 0.246 93.600,0.516 92.460,0.759 91.066 C 3.484 75.417,16.060 60.496,30.800 55.422 C 35.953 53.648,36.338 53.550,40.317 52.981 C 46.066 52.159,114.817 52.161,120.600 52.984 C 143.463 56.235,159.961 75.055,160.763 98.800 L 161.000 105.800 220.400 106.019 C 262.906 106.176,280.540 106.371,282.402 106.704 C 288.986 107.881,295.986 110.631,300.342 113.752 C 301.300 114.438,302.560 115.313,303.142 115.694 C 307.690 118.680,314.009 126.457,317.200 133.000 C 321.401 141.613,321.995 146.255,321.977 170.310 C 321.971 178.951,322.078 186.203,322.216 186.425 C 322.380 186.691,330.095 186.812,344.733 186.779 C 368.803 186.724,369.142 186.747,376.212 188.991 C 381.954 190.814,388.211 194.832,391.662 198.914 C 395.916 203.945,397.373 206.765,399.354 213.800 C 399.842 215.533,399.922 201.399,399.958 107.900 L 400.000 0.000 200.000 0.000 L 0.000 0.000 0.000 46.800 M44.000 79.609 C 35.903 81.030,30.492 85.651,27.670 93.553 C 26.700 96.271,26.428 277.200,27.395 277.200 C 27.728 277.200,28.002 277.065,28.004 276.900 C 28.006 276.735,28.861 275.591,29.904 274.358 C 30.947 273.125,32.700 270.994,33.800 269.623 C 34.900 268.252,35.985 266.921,36.212 266.665 C 36.689 266.126,44.000 257.146,48.476 251.600 C 50.163 249.510,52.938 246.090,54.642 244.000 C 56.346 241.910,59.188 238.400,60.957 236.200 C 62.727 234.000,64.720 231.554,65.387 230.766 C 66.054 229.977,67.230 228.544,68.000 227.582 C 68.770 226.620,70.030 225.084,70.800 224.169 C 72.598 222.031,72.902 221.657,76.488 217.159 C 80.083 212.649,84.269 208.039,87.000 205.583 C 89.287 203.526,93.815 200.000,94.171 200.000 C 94.302 200.000,95.442 199.306,96.705 198.458 C 104.936 192.929,115.800 188.887,127.000 187.186 C 128.374 186.977,163.866 186.795,210.000 186.759 C 254.330 186.725,291.590 186.585,292.800 186.449 L 295.000 186.200 294.998 168.000 C 294.996 151.483,294.928 149.578,294.261 147.400 C 292.306 141.010,286.872 135.615,280.453 133.690 C 278.392 133.071,272.726 132.996,213.800 132.807 L 149.400 132.600 147.110 131.675 C 137.334 127.726,134.003 120.968,133.998 105.071 C 133.993 90.369,130.472 83.988,120.348 80.330 L 117.800 79.410 81.800 79.351 C 62.000 79.319,44.990 79.435,44.000 79.609 M128.200 213.998 C 116.884 215.713,106.328 222.459,97.213 233.800 C 95.621 235.780,92.228 240.010,89.673 243.200 C 87.117 246.390,84.913 249.090,84.773 249.200 C 84.634 249.310,80.767 254.080,76.179 259.800 C 71.591 265.520,67.649 270.415,67.418 270.678 C 67.188 270.942,66.190 272.162,65.200 273.389 C 64.210 274.617,62.680 276.496,61.800 277.564 C 60.920 278.632,59.300 280.635,58.200 282.015 C 57.100 283.395,54.850 286.164,53.200 288.167 C 51.550 290.171,49.660 292.495,49.000 293.332 C 48.340 294.169,47.260 295.538,46.600 296.374 C 45.940 297.210,44.044 299.583,42.386 301.647 C 35.345 310.414,34.021 316.276,38.536 318.694 C 42.330 320.726,33.557 320.581,159.845 320.699 C 287.753 320.819,277.958 320.960,286.000 318.886 C 290.855 317.633,299.300 312.956,303.703 309.081 C 306.512 306.609,308.372 304.449,317.347 293.233 C 318.858 291.345,320.568 289.232,321.147 288.538 C 321.726 287.845,323.100 286.160,324.200 284.794 C 325.300 283.429,326.794 281.624,327.520 280.785 C 328.246 279.945,329.236 278.716,329.720 278.053 C 330.204 277.390,332.400 274.651,334.600 271.965 C 340.849 264.336,341.505 263.530,343.202 261.400 C 346.053 257.821,347.732 255.736,351.960 250.526 C 354.248 247.707,357.936 243.150,360.154 240.400 C 362.373 237.650,364.281 235.310,364.394 235.200 C 364.761 234.844,367.767 231.059,369.489 228.785 C 374.273 222.468,374.239 217.220,369.400 214.800 L 367.400 213.800 248.800 213.748 C 183.570 213.719,129.300 213.832,128.200 213.998 M399.600 225.751 C 399.600 231.796,394.623 240.665,383.715 254.059 C 380.427 258.097,376.789 262.570,375.632 264.000 C 371.130 269.561,362.517 280.153,360.892 282.126 C 359.952 283.267,358.422 285.160,357.492 286.332 C 356.561 287.505,355.260 289.144,354.600 289.975 C 353.940 290.806,351.510 293.776,349.200 296.575 C 346.890 299.375,344.460 302.356,343.800 303.201 C 342.127 305.341,340.489 307.360,338.486 309.753 C 337.543 310.879,336.634 311.980,336.467 312.200 C 336.299 312.420,335.001 314.015,333.581 315.744 C 332.162 317.472,330.648 319.362,330.218 319.944 C 321.061 332.312,304.672 342.065,285.600 346.495 L 281.800 347.378 163.000 347.498 C 32.175 347.630,40.175 347.773,32.351 345.172 C 16.471 339.895,3.810 325.502,0.820 309.326 C 0.591 308.085,0.312 306.979,0.202 306.868 C 0.091 306.757,-0.000 327.667,-0.000 353.333 L 0.000 400.000 200.000 400.000 L 400.000 400.000 400.000 312.400 C 400.000 264.220,399.910 224.800,399.800 224.800 C 399.690 224.800,399.600 225.228,399.600 225.751 " stroke="none" fill="#fbfbfb" fill-rule="evenodd"></path></g></svg>`
+    openFileLocationButton.addEventListener("click", () => {
+        const containingFolder = src.split("/").slice(0, -1).join("/").replaceAll("/", "\\")
+        // shell.showItemInFolder(src)
+        // er.shell.showItemInFolder(src)
+
+        // Electron suddenly isn't working anymore, to open folders, since updating from v2 to v19
+        // Couldn't figure it out, so I'm just gonna do it myself, manually. It doesn't show the file, but at least it opens the folder
+
+        er.shell.showItemInFolder(src)
+        spawn(`explorer`, [containingFolder], {stdio: "ignore"})
+    })
+
+    if (fs.existsSync(`${src}.json`)) {
+        const editButton = createElem("div", {title: window.i18n.ADJUST_SAMPLE_IN_EDITOR})
+        editButton.innerHTML = `<svg class="renameSVG" version="1.0" xmlns="http:\/\/www.w3.org/2000/svg" width="344.000000pt" height="344.000000pt" viewBox="0 0 344.000000 344.000000" preserveAspectRatio="xMidYMid meet"><g transform="translate(0.000000,344.000000) scale(0.100000,-0.100000)" fill="#555555" stroke="none"><path d="M1489 2353 l-936 -938 -197 -623 c-109 -343 -195 -626 -192 -629 2 -3 284 84 626 193 l621 198 937 938 c889 891 937 940 934 971 -11 108 -86 289 -167 403 -157 219 -395 371 -655 418 l-34 6 -937 -937z m1103 671 c135 -45 253 -135 337 -257 41 -61 96 -178 112 -241 l12 -48 -129 -129 -129 -129 -287 287 -288 288 127 127 c79 79 135 128 148 128 11 0 55 -12 97 -26z m-1798 -1783 c174 -79 354 -248 436 -409 59 -116 72 -104 -213 -196 l-248 -80 -104 104 c-58 58 -105 109 -105 115 0 23 154 495 162 495 5 0 37 -13 72 -29z"/></g></svg>`
+        editButton.addEventListener("click", () => {
+
+            const doTheRest = () => {
+                let editData = fs.readFileSync(`${src}.json`, "utf8")
+                editData = JSON.parse(editData)
+
+                generateVoiceButton.dataset.modelIDLoaded = editData.pitchEditor ? editData.pitchEditor.currentVoice : editData.currentVoice
+
+                window.sequenceEditor.historyState.push(editData.inputSequence.trim())
+                window.sequenceEditor.isEditingFromFile = true
+                window.sequenceEditor.inputSequence = editData.inputSequence
+                window.sequenceEditor.pacing = editData.pacing
+                window.sequenceEditor.letters = editData.pitchEditor ? editData.pitchEditor.letters : editData.letters
+                window.sequenceEditor.currentVoice = editData.pitchEditor ? editData.pitchEditor.currentVoice : editData.currentVoice
+                window.sequenceEditor.resetEnergy = (editData.pitchEditor && editData.pitchEditor.resetEnergy) ? editData.pitchEditor.resetEnergy : editData.resetEnergy
+                window.sequenceEditor.resetPitch = editData.pitchEditor ? editData.pitchEditor.resetPitch : editData.resetPitch
+                window.sequenceEditor.resetDurs = editData.pitchEditor ? editData.pitchEditor.resetDurs : editData.resetDurs
+                window.sequenceEditor.resetEmAngry = editData.resetEmAngry
+                window.sequenceEditor.resetEmHappy = editData.resetEmHappy
+                window.sequenceEditor.resetEmSad = editData.resetEmSad
+                window.sequenceEditor.resetEmSurprise = editData.resetEmSurprise
+                window.sequenceEditor.letterFocus = []
+                window.sequenceEditor.ampFlatCounter = 0
+                window.sequenceEditor.hasChanged = false
+                window.sequenceEditor.sequence = editData.pitchEditor ? editData.pitchEditor.sequence : editData.sequence
+                window.sequenceEditor.energyNew = (editData.pitchEditor && editData.pitchEditor.energyNew) ? editData.pitchEditor.energyNew : editData.energyNew
+                window.sequenceEditor.pitchNew = editData.pitchEditor ? editData.pitchEditor.pitchNew : editData.pitchNew
+                window.sequenceEditor.dursNew = editData.pitchEditor ? editData.pitchEditor.dursNew : editData.dursNew
+                window.sequenceEditor.emAngryNew = editData.emAngryNew
+                window.sequenceEditor.emHappyNew = editData.emHappyNew
+                window.sequenceEditor.emSadNew = editData.emSadNew
+                window.sequenceEditor.emSurpriseNew = editData.emSurpriseNew
+
+                if (editData.styleValuesReset) {
+                    window.sequenceEditor.loadStylesData()
+
+                    window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+                        window.sequenceEditor.styleValuesReset[styleKey] = editData.styleValuesReset[styleKey]
+                        window.sequenceEditor.styleValuesNew[styleKey] = editData.styleValuesNew[styleKey]
+                    })
+                }
+
+
+                window.sequenceEditor.init()
+                window.sequenceEditor.update(window.currentModel.modelType)
+                window.sequenceEditor.autoInferTimer = null
+
+                dialogueInput.value = editData.inputSequence
+                window.refreshText()
+                paceNumbInput.value = editData.pacing
+                pace_slid.value = editData.pacing
+
+                window.sequenceEditor.sliderBoxes.forEach((box, i) => {box.setValueFromValue(window.sequenceEditor.dursNew[i])})
+                window.sequenceEditor.update(window.currentModel.modelType)
+
+                if (!window.wavesurfer) {
+                    window.initWaveSurfer(src)
+                } else {
+                    window.wavesurfer.load(src)
+                }
+
+                samplePlayPause.style.display = "block"
+            }
+
+            if (window.currentModel.loaded) {
+                doTheRest()
+            } else {
+                window.loadModel().then(() => {
+                    doTheRest()
+                })
+            }
+        })
+        audioControls.appendChild(editButton)
+    }
+
+    const renameButton = createElem("div", {title: window.i18n.RENAME_THE_FILE})
+    renameButton.innerHTML = `<svg class="renameSVG" version="1.0" xmlns="http://www.w3.org/2000/svg" width="166.000000pt" height="336.000000pt" viewBox="0 0 166.000000 336.000000" preserveAspectRatio="xMidYMid meet"><g transform="translate(0.000000,336.000000) scale(0.100000,-0.100000)" fill="#000000" stroke="none"> <path d="M165 3175 c-30 -31 -35 -42 -35 -84 0 -34 6 -56 21 -75 42 -53 58 -56 324 -56 l245 0 0 -1290 0 -1290 -245 0 c-266 0 -282 -3 -324 -56 -15 -19 -21 -41 -21 -75 0 -42 5 -53 35 -84 l36 -35 281 0 280 0 41 40 c30 30 42 38 48 28 5 -7 9 -16 9 -21 0 -4 15 -16 33 -27 30 -19 51 -20 319 -20 l287 0 36 35 c30 31 35 42 35 84 0 34 -6 56 -21 75 -42 53 -58 56 -324 56 l-245 0 0 1290 0 1290 245 0 c266 0 282 3 324 56 15 19 21 41 21 75 0 42 -5 53 -35 84 l-36 35 -287 0 c-268 0 -289 -1 -319 -20 -18 -11 -33 -23 -33 -27 0 -5 -4 -14 -9 -21 -6 -10 -18 -2 -48 28 l-41 40 -280 0 -281 0 -36 -35z"/></g></svg>`
+
+    renameButton.addEventListener("click", () => {
+        createModal("prompt", {
+            prompt: window.i18n.ENTER_NEW_FILENAME_UNCHANGED_CANCEL,
+            value: sample.querySelector("div").innerHTML
+        }).then(newFileName => {
+            if (newFileName!=fileName) {
+                const oldPath = src.split("/").reverse()
+                const newPath = src.split("/").reverse()
+                oldPath[0] = sample.querySelector("div").innerHTML
+                newPath[0] = newFileName
+
+                const oldPathComposed = oldPath.reverse().join("/")
+                const newPathComposed = newPath.reverse().join("/")
+                fs.renameSync(oldPathComposed, newPathComposed)
+
+                if (fs.existsSync(`${oldPathComposed}.json`)) {
+                    fs.renameSync(oldPathComposed+".json", newPathComposed+".json")
+                }
+                if (fs.existsSync(`${oldPathComposed.replace(/\.wav$/, "")}.lip`)) {
+                    fs.renameSync(oldPathComposed.replace(/\.wav$/, "")+".lip", newPathComposed.replace(/\.wav$/, "")+".lip")
+                }
+                if (fs.existsSync(`${oldPathComposed.replace(/\.wav$/, "")}.fuz`)) {
+                    fs.renameSync(oldPathComposed.replace(/\.wav$/, "")+".fuz", newPathComposed.replace(/\.wav$/, "")+".fuz")
+                }
+
+                oldPath.reverse()
+                oldPath.splice(0,1)
+                refreshRecordsList(oldPath.reverse().join("/"))
+            }
+        })
+    })
+
+    const editInProgramButton = createElem("div", {title: window.i18n.EDIT_IN_EXTERNAL_PROGRAM})
+    editInProgramButton.innerHTML = `<svg class="renameSVG" version="1.0" width="175.000000pt" height="240.000000pt" viewBox="0 0 175.000000 240.000000"  preserveAspectRatio="xMidYMid meet"><g transform="translate(0.000000,240.000000) scale(0.100000,-0.100000)" fill="#000000" stroke="none"><path d="M615 2265 l-129 -125 -68 0 c-95 0 -98 -4 -98 -150 0 -146 3 -150 98 -150 l68 0 129 -125 c128 -123 165 -145 179 -109 8 20 8 748 0 768 -14 36 -51 14 -179 -109z"/> <path d="M1016 2344 c-22 -21 -20 -30 10 -51 66 -45 126 -109 151 -162 22 -47 27 -69 27 -141 0 -72 -5 -94 -27 -141 -25 -53 -85 -117 -151 -162 -30 -20 -33 -39 -11 -57 22 -18 64 3 132 64 192 173 164 491 -54 636 -54 35 -56 35 -77 14z"/> <path d="M926 2235 c-8 -22 1 -37 46 -70 73 -53 104 -149 78 -241 -13 -44 -50 -92 -108 -136 -26 -21 -27 -31 -6 -52 37 -38 150 68 179 167 27 91 13 181 -41 259 -49 70 -133 112 -148 73z"/> <path d="M834 2115 c-9 -23 2 -42 33 -57 53 -25 56 -108 4 -134 -35 -18 -44 -30 -36 -53 8 -25 34 -27 76 -6 92 48 92 202 0 250 -38 19 -70 19 -77 0z"/> <path d="M1381 1853 c-33 -47 -182 -253 -264 -364 -100 -137 -187 -262 -187 -270 0 -8 140 -204 177 -249 5 -6 41 41 109 141 30 45 60 86 65 93 48 54 197 276 226 336 33 68 37 83 37 160 1 71 -3 93 -23 130 -53 101 -82 106 -140 23z"/> <path d="M211 1861 c-56 -60 -68 -184 -27 -283 15 -38 106 -168 260 -371 130 -173 236 -320 236 -328 0 -8 -9 -25 -20 -39 -11 -14 -20 -29 -20 -33 0 -5 -10 -23 -23 -40 -12 -18 -27 -41 -33 -52 -13 -24 -65 -114 -80 -138 -10 -17 -13 -16 -60 7 -98 49 -209 43 -305 -17 -83 -51 -129 -141 -129 -251 0 -161 115 -283 275 -294 101 -6 173 22 243 96 56 58 79 97 133 227 46 112 101 203 164 274 l53 60 42 -45 c27 -29 69 -103 124 -217 86 -176 133 -250 197 -306 157 -136 405 -73 478 123 37 101 21 202 -46 290 -91 118 -275 147 -402 63 -30 -20 -42 -23 -49 -14 -5 7 -48 82 -96 167 -47 85 -123 202 -168 260 -45 58 -111 143 -146 190 -85 110 -251 326 -321 416 -31 40 -65 84 -76 100 -11 15 -35 46 -54 68 -19 23 -45 58 -59 79 -30 45 -54 47 -91 8z m653 -943 c20 -28 20 -33 0 -52 -42 -43 -109 10 -69 54 24 26 50 25 69 -2z m653 -434 c49 -20 87 -85 87 -149 -2 -135 -144 -209 -257 -134 -124 82 -89 265 58 299 33 8 64 4 112 -16z m-1126 -20 c47 -24 73 -71 77 -139 3 -50 0 -65 -20 -94 -34 -50 -71 -73 -125 -78 -99 -9 -173 53 -181 152 -11 135 126 223 249 159z"/></g></svg>`
+    editInProgramButton.addEventListener("click", () => {
+
+        if (window.userSettings.externalAudioEditor && window.userSettings.externalAudioEditor.length) {
+            const fileName = audio.children[0].src.split("file:///")[1].split("%20").join(" ")
+            const sp = spawn(window.userSettings.externalAudioEditor, [fileName], {'detached': true}, (err, data) => {
+                if (err) {
+                    console.log(err)
+                    console.log(err.message)
+                    window.errorModal(err.message)
+                }
+            })
+
+            sp.on("error", err => {
+                if (err.message.includes("ENOENT")) {
+                    window.errorModal(`${window.i18n.FOLLOWING_PATH_NOT_VALID}:<br><br> ${window.userSettings.externalAudioEditor}`)
+                } else {
+                    window.errorModal(err.message)
+                }
+            })
+
+        } else {
+            window.errorModal(window.i18n.SPECIFY_EDIT_TOOL)
+        }
+    })
+
+
+    const deleteFileButton = createElem("div", {title: window.i18n.DELETE_FILE})
+    deleteFileButton.innerHTML = "&#10060;"
+    deleteFileButton.addEventListener("click", () => {
+        confirmModal(`${window.i18n.SURE_DELETE}<br><br><i>${fileName}</i>`).then(confirmation => {
+            if (confirmation) {
+                window.appLogger.log(`${newSample?window.i18n.DELETING_NEW_FILE:window.i18n.DELETING}: ${src}`)
+                if (fs.existsSync(src)) {
+                    fs.unlinkSync(src)
+                }
+                sample.remove()
+                if (fs.existsSync(`${src}.json`)) {
+                    fs.unlinkSync(`${src}.json`)
+                }
+            }
+        })
+    })
+    audioControls.appendChild(renameButton)
+    audioControls.appendChild(audioSVG)
+    audioControls.appendChild(editInProgramButton)
+    audioControls.appendChild(openFileLocationButton)
+    audioControls.appendChild(deleteFileButton)
+    sample.appendChild(audioControls)
+    return sample
+}
+
+
+window.refreshRecordsList = () => {
+    voiceSamples.innerHTML = ""
+    const outputFilesPaginationSize = window.userSettings.output_files_pagination_size
+
+
+    const filteredRecords = window.outputFilesState.records.filter(recordAndJson => {
+        if (!recordAndJson[0].fileName.toLowerCase().includes(voiceSamplesSearch.value.toLowerCase().trim())) {
+            return
+        }
+        if (voiceSamplesSearchPrompt.value.length) {
+            if (!recordAndJson[1] || !recordAndJson[1].inputSequence.toLowerCase().includes(voiceSamplesSearchPrompt.value.toLowerCase().trim())) {
+                return
+            }
+        }
+        return recordAndJson
+    })
+
+
+    const startIndex = (window.outputFilesState.paginationIndex*outputFilesPaginationSize)
+    const endIndex = Math.min(startIndex+outputFilesPaginationSize, filteredRecords.length)
+
+    for (let ri=startIndex; ri<endIndex; ri++) {
+        voiceSamples.appendChild(window.makeSample(filteredRecords[ri][0].jsonPath))
+    }
+    const numPages = Math.ceil(filteredRecords.length/outputFilesPaginationSize)
+    main_total_pages.innerHTML = window.i18n.PAGINATION_TOTAL_OF.replace("_1", numPages)
+    window.outputFilesState.totalPages = numPages
+}
+main_paginationPrev.addEventListener("click", () => {
+    main_pageNum.value = Math.max(1, parseInt(main_pageNum.value)-1)
+    window.outputFilesState.paginationIndex = main_pageNum.value-1
+    window.refreshRecordsList()
+})
+main_paginationNext.addEventListener("click", () => {
+    main_pageNum.value = Math.min(parseInt(main_pageNum.value)+1, window.outputFilesState.totalPages)
+    window.outputFilesState.paginationIndex = main_pageNum.value-1
+    window.refreshRecordsList()
+})
+
+
+// Delete all output files for a voice
+voiceRecordsDeleteAllButton.addEventListener("click", () => {
+    if (window.currentModel) {
+        const outDir = window.userSettings[`outpath_${window.currentGame.gameId}`]+`/${currentModel.voiceId}`
+
+        const files = fs.readdirSync(outDir)
+        if (files.length) {
+            window.confirmModal(window.i18n.DELETE_ALL_FILES_CONFIRM.replace("_1", files.length).replace("_2", outDir)).then(resp => {
+                if (resp) {
+                    window.deleteFolderRecursive(outDir, true)
+                    window.initMainPagePagination(outDir)
+                    window.refreshRecordsList()
+                }
+            })
+        } else {
+            window.errorModal(window.i18n.DELETE_ALL_FILES_ERR_NO_FILES.replace("_1", outDir))
+        }
+    }
+})
+
+voiceRecordsOrderByButton.addEventListener("click", () => {
+    window.userSettings.voiceRecordsOrderBy = window.userSettings.voiceRecordsOrderBy=="name" ? "time" : "name"
+    saveUserSettings()
+    const labels = {
+        "name": window.i18n.NAME,
+        "time": window.i18n.TIME
+    }
+    voiceRecordsOrderByButton.innerHTML = labels[window.userSettings.voiceRecordsOrderBy]
+    if (window.currentModel) {
+        const voiceRecordsList = window.userSettings[`outpath_${window.currentGame.gameId}`]+`/${window.currentModel.voiceId}`
+        window.reOrderMainPageRecords()
+        window.refreshRecordsList()
+    }
+})
+voiceRecordsOrderByOrderButton.addEventListener("click", () => {
+    window.userSettings.voiceRecordsOrderByOrder = window.userSettings.voiceRecordsOrderByOrder=="ascending" ? "descending" : "ascending"
+    saveUserSettings()
+    const labels = {
+        "ascending": window.i18n.ASCENDING,
+        "descending": window.i18n.DESCENDING
+    }
+    voiceRecordsOrderByOrderButton.innerHTML = labels[window.userSettings.voiceRecordsOrderByOrder]
+    if (window.currentModel) {
+        const voiceRecordsList = window.userSettings[`outpath_${window.currentGame.gameId}`]+`/${window.currentModel.voiceId}`
+        window.reOrderMainPageRecords()
+        window.refreshRecordsList()
+    }
+})
+voiceSamplesSearch.addEventListener("keyup", () => {
+    if (window.currentModel) {
+        window.outputFilesState.paginationIndex = 0
+        main_pageNum.value = 1
+        const voiceRecordsList = window.userSettings[`outpath_${window.currentGame.gameId}`]+`/${window.currentModel.voiceId}`
+        window.refreshRecordsList()
+    }
+})
+voiceSamplesSearchPrompt.addEventListener("keyup", () => {
+    if (window.currentModel) {
+        window.outputFilesState.paginationIndex = 0
+        main_pageNum.value = 1
+        const voiceRecordsList = window.userSettings[`outpath_${window.currentGame.gameId}`]+`/${window.currentModel.voiceId}`
+        window.refreshRecordsList()
+    }
+})
+
+if (Object.keys(window.userSettings).includes("voiceRecordsOrderBy")) {
+    const labels = {
+        "name": window.i18n.NAME,
+        "time": window.i18n.TIME
+    }
+    voiceRecordsOrderByButton.innerHTML = labels[window.userSettings.voiceRecordsOrderBy]
+} else {
+    window.userSettings.voiceRecordsOrderBy = "name"
+    saveUserSettings()
+}
+if (Object.keys(window.userSettings).includes("voiceRecordsOrderByOrder")) {
+    const labels = {
+        "ascending": window.i18n.ASCENDING,
+        "descending": window.i18n.DESCENDING
+    }
+    voiceRecordsOrderByOrderButton.innerHTML = labels[window.userSettings.voiceRecordsOrderByOrder]
+} else {
+    window.userSettings.voiceRecordsOrderByOrder = "ascending"
+    saveUserSettings()
+}

javascript/plugins_manager.js

@@ -0,0 +1,594 @@
+"use strict"
+
+const fs = require("fs")
+const er = require('@electron/remote')
+
+class PluginsManager {
+
+    constructor (path, appLogger, appVersion) {
+
+        this.path = `${__dirname.replace(/\\/g,"/").replace("/javascript", "")}/`.replace("/resources/app/resources/app", "/resources/app")
+        this.appVersion = appVersion
+        this.appLogger = appLogger
+        this.plugins = []
+        this.selectedPlugin = undefined
+        this.hasRunPostStartPlugins = false
+        this.changesToApply = {
+            ticked: [],
+            unticked: []
+        }
+        this.teardownModules = {}
+        this.resetModules()
+
+
+        this.scanPlugins()
+        this.savePlugins()
+        this.appLogger.log(`${this.path}/plugins`)
+        if (fs.existsSync(`${this.path}/plugins`)) {
+            fs.watch(`${this.path}/plugins`, {recursive: false, persistent: true}, (eventType, filename) => {
+                this.scanPlugins()
+                this.updateUI()
+                this.savePlugins()
+            })
+        }
+
+        plugins_moveUpBtn.addEventListener("click", () => {
+
+            if (!this.selectedPlugin || this.selectedPlugin[1]==0) return
+
+            const plugin = this.plugins.splice(this.selectedPlugin[1], 1)[0]
+            this.plugins.splice(this.selectedPlugin[1]-1, 0, plugin)
+            this.selectedPlugin[1] -= 1
+            this.updateUI()
+            plugins_applyBtn.disabled = false
+        })
+
+        plugins_moveDownBtn.addEventListener("click", () => {
+
+            if (!this.selectedPlugin || this.selectedPlugin[1]==this.plugins.length-1) return
+
+            const plugin = this.plugins.splice(this.selectedPlugin[1], 1)[0]
+            this.plugins.splice(this.selectedPlugin[1]+1, 0, plugin)
+            this.selectedPlugin[1] += 1
+            this.updateUI()
+            plugins_applyBtn.disabled = false
+        })
+
+        plugins_applyBtn.addEventListener("click", () => this.apply())
+        plugins_main.addEventListener("click", (e) => {
+            if (e.target == plugins_main) {
+                this.selectedPlugin = undefined
+                this.updateUI()
+            }
+        })
+
+        window.pluginsManager = this
+        this.loadModules()
+    }
+
+    resetModules () {
+        this.setupModules = new Set()
+        this.pluginsModules = {
+            "start": {
+                "pre": [],
+                "post": []
+            },
+            "keep-sample": {
+                "pre": [],
+                "mid": [],
+                "post": []
+            },
+            "batch-stop": {
+                "post": []
+            },
+            "generate-voice": {
+                "pre": []
+            }
+        }
+        pluginsCSS.innerHTML = ""
+    }
+
+    scanPlugins () {
+
+        const plugins = []
+
+        try {
+            const pluginIDs = fs.readdirSync(`${this.path}/plugins`)
+            pluginIDs.forEach(pluginId => {
+                try {
+                    const pluginData = JSON.parse(fs.readFileSync(`${this.path}/plugins/${pluginId}/plugin.json`))
+
+                    const minVersionOk = window.checkVersionRequirements(pluginData["min-app-version"], this.appVersion)
+                    const maxVersionOk = window.checkVersionRequirements(pluginData["max-app-version"], this.appVersion, true)
+
+                    plugins.push([pluginId, pluginData, false, minVersionOk, maxVersionOk])
+
+                } catch (e) {
+                    this.appLogger.log(`${window.i18n.ERR_LOADING_PLUGIN} ${pluginId}: ${e}`)
+                }
+            })
+
+
+        } catch (e) {
+            console.log(e)
+        }
+
+        const orderedPlugins = []
+
+        // Order the found known plugins
+        window.userSettings.plugins.loadOrder.split(",").forEach(pluginId => {
+            for (let i=0; i<plugins.length; i++) {
+                if (pluginId.replace("*", "")==plugins[i][0]) {
+                    plugins[i][2] = pluginId.includes("*") && plugins[i][3] && plugins[i][4]
+                    orderedPlugins.push(plugins[i])
+                    plugins.splice(i,1)
+                    break
+                }
+            }
+        })
+
+        // Add any remaining (new) plugins at the bottom of the list
+        plugins.forEach(p => orderedPlugins.push(p))
+        this.plugins = orderedPlugins
+    }
+
+    updateUI () {
+
+        pluginsRecordsContainer.innerHTML = ""
+
+        this.plugins.forEach(([pluginId, pluginData, isEnabled, minVersionOk, maxVersionOk], pi) => {
+            const record = createElem("div")
+            const enabledCkbx = createElem("input", {type: "checkbox"})
+            enabledCkbx.checked = isEnabled
+            record.appendChild(createElem("div", enabledCkbx))
+            record.appendChild(createElem("div", `${pi}`))
+
+            const pluginNameElem = createElem("div", pluginData["plugin-name"])
+            pluginNameElem.title = pluginData["plugin-name"]
+            record.appendChild(pluginNameElem)
+
+            const pluginAuthorElem = createElem("div", pluginData["author"]||"")
+            pluginAuthorElem.title = pluginData["author"]||""
+            record.appendChild(pluginAuthorElem)
+
+            const endorseButtonContainer = createElem("div")
+            record.appendChild(endorseButtonContainer)
+            if (pluginData["nexus-link"] && window.nexusState.key) {
+
+                if (window.nexusState.key) {
+                    window.nexus_getData(`${pluginData["nexus-link"].split(".com/")[1]}.json`).then(repoInfo => {
+                        const endorseButton = createElem("button.smallButton", "Endorse")
+                        const gameId = repoInfo.game_id
+                        const nexusRepoId = repoInfo.mod_id
+
+                        if (repoInfo.endorsement.endorse_status=="Endorsed") {
+                            window.endorsedRepos.add(`plugin:${pluginId}`)
+                            endorseButton.innerHTML = "Unendorse"
+                            endorseButton.style.background = "none"
+                            endorseButton.style.border = `2px solid #${window.currentGame ? currentGame.themeColourPrimary : "aaa"}`
+                        } else {
+                            endorseButton.style.setProperty("background-color", `#${window.currentGame ? currentGame.themeColourPrimary : "aaa"}`, "important")
+                        }
+
+                        endorseButtonContainer.appendChild(endorseButton)
+                        endorseButton.addEventListener("click", async () => {
+                            let response
+                            if (window.endorsedRepos.has(`plugin:${pluginId}`)) {
+                                response = await window.nexus_getData(`${gameId}/mods/${nexusRepoId}/abstain.json`, {
+                                    game_domain_name: gameId,
+                                    id: nexusRepoId,
+                                    version: repoInfo.version
+                                }, "POST")
+                            } else {
+                                response = await window.nexus_getData(`${gameId}/mods/${nexusRepoId}/endorse.json`, {
+                                    game_domain_name: gameId,
+                                    id: nexusRepoId,
+                                    version: repoInfo.version
+                                }, "POST")
+                            }
+                            if (response && response.message && response.status=="Error") {
+                                if (response.message=="NOT_DOWNLOADED_MOD") {
+                                    response.message = "You need to first download something from this repo to be able to endorse it."
+                                } else if (response.message=="TOO_SOON_AFTER_DOWNLOAD") {
+                                    response.message = "Nexus requires you to wait at least 15 mins (at the time of writing) before you can endorse."
+                                } else if (response.message=="IS_OWN_MOD") {
+                                    response.message = "Nexus does not allow you to rate your own content."
+                                }
+
+                                window.errorModal(response.message)
+                            } else {
+
+                                if (window.endorsedRepos.has(`plugin:${pluginId}`)) {
+                                    window.endorsedRepos.delete(`plugin:${pluginId}`)
+                                } else {
+                                    window.endorsedRepos.add(`plugin:${pluginId}`)
+                                }
+                                this.updateUI()
+                            }
+                        })
+                    })
+                }
+            }
+
+
+            const hasBackendScript = !!Object.keys(pluginData["back-end-hooks"]).find(key => {
+                return (key=="custom-event" && pluginData["back-end-hooks"]["custom-event"]["file"]) ||
+                (pluginData["back-end-hooks"][key]["pre"] && pluginData["back-end-hooks"][key]["pre"]["file"]) ||
+                (pluginData["back-end-hooks"][key]["mid"] && pluginData["back-end-hooks"][key]["mid"]["file"]) ||
+                (pluginData["back-end-hooks"][key]["post"] && pluginData["back-end-hooks"][key]["post"]["file"])
+            })
+            const hasFrontendScript = !!pluginData["front-end-hooks"]
+            const type =  hasFrontendScript && hasBackendScript ? "Both": (!hasFrontendScript && !hasBackendScript ? "None" : (hasFrontendScript ? "Front" : "Back"))
+
+            record.appendChild(createElem("div", pluginData["plugin-version"]))
+            record.appendChild(createElem("div", type))
+            // Min app version requirement
+            const minAppVersionElem = createElem("div", pluginData["min-app-version"])
+            record.appendChild(minAppVersionElem)
+            if (pluginData["min-app-version"] && !minVersionOk) {
+                minAppVersionElem.style.color = "red"
+                enabledCkbx.checked = false
+                enabledCkbx.disabled = true
+            }
+
+            // Max app version requirement
+            const maxAppVersionElem = createElem("div", pluginData["max-app-version"])
+            record.appendChild(maxAppVersionElem)
+            if (pluginData["max-app-version"] && !maxVersionOk) {
+                maxAppVersionElem.style.color = "red"
+                enabledCkbx.checked = false
+                enabledCkbx.disabled = true
+            }
+
+            const shortDescriptionElem = createElem("div", pluginData["plugin-short-description"])
+            shortDescriptionElem.title = pluginData["plugin-short-description"]
+            record.appendChild(shortDescriptionElem)
+
+            const pluginIdElem = createElem("div", pluginId)
+            pluginIdElem.title = pluginId
+            record.appendChild(pluginIdElem)
+
+            pluginsRecordsContainer.appendChild(record)
+
+            enabledCkbx.addEventListener("click", () => {
+                this.plugins[pi][2] = enabledCkbx.checked
+                plugins_applyBtn.disabled = false
+            })
+
+            record.addEventListener("click", (e) => {
+
+                if (e.target==enabledCkbx || e.target.nodeName=="BUTTON") {
+                    return
+                }
+
+                if (this.selectedPlugin) {
+                    this.selectedPlugin[0].style.background = "none"
+                    Array.from(this.selectedPlugin[0].children).forEach(child => child.style.color = "white")
+                }
+
+                this.selectedPlugin = [record, pi, pluginData]
+                this.selectedPlugin[0].style.background = "white"
+                Array.from(this.selectedPlugin[0].children).forEach(child => child.style.color = "black")
+
+                plugins_moveUpBtn.disabled = false
+                plugins_moveDownBtn.disabled = false
+
+            })
+            if (this.selectedPlugin && pi==this.selectedPlugin[1]) {
+                this.selectedPlugin = [record, pi, pluginData]
+                this.selectedPlugin[0].style.background = "white"
+                Array.from(this.selectedPlugin[0].children).forEach(child => child.style.color = "black")
+            }
+
+        })
+    }
+
+    savePlugins () {
+        window.userSettings.plugins.loadOrder = this.plugins.map(([pluginId, pluginData, isEnabled]) => `${isEnabled?"*":""}${pluginId}`).join(",")
+        saveUserSettings()
+        fs.writeFileSync(`./plugins.txt`, window.userSettings.plugins.loadOrder.replace(/,/g, "\n"))
+    }
+
+    apply () {
+
+        const enabledPlugins = this.plugins.filter(([pluginId, pluginData, isEnabled]) => isEnabled).map(([pluginId, pluginData, isEnabled]) => pluginId)
+        const newPlugins = enabledPlugins.filter(pluginId => !window.userSettings.plugins.loadOrder.includes(`*${pluginId}`))
+        const removedPlugins = window.userSettings.plugins.loadOrder.split(",").filter(pluginId => pluginId.startsWith("*") && !enabledPlugins.includes(pluginId.slice(1, 100000)) ).map(pluginId => pluginId.slice(1, 100000))
+
+        removedPlugins.forEach(pluginId => {
+            if (this.teardownModules[pluginId]) {
+                this.teardownModules[pluginId].forEach(func => func())
+            }
+        })
+
+        const pluginLoadStatus = this.loadModules()
+        if (pluginLoadStatus) {
+            window.errorModal(`${window.i18n.FAILED_INIT_FOLLOWING} ${window.i18n.PLUGIN.toLowerCase()}: ${pluginLoadStatus}`)
+            return
+        }
+        this.savePlugins()
+        this.resetModules()
+        plugins_applyBtn.disabled = true
+
+        doFetch(`http://localhost:8008/refreshPlugins`, {
+            method: "Post",
+            body: "{}"
+        }).then(r=>r.text()).then(status => {
+
+            const plugins = status.split(",")
+            const successful = plugins.filter(p => p=="OK")
+            const failed = plugins.filter(p => p!="OK")
+
+            let message = `${window.i18n.SUCCESSFULLY_INITIALIZED} ${successful.length} ${successful.length>1||successful.length==0?window.i18n.PLUGINS:window.i18n.PLUGIN}.`
+            if (failed.length) {
+                if (successful.length==0) {
+                    message = ""
+                }
+                message += ` ${window.i18n.FAILED_INIT_FOLLOWING} ${failed.length>1?window.i18n.PLUGINS:window.i18n.PLUGIN}: <br>${failed.join("<br>")} <br><br>${window.i18n.CHECK_SERVERLOG}`
+            }
+
+            if (!status.length || successful.length==0 && failed.length==0) {
+                message = window.i18n.SUCC_NO_ACTIVE_PLUGINS
+            }
+
+            const restartRequired = newPlugins.map(newPluginId => this.plugins.find(([pluginId, pluginData, isEnabled]) => pluginId==newPluginId))
+                                              .filter(([pluginId, pluginData, isEnabled]) => !!pluginData["install-requires-restart"]).length +
+                                    removedPlugins.map(removedPluginId => this.plugins.find(([pluginId, pluginData, isEnabled]) => pluginId==removedPluginId))
+                                              .filter(([pluginId, pluginData, isEnabled]) => !!pluginData["uninstall-requires-restart"]).length
+            if (restartRequired) {
+                message += `<br><br> ${window.i18n.APP_RESTART_NEEDED}`
+            }
+
+            // Don't use window.errorModal, otherwise you get the error sound
+            createModal("error", message)
+        })
+    }
+
+
+    loadModules () {
+        for (let pi=0; pi<this.plugins.length; pi++) {
+            const [pluginId, pluginData, enabled] = this.plugins[pi]
+            if (!enabled) continue
+            let failed
+
+            failed = this.loadModuleFns(pluginId, pluginData, "start", "pre")
+            if (failed) return `${pluginId}->start->pre<br><br>${failed}`
+
+            failed = this.loadModuleFns(pluginId, pluginData, "start", "post")
+            if (failed) return `${pluginId}->start->post<br><br>${failed}`
+
+            this.loadModuleFns(pluginId, pluginData, "keep-sample", "pre")
+            if (failed) return `${pluginId}->keep-sample->pre<br><br>${failed}`
+
+            this.loadModuleFns(pluginId, pluginData, "keep-sample", "mid")
+            if (failed) return `${pluginId}->keep-sample->mid<br><br>${failed}`
+
+            this.loadModuleFns(pluginId, pluginData, "keep-sample", "post")
+            if (failed) return `${pluginId}->keep-sample->post<br><br>${failed}`
+
+            this.loadModuleFns(pluginId, pluginData, "generate-voice", "pre")
+            if (failed) return `${pluginId}->generate-voice->pre<br><br>${failed}`
+
+            this.loadModuleFns(pluginId, pluginData, "batch-stop", "post")
+            if (failed) return `${pluginId}->batch-stop->post<br><br>${failed}`
+
+
+            if (Object.keys(pluginData).includes("front-end-style-files") && pluginData["front-end-style-files"].length) {
+                pluginData["front-end-style-files"].forEach(styleFile => {
+                    try {
+                        if (styleFile.endsWith(".css")) {
+                            const styleData = fs.readFileSync(`${this.path}/plugins/${pluginId}/${styleFile}`)
+                            pluginsCSS.innerHTML += styleData
+                        }
+                    } catch (e) {
+                        window.appLogger.log(`${window.i18n.ERR_LOADING_CSS} ${pluginId}: ${e}`)
+                    }
+                })
+            }
+        }
+    }
+
+    loadModuleFns (pluginId, pluginData, task, hookTime) {
+        try {
+            if (Object.keys(pluginData).includes("front-end-hooks") && Object.keys(pluginData["front-end-hooks"]).includes(task) && Object.keys(pluginData["front-end-hooks"][task]).includes(hookTime) ) {
+
+                const file = pluginData["front-end-hooks"][task][hookTime]["file"]
+                const functionName = pluginData["front-end-hooks"][task][hookTime]["function"]
+
+                if (!file.endsWith(".js")) {
+                    window.appLogger.log(`[${window.i18n.PLUGIN}: ${pluginId}]: ${window.i18n.CANT_IMPORT_FILE_FOR_HOOK_TASK_ENTRYPOINT.replace("_1", file).replace("_2", hookTime).replace("_3", task)}: ${window.i18n.ONLY_JS}`)
+                    return
+                }
+
+                if (file && functionName) {
+                    const module = require(`${this.path}/plugins/${pluginId}/${file}`)
+
+                    if (module.teardown) {
+                        if (!Object.keys(this.teardownModules).includes(pluginId)) {
+                            this.teardownModules[pluginId] = []
+                        }
+                        this.teardownModules[pluginId].push(module.teardown)
+                    }
+
+                    if (module.setup && !this.setupModules.has(`${pluginId}/${file}`)) {
+                        window.appLogger.setPrefix(pluginId)
+                        module.setup(window)
+                        window.appLogger.setPrefix("")
+                        this.setupModules.add(`${pluginId}/${file}`)
+                    }
+
+                    this.pluginsModules[task][hookTime].push([pluginId, module[functionName]])
+                }
+            }
+        } catch (e) {
+            console.log(`${window.i18n.ERR_LOADING_PLUGIN} ${pluginId}->${task}->${hookTime}: ` + e.stack)
+            window.appLogger.log(`${window.i18n.ERR_LOADING_PLUGIN} ${pluginId}->${task}->${hookTime}: ` + e)
+            return e.stack
+        }
+
+    }
+
+    runPlugins (pList, event, data) {
+        if (pList.length) {
+            console.log(`Running plugin for event: ${event}`)
+        }
+        pList.forEach(([pluginId, pluginFn]) => {
+            try {
+                window.appLogger.setPrefix(pluginId)
+                pluginFn(window, data)
+                window.appLogger.setPrefix("")
+
+            } catch (e) {
+                console.log(e, pluginFn)
+                window.appLogger.log(`[${window.i18n.PLUGIN_RUN_ERROR} "${event}": ${pluginId}]: ${e}`)
+            }
+        })
+    }
+
+
+    _saveINIFile (IniSettings, settingsKey, pluginId, filePath) {
+        const outputIni = []
+        settingsOptionsContainer.querySelectorAll(`.${pluginId}_plugin_setting>div>input, .${pluginId}_plugin_setting>div>select`).forEach(input => {
+
+            if (input.tagName=="SELECT") {
+                const select = input
+                const optionsList = Array.from(select.querySelectorAll("option")).map(option => {
+                    return [option.innerHTML, option.value]
+                })
+                const optionsListString = `{${optionsList.map(kv => kv.join(":")).join(";")}}`
+
+                outputIni.push(`${select.name.toLowerCase()}=${select.value} # ${optionsListString} ${select.getAttribute("comment")!="undefined" ? select.getAttribute("comment") : ""}`)
+                IniSettings[select.name.toLowerCase()] = select.value
+
+            } else {
+                const value = input.type=="checkbox" ? (input.checked ? true : false) : input.value
+                outputIni.push(`${input.name.toLowerCase()}=${value}${input.getAttribute("comment")!="undefined" ? " # "+input.getAttribute("comment") : ""}`)
+                IniSettings[input.name.toLowerCase()] = value
+            }
+        })
+
+        fs.writeFileSync(filePath, outputIni.join("\n"), "utf8")
+        window.pluginsContext[settingsKey] = IniSettings
+    }
+
+    registerINIFile (pluginId, settingsKey, filePath) {
+
+        if (!pluginId || !settingsKey || !filePath) {
+            return window.appLogger.log(`You must provide the following to register an ini file: pluginId, settingsKey, filePath`)
+        }
+
+        if (fs.existsSync(filePath)) {
+
+            if (document.querySelectorAll(`.${pluginId}_plugin_setting`).length) {
+                return
+            }
+
+            const IniSettings = {}
+            const iniFileData = fs.readFileSync(filePath, "utf8").split("\n")
+
+            const hr = createElem(`hr.${pluginId}_plugin_setting`)
+            settingsOptionsContainer.appendChild(hr)
+            settingsOptionsContainer.appendChild(createElem(`div.centeredSettingsSectionPlugins.${pluginId}_plugin_setting`, createElem("div", window.i18n.SETTINGS_FOR_PLUGIN.replace("_1", pluginId)) ))
+
+            iniFileData.forEach(keyVal => {
+                if (!keyVal.trim().length) {
+                    return
+                }
+                let comment = keyVal.includes("#") ? keyVal.split("#")[1].trim() : undefined
+                keyVal = keyVal.split("#")[0].trim()
+                const key = keyVal.split("=")[0].trim()
+                let val = keyVal.split("=")[1].trim()
+                if (val=="false") val = false
+                if (val=="true") val = true
+                IniSettings[key.toLowerCase()] = val
+
+                const labelText = key[0].toUpperCase() + key.substring(1)
+                let label, input
+                const extraElems = []
+
+                if (comment && (comment.includes("$filepicker") || comment.includes("$folderpicker"))) {
+
+                    input = createElem("input", {name: key, comment: comment})
+                    input.style.width = "80%"
+                    input.value = val
+                    const button = createElem("button.svgButton")
+                    button.innerHTML = `<svg class="openFolderSVG" width="400" height="350" viewBox="0, 0, 400,350"><g id="svgg" ><path id="path0"  d="M39.960 53.003 C 36.442 53.516,35.992 53.635,30.800 55.422 C 15.784 60.591,3.913 74.835,0.636 91.617 C -0.372 96.776,-0.146 305.978,0.872 310.000 C 5.229 327.228,16.605 339.940,32.351 345.172 C 40.175 347.773,32.175 347.630,163.000 347.498 L 281.800 347.378 285.600 346.495 C 304.672 342.065,321.061 332.312,330.218 319.944 C 330.648 319.362,332.162 317.472,333.581 315.744 C 335.001 314.015,336.299 312.420,336.467 312.200 C 336.634 311.980,337.543 310.879,338.486 309.753 C 340.489 307.360,342.127 305.341,343.800 303.201 C 344.460 302.356,346.890 299.375,349.200 296.575 C 351.510 293.776,353.940 290.806,354.600 289.975 C 355.260 289.144,356.561 287.505,357.492 286.332 C 358.422 285.160,359.952 283.267,360.892 282.126 C 362.517 280.153,371.130 269.561,375.632 264.000 C 376.789 262.570,380.427 258.097,383.715 254.059 C 393.790 241.689,396.099 237.993,398.474 230.445 C 403.970 212.972,394.149 194.684,376.212 188.991 C 369.142 186.747,368.803 186.724,344.733 186.779 C 330.095 186.812,322.380 186.691,322.216 186.425 C 322.078 186.203,321.971 178.951,321.977 170.310 C 321.995 146.255,321.401 141.613,317.200 133.000 C 314.009 126.457,307.690 118.680,303.142 115.694 C 302.560 115.313,301.300 114.438,300.342 113.752 C 295.986 110.631,288.986 107.881,282.402 106.704 C 280.540 106.371,262.906 106.176,220.400 106.019 L 161.000 105.800 160.763 98.800 C 159.961 75.055,143.463 56.235,120.600 52.984 C 115.148 52.208,45.292 52.225,39.960 53.003 M120.348 80.330 C 130.472 83.988,133.993 90.369,133.998 105.071 C 134.003 120.968,137.334 127.726,147.110 131.675 L 149.400 132.600 213.800 132.807 C 272.726 132.996,278.392 133.071,280.453 133.690 C 286.872 135.615,292.306 141.010,294.261 147.400 C 294.928 149.578,294.996 151.483,294.998 168.000 L 295.000 186.200 292.800 186.449 C 291.590 186.585,254.330 186.725,210.000 186.759 C 163.866 186.795,128.374 186.977,127.000 187.186 C 115.800 188.887,104.936 192.929,96.705 198.458 C 95.442 199.306,94.302 200.000,94.171 200.000 C 93.815 200.000,89.287 203.526,87.000 205.583 C 84.269 208.039,80.083 212.649,76.488 217.159 C 72.902 221.657,72.598 222.031,70.800 224.169 C 70.030 225.084,68.770 226.620,68.000 227.582 C 67.230 228.544,66.054 229.977,65.387 230.766 C 64.720 231.554,62.727 234.000,60.957 236.200 C 59.188 238.400,56.346 241.910,54.642 244.000 C 52.938 246.090,50.163 249.510,48.476 251.600 C 44.000 257.146,36.689 266.126,36.212 266.665 C 35.985 266.921,34.900 268.252,33.800 269.623 C 32.700 270.994,30.947 273.125,29.904 274.358 C 28.861 275.591,28.006 276.735,28.004 276.900 C 28.002 277.065,27.728 277.200,27.395 277.200 C 26.428 277.200,26.700 96.271,27.670 93.553 C 30.020 86.972,35.122 81.823,40.800 80.300 C 44.238 79.378,47.793 79.296,81.800 79.351 L 117.800 79.410 120.348 80.330 M369.400 214.800 C 374.239 217.220,374.273 222.468,369.489 228.785 C 367.767 231.059,364.761 234.844,364.394 235.200 C 364.281 235.310,362.373 237.650,360.154 240.400 C 357.936 243.150,354.248 247.707,351.960 250.526 C 347.732 255.736,346.053 257.821,343.202 261.400 C 341.505 263.530,340.849 264.336,334.600 271.965 C 332.400 274.651,330.204 277.390,329.720 278.053 C 329.236 278.716,328.246 279.945,327.520 280.785 C 326.794 281.624,325.300 283.429,324.200 284.794 C 323.100 286.160,321.726 287.845,321.147 288.538 C 320.568 289.232,318.858 291.345,317.347 293.233 C 308.372 304.449,306.512 306.609,303.703 309.081 C 299.300 312.956,290.855 317.633,286.000 318.886 C 277.958 320.960,287.753 320.819,159.845 320.699 C 33.557 320.581,42.330 320.726,38.536 318.694 C 34.021 316.276,35.345 310.414,42.386 301.647 C 44.044 299.583,45.940 297.210,46.600 296.374 C 47.260 295.538,48.340 294.169,49.000 293.332 C 49.660 292.495,51.550 290.171,53.200 288.167 C 54.850 286.164,57.100 283.395,58.200 282.015 C 59.300 280.635,60.920 278.632,61.800 277.564 C 62.680 276.496,64.210 274.617,65.200 273.389 C 66.190 272.162,67.188 270.942,67.418 270.678 C 67.649 270.415,71.591 265.520,76.179 259.800 C 80.767 254.080,84.634 249.310,84.773 249.200 C 84.913 249.090,87.117 246.390,89.673 243.200 C 92.228 240.010,95.621 235.780,97.213 233.800 C 106.328 222.459,116.884 215.713,128.200 213.998 C 129.300 213.832,183.570 213.719,248.800 213.748 L 367.400 213.800 369.400 214.800 " stroke="none" fill="#fbfbfb" fill-rule="evenodd"></path><path id="path1" fill-opacity="0" d="M0.000 46.800 C 0.000 72.540,0.072 93.600,0.159 93.600 C 0.246 93.600,0.516 92.460,0.759 91.066 C 3.484 75.417,16.060 60.496,30.800 55.422 C 35.953 53.648,36.338 53.550,40.317 52.981 C 46.066 52.159,114.817 52.161,120.600 52.984 C 143.463 56.235,159.961 75.055,160.763 98.800 L 161.000 105.800 220.400 106.019 C 262.906 106.176,280.540 106.371,282.402 106.704 C 288.986 107.881,295.986 110.631,300.342 113.752 C 301.300 114.438,302.560 115.313,303.142 115.694 C 307.690 118.680,314.009 126.457,317.200 133.000 C 321.401 141.613,321.995 146.255,321.977 170.310 C 321.971 178.951,322.078 186.203,322.216 186.425 C 322.380 186.691,330.095 186.812,344.733 186.779 C 368.803 186.724,369.142 186.747,376.212 188.991 C 381.954 190.814,388.211 194.832,391.662 198.914 C 395.916 203.945,397.373 206.765,399.354 213.800 C 399.842 215.533,399.922 201.399,399.958 107.900 L 400.000 0.000 200.000 0.000 L 0.000 0.000 0.000 46.800 M44.000 79.609 C 35.903 81.030,30.492 85.651,27.670 93.553 C 26.700 96.271,26.428 277.200,27.395 277.200 C 27.728 277.200,28.002 277.065,28.004 276.900 C 28.006 276.735,28.861 275.591,29.904 274.358 C 30.947 273.125,32.700 270.994,33.800 269.623 C 34.900 268.252,35.985 266.921,36.212 266.665 C 36.689 266.126,44.000 257.146,48.476 251.600 C 50.163 249.510,52.938 246.090,54.642 244.000 C 56.346 241.910,59.188 238.400,60.957 236.200 C 62.727 234.000,64.720 231.554,65.387 230.766 C 66.054 229.977,67.230 228.544,68.000 227.582 C 68.770 226.620,70.030 225.084,70.800 224.169 C 72.598 222.031,72.902 221.657,76.488 217.159 C 80.083 212.649,84.269 208.039,87.000 205.583 C 89.287 203.526,93.815 200.000,94.171 200.000 C 94.302 200.000,95.442 199.306,96.705 198.458 C 104.936 192.929,115.800 188.887,127.000 187.186 C 128.374 186.977,163.866 186.795,210.000 186.759 C 254.330 186.725,291.590 186.585,292.800 186.449 L 295.000 186.200 294.998 168.000 C 294.996 151.483,294.928 149.578,294.261 147.400 C 292.306 141.010,286.872 135.615,280.453 133.690 C 278.392 133.071,272.726 132.996,213.800 132.807 L 149.400 132.600 147.110 131.675 C 137.334 127.726,134.003 120.968,133.998 105.071 C 133.993 90.369,130.472 83.988,120.348 80.330 L 117.800 79.410 81.800 79.351 C 62.000 79.319,44.990 79.435,44.000 79.609 M128.200 213.998 C 116.884 215.713,106.328 222.459,97.213 233.800 C 95.621 235.780,92.228 240.010,89.673 243.200 C 87.117 246.390,84.913 249.090,84.773 249.200 C 84.634 249.310,80.767 254.080,76.179 259.800 C 71.591 265.520,67.649 270.415,67.418 270.678 C 67.188 270.942,66.190 272.162,65.200 273.389 C 64.210 274.617,62.680 276.496,61.800 277.564 C 60.920 278.632,59.300 280.635,58.200 282.015 C 57.100 283.395,54.850 286.164,53.200 288.167 C 51.550 290.171,49.660 292.495,49.000 293.332 C 48.340 294.169,47.260 295.538,46.600 296.374 C 45.940 297.210,44.044 299.583,42.386 301.647 C 35.345 310.414,34.021 316.276,38.536 318.694 C 42.330 320.726,33.557 320.581,159.845 320.699 C 287.753 320.819,277.958 320.960,286.000 318.886 C 290.855 317.633,299.300 312.956,303.703 309.081 C 306.512 306.609,308.372 304.449,317.347 293.233 C 318.858 291.345,320.568 289.232,321.147 288.538 C 321.726 287.845,323.100 286.160,324.200 284.794 C 325.300 283.429,326.794 281.624,327.520 280.785 C 328.246 279.945,329.236 278.716,329.720 278.053 C 330.204 277.390,332.400 274.651,334.600 271.965 C 340.849 264.336,341.505 263.530,343.202 261.400 C 346.053 257.821,347.732 255.736,351.960 250.526 C 354.248 247.707,357.936 243.150,360.154 240.400 C 362.373 237.650,364.281 235.310,364.394 235.200 C 364.761 234.844,367.767 231.059,369.489 228.785 C 374.273 222.468,374.239 217.220,369.400 214.800 L 367.400 213.800 248.800 213.748 C 183.570 213.719,129.300 213.832,128.200 213.998 M399.600 225.751 C 399.600 231.796,394.623 240.665,383.715 254.059 C 380.427 258.097,376.789 262.570,375.632 264.000 C 371.130 269.561,362.517 280.153,360.892 282.126 C 359.952 283.267,358.422 285.160,357.492 286.332 C 356.561 287.505,355.260 289.144,354.600 289.975 C 353.940 290.806,351.510 293.776,349.200 296.575 C 346.890 299.375,344.460 302.356,343.800 303.201 C 342.127 305.341,340.489 307.360,338.486 309.753 C 337.543 310.879,336.634 311.980,336.467 312.200 C 336.299 312.420,335.001 314.015,333.581 315.744 C 332.162 317.472,330.648 319.362,330.218 319.944 C 321.061 332.312,304.672 342.065,285.600 346.495 L 281.800 347.378 163.000 347.498 C 32.175 347.630,40.175 347.773,32.351 345.172 C 16.471 339.895,3.810 325.502,0.820 309.326 C 0.591 308.085,0.312 306.979,0.202 306.868 C 0.091 306.757,-0.000 327.667,-0.000 353.333 L 0.000 400.000 200.000 400.000 L 400.000 400.000 400.000 312.400 C 400.000 264.220,399.910 224.800,399.800 224.800 C 399.690 224.800,399.600 225.228,399.600 225.751 " stroke="none" fill="#050505" fill-rule="evenodd"></path></g></svg>`
+
+                    const openType = comment.includes("$filepicker") ? "openFile" : "openDirectory"
+                    comment = comment.replace("$filepicker", "").replace("$folderpicker", "")
+
+                    button.addEventListener("click", () => {
+                        let filePathInput = er.dialog.showOpenDialog({ properties: [openType]})
+                        if (filePathInput) {
+                            filePathInput = filePathInput[0].replace(/\\/g, "/")
+                            input.value = filePathInput.replace(/\\/g, "/")
+
+                            this._saveINIFile(IniSettings, settingsKey, pluginId, filePath)
+                        }
+                    })
+                    extraElems.push(button)
+
+
+
+                } else if (comment && comment.includes("{") && comment.includes(":")) {
+
+                    const optionsList = comment.split("{")[1].split("}")[0].split(";").map(kv => {
+                        return [kv.split(":")[0], kv.split(":")[1]]
+                    })
+                    const optionElems = optionsList.map(data => {
+                        const opt = createElem("option", {value: data[1]})
+                        opt.innerHTML = data[0]
+                        return opt
+                    })
+
+                    comment = comment.split("}").reverse()[0].trim()
+
+                    input = createElem("select", {name: key, comment: comment})
+                    optionElems.forEach(option => {
+                        input.appendChild(option)
+                    })
+                    input.value = val
+
+                } else {
+                    const inputType = [true,false].includes(val) ? "checkbox" : "text"
+                    input = createElem("input", {
+                        type: inputType, name: key, comment: comment
+                    })
+                    if (inputType=="checkbox") {
+                        input.checked = val
+                    } else {
+                        input.value = val
+                    }
+                }
+
+                label = createElem("div", labelText.replace(/_/g, " ") + (comment ? `<br>(${comment})` : ""))
+
+
+                input.addEventListener("change", () => {
+                    this._saveINIFile(IniSettings, settingsKey, pluginId, filePath)
+                })
+
+                const rhd_elem = createElem("div")
+                rhd_elem.appendChild(input)
+                extraElems.forEach(elem => rhd_elem.appendChild(elem))
+                if (extraElems.length) {
+                    rhd_elem.style.flexDirection = "row"
+                }
+
+                settingsOptionsContainer.appendChild(createElem(`div.${pluginId}_plugin_setting`, [label, rhd_elem]))
+            })
+
+            window.pluginsContext[settingsKey] = IniSettings
+
+
+
+        } else {
+            window.appLogger.log(`Ini file does not exist here: ${filePath}`)
+        }
+
+    }
+
+}
+
+
+exports.PluginsManager = PluginsManager

javascript/script.js

@@ -0,0 +1,1730 @@
+"use strict"
+window.appVersion = "v3.0.3"
+
+window.PRODUCTION = module.filename.includes("resources")
+const path = window.PRODUCTION ? "./resources/app" : "."
+window.path = path
+
+const fs = require("fs")
+const zipdir = require('zip-dir')
+const {shell, ipcRenderer, clipboard} = require("electron")
+const doFetch = require("node-fetch")
+const {xVAAppLogger} = require("./javascript/appLogger.js")
+window.appLogger = new xVAAppLogger(`./app.log`, window.appVersion)
+process.on(`uncaughtException`, (data, origin) => {window.appLogger.log(`uncaughtException: ${data}`);window.appLogger.log(`uncaughtException: ${origin}`)})
+window.onerror = (event, source, lineno, colno, error) => {window.appLogger.log(`onerror: ${error.stack}`)}
+require("./javascript/i18n.js")
+require("./javascript/util.js")
+require("./javascript/nexus.js")
+require("./javascript/dragdrop_model_install.js")
+require("./javascript/embeddings.js")
+require("./javascript/totd.js")
+require("./javascript/arpabet.js")
+require("./javascript/style_embeddings.js")
+const {Editor} = require("./javascript/editor.js")
+require("./javascript/textarea.js")
+const {saveUserSettings, deleteFolderRecursive} = require("./javascript/settingsMenu.js")
+const xVASpeech = require("./javascript/speech2speech.js")
+require("./javascript/batch.js")
+require("./javascript/outputFiles.js")
+require("./javascript/workbench.js")
+const er = require('@electron/remote')
+window.electronBrowserWindow = er.getCurrentWindow()
+const child = require("child_process").execFile
+const spawn = require("child_process").spawn
+
+// Newly introduced in v3. I will slowly start moving global context variables into this, and update code throughout to reference this
+// instead of old variables such as window.games, window.currentModel, etc.
+window.appState = {}
+
+
+// Start the server
+if (window.PRODUCTION) {
+    window.pythonProcess = spawn(`${path}/cpython_${window.userSettings.installation}/server.exe`, {stdio: "ignore"})
+}
+
+const {PluginsManager} = require("./javascript/plugins_manager.js")
+window.pluginsContext = {}
+window.pluginsManager = new PluginsManager(window.path, window.appLogger, window.appVersion)
+window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["start"]["pre"], event="pre start")
+
+
+let themeColour
+let secondaryThemeColour
+const oldCError = console.error
+console.error = (...rest) => {
+    window.appLogger.log(`console.error: ${rest}`)
+    oldCError(rest)
+}
+
+window.addEventListener("error", function (e) {window.appLogger.log(`error: ${e.error.stack}`)})
+window.addEventListener('unhandledrejection', function (e) {window.appLogger.log(`unhandledrejection: ${e.stack}`)})
+
+
+setTimeout(() => {
+    window.electron = require("electron")
+}, 1000)
+
+
+window.games = {}
+window.models = {}
+window.sequenceEditor = new Editor()
+window.currentModel = undefined
+window.currentModelButton = undefined
+window.watchedModelsDirs = []
+
+window.appLogger.log(`Settings: ${JSON.stringify(window.userSettings)}`)
+
+// Set up folders
+try {fs.mkdirSync(`${path}/models`)} catch (e) {/*Do nothing*/}
+try {fs.mkdirSync(`${path}/output`)} catch (e) {/*Do nothing*/}
+try {fs.mkdirSync(`${path}/assets`)} catch (e) {/*Do nothing*/}
+
+// Clean up temp files
+const clearOldTempFiles = () => {
+    fs.readdir(`${__dirname.replace("/javascript", "")}/output`, (err, files) => {
+        if (err) {
+            window.appLogger.log(`Error cleaning up temp files: ${err}`)
+        }
+        if (files && files.length) {
+            files.filter(f => f.startsWith("temp-")).forEach(file => {
+                fs.unlink(`${__dirname.replace("/javascript", "")}/output/${file}`, err => err&&console.log(err))
+            })
+        }
+    })
+}
+clearOldTempFiles()
+
+let fileRenameCounter = 0
+let fileChangeCounter = 0
+window.isGenerating = false
+
+
+
+
+window.registerModel = (modelsPath, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => {
+    // Add game, if the game hasn't been added yet
+    let audioPreviewPath
+    try {
+        audioPreviewPath = `${modelsPath}/${model.games.find(({gameId}) => gameId==gameFolder).voiceId}`
+    } catch (e) {}
+    if (!window.games.hasOwnProperty(gameId)) {
+
+        const gameAsset = fs.readdirSync(`${path}/assets`).find(f => f==gameId+".json")
+        if (gameAsset && gameAsset.length && gameAsset[0]) {
+            const gameTheme = JSON.parse(fs.readFileSync(`${path}/assets/${gameAsset}`))
+
+            window.games[gameId] = {
+                models: [],
+                gameTheme,
+                gameAsset
+            }
+
+        } else {
+            window.appLogger.log(`Something not right with loading model: ${voiceId} . The asset file for its game (${gameId}) could not be found here: ${path}/assets. You need a ${gameId}.json file. Loading a generic theme for this voice's game/category.`)
+
+            const dummyGameTheme = {
+                "gameName": gameId,
+                "assetFile": "other.jpg",
+                "themeColourPrimary": "aaaaaa",
+                "themeColourSecondary": null,
+                "gameCode": "x",
+                "nexusGamePageIDs": []
+            }
+            const dummyGameAsset = "other.json"
+            window.games[gameId] = {
+                models: [],
+                dummyGameTheme,
+                dummyGameAsset
+            }
+            audioPreviewPath = `${modelsPath}/${model.games[0].voiceId}`
+        }
+    }
+
+    // Catch duplicates, for when/if a model is registered for multiple games, but there's already the same model in that game, from another version
+    // const existingDuplicates = []
+    // window.games[gameId].models.forEach((item,i) => {
+    //     if (item.voiceId==voiceId) {
+    //         existingDuplicates.push([item, i])
+    //     }
+    // })
+
+    // Check if a variant has already been added for this voice name, for this game
+    let foundVariantIndex = undefined
+    window.games[gameId].models.forEach((item,i) => {
+        if (foundVariantIndex!=undefined) return
+
+        if (item.voiceName.toLowerCase().trim()==voiceName.toLowerCase().trim()) {
+            foundVariantIndex = i
+        }
+    })
+
+    // Add the initial model metadata, if no existing variant has been added (will happen most of the time)
+    if (!foundVariantIndex) {
+        const modelData = {
+            gameId,
+            modelsPath,
+            voiceName,
+            lang_capabilities: model.lang_capabilities,
+            embOverABaseModel: model.embOverABaseModel,
+            variants: []
+        }
+        window.games[gameId].models.push(modelData)
+        foundVariantIndex = window.games[gameId].models.length-1
+    }
+
+    const variantData = {
+        author: model.author,
+        version: model.version,
+        modelVersion: model.modelVersion,
+        modelType: model.modelType,
+        base_speaker_emb: model.modelType=="xVAPitch" ? model.games[0].base_speaker_emb : undefined,
+        voiceId,
+        audioPreviewPath,
+        hifi: undefined,
+        num_speakers: model.emb_size,
+        emb_i,
+        variantName: variant ? variant.replace("Default :", "Default:").replace("Default:", "").trim() : "Default",
+        voiceDescription,
+        lang: model.lang,
+        gender,
+        modelType: modelType||model.modelType,
+        model,
+    }
+    const potentialHiFiPath = `${modelsPath}/${voiceId}.hg.pt`
+    if (fs.existsSync(potentialHiFiPath)) {
+        variantData.hifi = potentialHiFiPath
+    }
+
+    const isDefaultVariant = !variant || variant.toLowerCase().startsWith("default")
+
+    if (isDefaultVariant) {
+        // Place first in the list, if it's default
+        window.games[gameId].models[foundVariantIndex].audioPreviewPath = audioPreviewPath
+        window.games[gameId].models[foundVariantIndex].variants.splice(0,0,variantData)
+    } else {
+        window.games[gameId].models[foundVariantIndex].variants.push(variantData)
+    }
+
+
+    // // Using the detected duplicates, use only the latest version
+    // if (existingDuplicates.length) {
+    //     if (existingDuplicates[0][0].modelVersion<model.modelVersion) {
+    //         window.games[gameId].models.splice(existingDuplicates[0][1], 1)
+    //         window.games[gameId].models.push(modelData)
+    //     }
+    // } else {
+    //     window.games[gameId].models.push(modelData)
+    // }
+}
+
+window.loadAllModels = (forceUpdate=false) => {
+    return new Promise(resolve => {
+
+        if (!forceUpdate && window.nexusState.installQueue.length) {
+            return
+        }
+
+        let gameFolder
+        let modelPathsKeys = Object.keys(window.userSettings).filter(key => key.includes("modelspath_"))
+        window.games = {}
+
+        // Do the current game first, and stop blocking the render process
+        if (window.currentGame) {
+            const currentGameFolder = window.userSettings[`modelspath_${window.currentGame.gameId}`]
+            gameFolder = currentGameFolder
+            try {
+                const files = fs.readdirSync(modelsPath).filter(f => f.endsWith(".json"))
+                files.forEach(fileName => {
+                    try {
+                        if (!models.hasOwnProperty(`${gameFolder}/${fileName}`)) {
+                            models[`${gameFolder}/${fileName}`] = null
+                        }
+                        const model = JSON.parse(fs.readFileSync(`${modelsPath}/${fileName}`, "utf8"))
+                        model.games.forEach(({gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => {
+                            window.registerModel(currentGameFolder, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i})
+                        })
+
+                    } catch (e) {
+                        console.log(e)
+                        // window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME_WITH_FILENAME.replace("_1", gameFolder)} `+fileName)
+                        // window.appLogger.log(e)
+                        // window.appLogger.log(e.stack)
+                    }
+                })
+            } catch (e) {
+                window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME}: `+ gameFolder)
+                window.appLogger.log(e)
+            }
+            resolve() // Continue the rest but asynchronously
+        }
+
+
+        modelPathsKeys.forEach(modelsPathKey => {
+            const modelsPath = window.userSettings[modelsPathKey]
+            try {
+                const files = fs.readdirSync(modelsPath).filter(f => f.endsWith(".json"))
+
+                if (!files.length) {
+                    return
+                }
+
+                files.forEach(fileName => {
+
+                    gameFolder = modelsPathKey.split("_")[1]
+
+                    try {
+                        if (!models.hasOwnProperty(`${gameFolder}/${fileName}`)) {
+                            models[`${gameFolder}/${fileName}`] = null
+                        }
+
+                        const model = JSON.parse(fs.readFileSync(`${modelsPath}/${fileName}`, "utf8"))
+                        model.games.forEach(({gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i}) => {
+                            window.registerModel(modelsPath, gameFolder, model, {gameId, voiceId, voiceName, voiceDescription, gender, variant, modelType, emb_i})
+                        })
+                    } catch (e) {
+                        console.log(e)
+                        setTimeout(() => {
+                            window.errorModal(`${fileName}<br><br>${e.stack}`)
+                        }, 1000)
+                        window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME_WITH_FILENAME.replace("_1", gameFolder)} `+fileName)
+                        window.appLogger.log(e)
+                        window.appLogger.log(e.stack)
+                    }
+                })
+            } catch (e) {
+                window.appLogger.log(`${window.i18n.ERR_LOADING_MODELS_FOR_GAME}: `+ gameFolder)
+                window.appLogger.log(e)
+            }
+        })
+        window.updateGameList(false)
+        resolve()
+    })
+}
+
+
+// Change variant
+let oldVariantSelection = undefined // For reverting, if versioning checks fail
+variant_select.addEventListener("change", () => {
+
+    const model = window.games[window.currentGame.gameId].models.find(model => model.voiceName== window.currentModel.voiceName)
+    const variant = model.variants.find(variant => variant.variantName==variant_select.value)
+
+    const appVersionOk = window.checkVersionRequirements(variant.version, appVersion)
+    if (!appVersionOk) {
+        window.errorModal(`${window.i18n.MODEL_REQUIRES_VERSION} v${variant.version}<br><br>${window.i18n.THIS_APP_VERSION}: ${window.appVersion}`)
+        variant_select.value = oldVariantSelection
+        return
+    }
+
+    generateVoiceButton.dataset.modelQuery = JSON.stringify({
+        outputs: parseInt(model.outputs),
+        model: model.embOverABaseModel ? window.userSettings[`modelspath_${model.embOverABaseModel.split("/")[0]}`]+`/${model.embOverABaseModel.split("/")[1]}` : `${model.modelsPath}/${variant.voiceId}`,
+        modelType: variant.modelType,
+        version: variant.version,
+        model_speakers: model.num_speakers,
+        base_lang: model.lang || "en"
+    })
+    oldVariantSelection = variant_select.value
+
+    titleInfoVoiceID.innerHTML = variant.voiceId
+    titleInfoGender.innerHTML = variant.gender || "?"
+    titleInfoAppVersion.innerHTML = variant.version || "?"
+    titleInfoModelVersion.innerHTML = variant.modelVersion || "?"
+    titleInfoModelType.innerHTML = variant.modelType || "?"
+    titleInfoLanguage.innerHTML = variant.lang || window.currentModel.games[0].lang || "en"
+    titleInfoAuthor.innerHTML = variant.author || "?"
+
+    generateVoiceButton.click()
+})
+
+
+
+// Change game
+window.changeGame = (meta) => {
+
+    titleInfo.style.display = "none"
+    window.currentGame = meta
+    themeColour = meta.themeColourPrimary
+    secondaryThemeColour = meta.themeColourSecondary
+    let titleID = meta.gameCode
+
+    generateVoiceButton.disabled = true
+    generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE
+    selectedGameDisplay.innerHTML = meta.gameName
+
+    // Change the app title
+    titleName.innerHTML = window.i18n.SELECT_VOICE_TYPE
+    if (window.games[window.currentGame.gameId] == undefined) {
+        titleName.innerHTML = `${window.i18n.NO_MODELS_IN}: ${window.userSettings[`modelspath_${window.currentGame.gameId}`]}`
+    }
+
+    const gameFolder = meta.gameId
+    const gameName = meta.gameName
+
+    setting_models_path_container.style.display = "flex"
+    setting_out_path_container.style.display = "flex"
+    setting_models_path_label.innerHTML = `<i style="display:inline">${gameName}</i><span>${window.i18n.SETTINGS_MODELS_PATH}</span>`
+    setting_models_path_input.value = window.userSettings[`modelspath_${gameFolder}`]
+    setting_out_path_label.innerHTML = `<i style="display:inline">${gameName}</i> ${window.i18n.SETTINGS_OUTPUT_PATH}`
+    setting_out_path_input.value = window.userSettings[`outpath_${gameFolder}`]
+
+    window.setTheme(window.currentGame)
+    try {
+        window.displayAllModels()
+    } catch (e) {console.log(e)}
+
+    try {fs.mkdirSync(`${path}/output/${meta.gameId}`)} catch (e) {/*Do nothing*/}
+    localStorage.setItem("lastGame", JSON.stringify(meta))
+
+    // Populate models
+    voiceTypeContainer.innerHTML = ""
+    voiceSamples.innerHTML = ""
+
+    const buttons = []
+    const totalNumVoices = (window.games[meta.gameId] ? window.games[meta.gameId].models : []).reduce((p,c)=>p+c.variants.length, 0)
+    voiceSearchInput.placeholder = window.i18n.SEARCH_N_VOICES.replace("_", window.games[meta.gameId] ? totalNumVoices : "0")
+    voiceSearchInput.value = ""
+
+    if (!window.games[meta.gameId]) {
+        return
+    }
+
+    (window.games[meta.gameId] ? window.games[meta.gameId].models : []).forEach(({modelsPath, audioPreviewPath, gameId, variants, voiceName, embOverABaseModel}) => {
+
+        const {voiceId, voiceDescription, hifi, model} = variants[0]
+        const modelVersion = variants[0].version
+
+        const button = createElem("div.voiceType", voiceName)
+        button.style.background = `#${themeColour}`
+        if (embOverABaseModel) {
+            button.style.fontStyle = "italic"
+        }
+        if (window.userSettings.do_model_version_highlight && parseFloat(modelVersion)<window.userSettings.model_version_highlight) {
+            button.style.border =  `2px solid #${themeColour}`
+            button.style.padding =  "0"
+            button.style.background = "none"
+        }
+        button.dataset.modelId = voiceId
+        if (secondaryThemeColour) {
+            button.style.color = `#${secondaryThemeColour}`
+            button.style.textShadow = `none`
+        }
+
+        // Quick voice set preview, if there is a preview file
+        button.addEventListener("contextmenu", () => {
+            window.appLogger.log(`${audioPreviewPath}.wav`)
+            const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+                src: `${audioPreviewPath}.wav`
+            }))
+            audioPreview.style.height = "25px"
+            audioPreview.setSinkId(window.userSettings.base_speaker)
+        })
+
+        if (embOverABaseModel) {
+            const gameOfBaseModel = embOverABaseModel.split("/")[0]
+            if (gameOfBaseModel=="<base>") {
+                // For included base v3 models
+                modelsPath = `${window.path}/python/xvapitch/${embOverABaseModel.split("/")[1]}`
+            } else {
+                // For any other model
+                const gameModelsPath = `${window.userSettings[`outpath_${gameOfBaseModel}`]}`
+                modelsPath = `${gameModelsPath}/${embOverABaseModel.split("/")[1]}`
+            }
+        }
+
+        button.addEventListener("click", event => window.selectVoice(event, variants, hifi, gameId, voiceId, model, button, audioPreviewPath, modelsPath, meta, embOverABaseModel))
+        buttons.push(button)
+    })
+
+    buttons.sort((a,b) => a.innerHTML.toLowerCase()<b.innerHTML.toLowerCase()?-1:1)
+        .forEach(button => voiceTypeContainer.appendChild(button))
+
+}
+
+
+window.selectVoice = (event, variants, hifi, gameId, voiceId, model, button, audioPreviewPath, modelsPath, meta, embOverABaseModel) => {
+    // Just for easier packaging of the voice models for publishing - yes, lazy
+    if (event.ctrlKey && event.shiftKey) {
+        window.packageVoice(event.altKey, variants, {modelsPath, gameId})
+    }
+
+    variant_select.innerHTML = ""
+    oldVariantSelection = undefined
+    if (variants.length==1) {
+        variantElements.style.display = "none"
+    } else {
+        variantElements.style.display = "flex"
+        variants.forEach(variant => {
+            const option = createElem("option", {value: variant.variantName})
+            option.innerHTML = variant.variantName
+            variant_select.appendChild(option)
+            if (!oldVariantSelection) {
+                oldVariantSelection = variant.variantName
+            }
+        })
+    }
+
+
+    if (hifi) {
+        // Remove the bespoke hifi option if there was one already there
+        Array.from(vocoder_select.children).forEach(opt => {
+            if (opt.innerHTML=="Bespoke HiFi GAN") {
+                vocoder_select.removeChild(opt)
+            }
+        })
+        bespoke_hifi_bolt.style.opacity = 1
+        const option = createElem("option", "Bespoke HiFi GAN")
+        option.value = `${gameId}/${voiceId}.hg.pt`
+        vocoder_select.appendChild(option)
+    } else {
+        bespoke_hifi_bolt.style.opacity = 0
+        // Set the vocoder select to quick-and-dirty if bespoke hifi-gan was selected
+        if (vocoder_select.value.includes(".hg.")) {
+            vocoder_select.value = "qnd"
+            window.changeVocoder("qnd")
+        }
+        // Remove the bespoke hifi option if there was one already there
+        Array.from(vocoder_select.children).forEach(opt => {
+            if (opt.innerHTML=="Bespoke HiFi GAN") {
+                vocoder_select.removeChild(opt)
+            }
+        })
+    }
+
+    window.currentModel = model
+    window.currentModel.voiceId = voiceId
+    window.currentModel.voiceName = button.innerHTML
+    window.currentModel.hifi = hifi
+    window.currentModel.audioPreviewPath = audioPreviewPath
+    window.currentModelButton = button
+
+
+    generateVoiceButton.dataset.modelQuery = null
+
+    // The model is already loaded. Don't re-load it.
+    if (generateVoiceButton.dataset.modelIDLoaded == voiceId) {
+        generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE
+        generateVoiceButton.dataset.modelQuery = "null"
+
+    } else {
+        generateVoiceButton.innerHTML = window.i18n.LOAD_MODEL
+        generateVoiceButton.dataset.modelQuery = JSON.stringify({
+            outputs: parseInt(model.outputs),
+            model: model.embOverABaseModel ? window.userSettings[`modelspath_${model.embOverABaseModel.split("/")[0]}`]+`/${model.embOverABaseModel.split("/")[1]}` : `${modelsPath}/${model.voiceId}`,
+            modelType: model.modelType,
+            version: model.version,
+            model_speakers: model.emb_size,
+            cmudict: model.cmudict,
+            base_lang: model.lang || "en"
+        })
+        generateVoiceButton.dataset.modelIDToLoad = voiceId
+    }
+    generateVoiceButton.disabled = false
+
+    titleName.innerHTML = button.innerHTML
+    titleInfo.style.display = "flex"
+    titleInfoName.innerHTML = window.currentModel.voiceName
+    titleInfoVoiceID.innerHTML = voiceId
+    titleInfoGender.innerHTML = window.currentModel.games[0].gender || "?"
+    titleInfoAppVersion.innerHTML = window.currentModel.version || "?"
+    titleInfoModelVersion.innerHTML = window.currentModel.modelVersion || "?"
+    titleInfoModelType.innerHTML = window.currentModel.modelType || "?"
+    titleInfoLanguage.innerHTML = window.currentModel.lang || window.currentModel.games[0].lang || "en"
+    titleInfoAuthor.innerHTML = window.currentModel.author || "?"
+    titleInfoLicense.innerHTML = window.currentModel.license || window.i18n.UNKNOWN
+
+    title.dataset.modelId = voiceId
+    keepSampleButton.style.display = "none"
+    samplePlayPause.style.display = "none"
+
+    // Voice samples
+    voiceSamples.innerHTML = ""
+
+    window.initMainPagePagination(`${window.userSettings[`outpath_${meta.gameId}`]}/${button.dataset.modelId}`)
+    window.refreshRecordsList()
+}
+
+titleInfo.addEventListener("click", () => titleDetails.style.display = titleDetails.style.display=="none" ? "block" : "none")
+window.addEventListener("click", event => {
+    if (event.target!=titleInfo && event.target!=titleDetails && event.target.parentNode && event.target.parentNode!=titleDetails && event.target.parentNode.parentNode!=titleDetails) {
+        titleDetails.style.display = "none"
+    }
+})
+titleDetails.style.display = "none"
+
+
+window.loadModel = () => {
+    return new Promise(resolve => {
+        if (window.batch_state.state) {
+            window.errorModal(window.i18n.BATCH_ERR_IN_PROGRESS)
+            return
+        }
+
+        const body = JSON.parse(generateVoiceButton.dataset.modelQuery)
+
+        const appVersionOk = window.checkVersionRequirements(body.version, appVersion)
+        if (!appVersionOk) {
+            window.errorModal(`${window.i18n.MODEL_REQUIRES_VERSION} v${body.version}<br><br>${window.i18n.THIS_APP_VERSION}: ${window.appVersion}`)
+            return
+        }
+
+
+        window.appLogger.log(`${window.i18n.LOADING_VOICE}: ${JSON.parse(generateVoiceButton.dataset.modelQuery).model}`)
+        window.batch_state.lastModel = JSON.parse(generateVoiceButton.dataset.modelQuery).model.split("/").reverse()[0]
+
+        body["pluginsContext"] = JSON.stringify(window.pluginsContext)
+
+        spinnerModal(`${window.i18n.LOADING_VOICE}`)
+        doFetch(`http://localhost:8008/loadModel`, {
+            method: "Post",
+            body: JSON.stringify(body)
+        }).then(r=>r.text()).then(res => {
+
+            window.currentModel.loaded = true
+            generateVoiceButton.dataset.modelQuery = null
+            generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE
+            generateVoiceButton.dataset.modelIDLoaded = generateVoiceButton.dataset.modelIDToLoad
+
+            // Set the editor pitch/energy dropdowns to pitch, and freeze them, if energy is not supported by the model
+            window.appState.currentModelEmbeddings = {}
+            if (window.currentModel.modelType.toLowerCase()=="xvapitch" && !window.currentModel.isBaseModel) {
+                vocoder_options_container.style.display = "none"
+                base_lang_select.disabled = false
+                style_emb_select.disabled = false
+                window.loadStyleEmbsForVoice(window.currentModel)
+                mic_SVG.children[0].style.fill = "white"
+                base_lang_select.value = window.currentModel.lang
+            } else {
+                vocoder_options_container.style.display = "inline-block"
+                base_lang_select.disabled = true
+                style_emb_select.disabled = true
+                mic_SVG.children[0].style.fill = "grey"
+            }
+            if (window.currentModel.modelType.toLowerCase()=="fastpitch") {
+                seq_edit_view_select.value = "pitch"
+                seq_edit_edit_select.value = "pitch"
+                seq_edit_view_select.disabled = true
+                seq_edit_edit_select.disabled = true
+            } else {
+                seq_edit_view_select.value = "pitch_energy"
+                seq_edit_view_select.disabled = false
+                seq_edit_edit_select.disabled = false
+            }
+
+            window.populateLanguagesDropdownsFromModel(base_lang_select, window.currentModel)
+            base_lang_select.value = window.currentModel.lang
+
+            if (window.userSettings.defaultToHiFi && window.currentModel.hifi) {
+                vocoder_select.value = Array.from(vocoder_select.children).find(opt => opt.innerHTML=="Bespoke HiFi GAN").value
+                window.changeVocoder(vocoder_select.value).then(() => dialogueInput.focus())
+            } else if (window.userSettings.vocoder.includes(".hg.pt")) {
+                window.changeVocoder("qnd").then(() => dialogueInput.focus())
+            } else {
+                closeModal(null, [workbenchContainer]).then(() => dialogueInput.focus())
+            }
+            resolve()
+        }).catch(e => {
+            console.log(e)
+            if (e.code =="ENOENT") {
+                closeModal(null, [modalContainer, workbenchContainer]).then(() => {
+                    window.errorModal(window.i18n.ERR_SERVER)
+                    resolve()
+                })
+            }
+        })
+    })
+}
+
+// Return true/false for if the prompt is the same - BUT: allow phoneme swaps
+window.checkIfPromptIsTheSame = (sequence) => {
+
+    // False if there was no previous prompt
+    if (!window.sequenceEditor.historyState.length) {
+        return false
+    }
+
+    const lastPrompt = window.sequenceEditor.historyState.at(-1)
+
+    // False if they're different lengths
+    if (sequence.length != lastPrompt.length) {
+        return false
+    }
+
+    // Split into words (and phonemes)
+    const currentParts = sequence.split(" ")
+    const lastParts = lastPrompt.split(" ")
+
+    for (let si=0; si<currentParts.length; si++) {
+        // False if a word is different, but not if it's an ARPAbet symbol
+        const cleaned = currentParts[si].replace(/[^a-zA-Z]/g, "")
+        if (currentParts[si]!=lastParts[si] && !window.ARPAbetSymbols.includes(cleaned)) {
+            return false
+        }
+    }
+
+    return true
+}
+
+window.synthesizeSample = () => {
+
+    const game = window.currentGame.gameId
+
+    if (window.isGenerating) {
+        return
+    }
+    if (!window.speech2speechState.s2s_running) {
+        clearOldTempFiles()
+    }
+
+    let sequence = dialogueInput.value.replace("…", "...").replace("’", "'")
+    if (window.userSettings.spacePadding && !window.sequenceEditor.isEditingFromFile) { // Pad start and end of the input sequence with spaces
+        sequence = " "+sequence.trim()+" "
+    }
+    window.sequenceEditor.isEditingFromFile = false
+
+    if (sequence.length==0) {
+        return
+    }
+    window.isGenerating = true
+
+    window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["generate-voice"]["pre"], event="pre generate-voice")
+
+    if (window.wavesurfer) {
+        try {
+            window.wavesurfer.stop()
+        } catch (e) {
+            console.log(e)
+        }
+        wavesurferContainer.style.opacity = 0
+    }
+    toggleSpinnerButtons()
+
+    const voiceType = title.dataset.modelId
+    const outputFileName = dialogueInput.value.slice(0, 260).replace(/\n/g, " ").replace(/[\/\\:\*?<>"|]*/g, "").replace(/^[\.\s]+/, "")
+
+    try {fs.unlinkSync(localStorage.getItem("tempFileLocation"))} catch (e) {/*Do nothing*/}
+
+    // For some reason, the samplePlay audio element does not update the source when the file name is the same
+    const tempFileNum = `${Math.random().toString().split(".")[1]}`
+    let tempFileLocation = `${path}/output/temp-${tempFileNum}.wav`
+    let pitch = []
+    let duration = []
+    let energy = []
+    let emAngry = []
+    let emHappy = []
+    let emSad = []
+    let emSurprise = []
+    let editorStyles = {}
+    let isFreshRegen = true
+    let old_sequence = undefined
+
+    if (editorContainer.innerHTML && editorContainer.innerHTML.length && generateVoiceButton.dataset.modelIDLoaded==window.sequenceEditor.currentVoice) {
+        if (window.sequenceEditor.audioInput || window.sequenceEditor.sequence && sequence!=window.sequenceEditor.inputSequence) {
+            old_sequence = window.sequenceEditor.inputSequence
+        }
+    }
+    // Don't use the old_sequence if running speech-to-speech
+    if (window.speech2speechState.s2s_running) {
+        old_sequence = undefined
+        window.speech2speechState.s2s_running = false
+    }
+
+    // Check if editing an existing line (otherwise it's a fresh new line)
+    const languageHasChanged = window.sequenceEditor.base_lang && window.sequenceEditor.base_lang != base_lang_select.value
+    const promptHasChanged = !window.checkIfPromptIsTheSame(sequence)
+    if (!promptHasChanged && !languageHasChanged && !window.arpabetMenuState.hasChangedARPAbet && !window.styleEmbsMenuState.hasChangedEmb &&
+        (speech2speechState.s2s_autogenerate || (editorContainer.innerHTML && editorContainer.innerHTML.length && (window.userSettings.keepEditorOnVoiceChange || generateVoiceButton.dataset.modelIDLoaded==window.sequenceEditor.currentVoice)))) {
+
+        speech2speechState.s2s_autogenerate = false
+        pitch = window.sequenceEditor.pitchNew.map(v=> v==undefined?0:v)
+        duration = window.sequenceEditor.dursNew.map(v => v*pace_slid.value).map(v=> v==undefined?0:v)
+        energy = window.sequenceEditor.energyNew ? window.sequenceEditor.energyNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : []
+        if (window.currentModel.modelType=="xVAPitch") {
+            emAngry = window.sequenceEditor.emAngryNew ? window.sequenceEditor.emAngryNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : []
+            emHappy = window.sequenceEditor.emHappyNew ? window.sequenceEditor.emHappyNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : []
+            emSad = window.sequenceEditor.emSadNew ? window.sequenceEditor.emSadNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : []
+            emSurprise = window.sequenceEditor.emSurpriseNew ? window.sequenceEditor.emSurpriseNew.map(v => v==undefined?0:v).filter(v => !isNaN(v)) : []
+
+            if (window.sequenceEditor.registeredStyleKeys) {
+                window.sequenceEditor.registeredStyleKeys.forEach(styleKey => {
+                    editorStyles[styleKey] = {
+                        embedding: window.appState.currentModelEmbeddings[styleKey][1],
+                        sliders: window.sequenceEditor.styleValuesNew[styleKey].map(v => v==undefined?0:v).filter(v => !isNaN(v))// : []
+                    }
+                })
+            }
+        }
+        isFreshRegen = false
+    }
+
+    window.arpabetMenuState.hasChangedARPAbet = false
+    window.styleEmbsMenuState.hasChangedEmb = false
+    window.sequenceEditor.currentVoice = generateVoiceButton.dataset.modelIDLoaded
+
+    const speaker_i = window.currentModel.games[0].emb_i
+    const pace = (window.userSettings.keepPaceOnNew && isFreshRegen)?pace_slid.value:1
+
+    window.appLogger.log(`${window.i18n.SYNTHESIZING}: ${sequence}`)
+
+    doFetch(`http://localhost:8008/synthesize`, {
+        method: "Post",
+        body: JSON.stringify({
+            sequence, pitch, duration, energy, emAngry, emHappy, emSad, emSurprise, editorStyles, speaker_i, pace,
+            base_lang: base_lang_select.value,
+            base_emb: style_emb_select.value||"",
+            modelType: window.currentModel.modelType,
+            old_sequence, // For partial re-generation
+            device: window.userSettings.installation=="cpu"?"cpu":(window.userSettings.useGPU?"cuda:0":"cpu"),
+            // device: window.userSettings.useGPU?"gpu":"cpu",   // Switch to this once DirectML is installed
+            useSR: useSRCkbx.checked,
+            useCleanup: useCleanupCkbx.checked,
+            outfile: tempFileLocation,
+            pluginsContext: JSON.stringify(window.pluginsContext),
+            vocoder: window.currentModel.modelType=="xVAPitch" ? "n/a" : window.userSettings.vocoder,
+            waveglowPath: vocoder_select.value=="256_waveglow" ? window.userSettings.waveglow_path : window.userSettings.bigwaveglow_path
+        })
+    }).then(r=>r.text()).then(res => {
+        window.isGenerating = false
+
+        if (res=="ENOENT" || res.startsWith("ERR:")) {
+            console.log(res)
+            if (res.startsWith("ERR:")) {
+                if (res.includes("ARPABET_NOT_IN_LIST")) {
+                    const symbolNotInList = res.split(":").reverse()[0]
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${window.i18n.ERR_ARPABET_NOT_EXIST.replace("_1", symbolNotInList)}`)
+                } else {
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res.replace("ERR:","").replaceAll(/\n/g, "<br>")}`)
+                }
+            } else {
+                window.appLogger.log(res)
+                window.errorModal(`${window.i18n.BATCH_MODEL_NOT_FOUND}.${vocoder_select.value.includes("waveglow")?" "+window.i18n.BATCH_DOWNLOAD_WAVEGLOW:""}`)
+            }
+            toggleSpinnerButtons()
+            return
+        }
+
+        dialogueInput.focus()
+        window.sequenceEditor.historyState.push(sequence)
+
+        if (window.userSettings.clear_text_after_synth) {
+            dialogueInput.value = ""
+        }
+
+        res = res.split("\n")
+        let pitchData = res[0]
+        let durationsData = res[1]
+        let energyData = res[2]
+        let em_angryData = res[3]
+        let em_happyData = res[4]
+        let em_sadData = res[5]
+        let em_surpriseData = res[6]
+        const editorStyles = res[7]&&res[7].length ? JSON.parse(res[7]) : undefined
+        let cleanedSequence = res[8].split("|").map(c=>c.replaceAll("{", "").replaceAll("}", "").replace(/\s/g, "_"))
+        const start_index = res[9]
+        const end_index = res[10]
+        pitchData = pitchData.split(",").map(v => parseFloat(v))
+
+        // For use in adjusting editor range
+        const maxPitchVal = pitchData.reduce((p,c)=>Math.max(p, Math.abs(c)), 0)
+        if (maxPitchVal>window.sequenceEditor.default_pitchSliderRange) {
+            window.sequenceEditor.pitchSliderRange = maxPitchVal
+        } else {
+            window.sequenceEditor.pitchSliderRange = window.sequenceEditor.default_pitchSliderRange
+        }
+
+        em_angryData = em_angryData.length ? em_angryData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : []
+        em_happyData = em_happyData.length ? em_happyData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : []
+        em_sadData = em_sadData.length ? em_sadData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : []
+        em_surpriseData = em_surpriseData.length ? em_surpriseData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v)) : []
+
+        if (energyData.length) {
+            energyData = energyData.split(",").map(v => parseFloat(v)).filter(v => !isNaN(v))
+
+            // For use in adjusting editor range
+            const maxEnergyVal = energyData.reduce((p,c)=>Math.max(p, c), 0)
+            const minEnergyVal = energyData.reduce((p,c)=>Math.min(p, c), 100)
+
+            if (minEnergyVal<window.sequenceEditor.default_MIN_ENERGY) {
+                window.sequenceEditor.MIN_ENERGY = minEnergyVal
+            } else {
+                window.sequenceEditor.MIN_ENERGY = window.sequenceEditor.default_MIN_ENERGY
+            }
+            if (maxEnergyVal>window.sequenceEditor.default_MAX_ENERGY) {
+                window.sequenceEditor.MAX_ENERGY = maxEnergyVal
+            } else {
+                window.sequenceEditor.MAX_ENERGY = window.sequenceEditor.default_MAX_ENERGY
+            }
+
+        } else {
+            energyData = []
+        }
+        durationsData = durationsData.split(",").map(v => isFreshRegen ? parseFloat(v) : parseFloat(v)/pace_slid.value)
+
+        const doTheRest = () => {
+
+            window.sequenceEditor.base_lang = base_lang_select.value
+            window.sequenceEditor.inputSequence = sequence
+            window.sequenceEditor.sequence = cleanedSequence
+
+            if (pitch.length==0 || isFreshRegen) {
+                window.sequenceEditor.resetPitch = pitchData
+                window.sequenceEditor.resetDurs = durationsData
+                window.sequenceEditor.resetEnergy = energyData
+                window.sequenceEditor.resetEmAngry = em_angryData
+                window.sequenceEditor.resetEmHappy = em_happyData
+                window.sequenceEditor.resetEmSad = em_sadData
+                window.sequenceEditor.resetEmSurprise = em_surpriseData
+            }
+
+            window.sequenceEditor.letters = cleanedSequence
+            window.sequenceEditor.pitchNew = pitchData.map(p=>p)
+            window.sequenceEditor.dursNew = durationsData.map(v=>v)
+            window.sequenceEditor.energyNew = energyData.map(v=>v)
+            if (window.currentModel.modelType=="xVAPitch") {
+                window.sequenceEditor.emAngryNew = em_angryData.map(v=>v)
+                window.sequenceEditor.emHappyNew = em_happyData.map(v=>v)
+                window.sequenceEditor.emSadNew = em_sadData.map(v=>v)
+                window.sequenceEditor.emSurpriseNew = em_surpriseData.map(v=>v)
+                window.sequenceEditor.loadStylesData(editorStyles)
+            }
+            window.sequenceEditor.init()
+            const pitchRange = window.userSettings.pitchrangeoverride ? window.userSettings.pitchrangeoverride : window.sequenceEditor.pitchSliderRange
+            window.sequenceEditor.update(window.currentModel.modelType, pitchRange)
+
+            window.sequenceEditor.sliderBoxes.forEach((box, i) => {box.setValueFromValue(window.sequenceEditor.dursNew[i])})
+            window.sequenceEditor.autoInferTimer = null
+            window.sequenceEditor.hasChanged = false
+
+
+            toggleSpinnerButtons()
+            if (keepSampleButton.dataset.newFileLocation && keepSampleButton.dataset.newFileLocation.startsWith("BATCH_EDIT")) {
+                console.log("_debug_")
+            } else {
+                if (window.userSettings[`outpath_${game}`]) {
+                    keepSampleButton.dataset.newFileLocation = `${window.userSettings[`outpath_${game}`]}/${voiceType}/${outputFileName}.wav`
+                } else {
+                    keepSampleButton.dataset.newFileLocation = `${__dirname.replace(/\\/g,"/")}/output/${voiceType}/${outputFileName}.wav`
+                }
+            }
+            keepSampleButton.disabled = false
+            window.tempFileLocation = tempFileLocation
+
+
+            // Wavesurfer
+            if (!window.wavesurfer) {
+                window.initWaveSurfer(`${__dirname.replace("/javascript", "")}/output/${tempFileLocation.split("/").reverse()[0]}`)
+            } else {
+                window.wavesurfer.load(`${__dirname.replace("/javascript", "")}/output/${tempFileLocation.split("/").reverse()[0]}`)
+            }
+
+            window.wavesurfer.on("ready",  () => {
+
+                wavesurferContainer.style.opacity = 1
+
+                if (window.userSettings.autoPlayGen) {
+
+                    if (window.userSettings.playChangedAudio) {
+                        const playbackStartEnd = window.sequenceEditor.getChangedTimeStamps(start_index, end_index, window.wavesurfer.getDuration())
+                        if (playbackStartEnd) {
+                            wavesurfer.play(playbackStartEnd[0], playbackStartEnd[1])
+                        } else {
+                            wavesurfer.play()
+                        }
+                    } else {
+                        wavesurfer.play()
+                    }
+                    window.sequenceEditor.adjustedLetters = new Set()
+                    samplePlayPause.innerHTML = window.i18n.PAUSE
+                }
+            })
+
+            // Persistance across sessions
+            localStorage.setItem("tempFileLocation", tempFileLocation)
+        }
+
+
+        if (window.userSettings.audio.ffmpeg) {
+            const options = {
+                hz: window.userSettings.audio.hz,
+                padStart: window.userSettings.audio.padStart,
+                padEnd: window.userSettings.audio.padEnd,
+                bit_depth: window.userSettings.audio.bitdepth,
+                amplitude: window.userSettings.audio.amplitude,
+                pitchMult: window.userSettings.audio.pitchMult,
+                tempo: window.userSettings.audio.tempo,
+                deessing: window.userSettings.audio.deessing,
+                nr: window.userSettings.audio.nr,
+                nf: window.userSettings.audio.nf,
+                useNR: window.userSettings.audio.useNR,
+                useSR: useSRCkbx.checked,
+                useCleanup: useCleanupCkbx.checked,
+            }
+
+            const extraInfo = {
+                game: window.currentGame.gameId,
+                voiceId: window.currentModel.voiceId,
+                voiceName: window.currentModel.voiceName,
+                inputSequence: sequence,
+                letters: cleanedSequence,
+                pitch: pitchData.map(p=>p),
+                energy: energyData.map(p=>p),
+                em_angry: em_angryData.map(p=>p),
+                em_happy: em_happyData.map(p=>p),
+                em_sad: em_sadData.map(p=>p),
+                em_surprise: em_surpriseData.map(p=>p),
+                durations: durationsData.map(v=>v)
+            }
+
+            doFetch(`http://localhost:8008/outputAudio`, {
+                method: "Post",
+                body: JSON.stringify({
+                    input_path: tempFileLocation,
+                    output_path: tempFileLocation.replace(".wav", `_ffmpeg.${window.userSettings.audio.format}`),
+                    pluginsContext: JSON.stringify(window.pluginsContext),
+                    extraInfo: JSON.stringify(extraInfo),
+                    isBatchMode: false,
+                    options: JSON.stringify(options)
+                })
+            }).then(r=>r.text()).then(res => {
+                if (res.length && res!="-") {
+                    console.log("res", res)
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res}`).then(() => toggleSpinnerButtons())
+                } else {
+                    tempFileLocation = tempFileLocation.replace(".wav", `_ffmpeg.${window.userSettings.audio.format}`)
+                    doTheRest()
+                }
+            }).catch(res => {
+                console.log(res)
+                window.appLogger.log(`outputAudio error: ${res}`)
+                // closeModal().then(() => {
+                    window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>${res}`)
+                // })
+            })
+        } else {
+            doTheRest()
+        }
+
+
+    }).catch(res => {
+        window.isGenerating = false
+        console.log(res)
+        window.appLogger.log(res)
+        window.errorModal(window.i18n.SOMETHING_WENT_WRONG)
+        toggleSpinnerButtons()
+    })
+}
+
+generateVoiceButton.addEventListener("click", () => {
+    try {fs.mkdirSync(window.userSettings[`outpath_${game}`])} catch (e) {/*Do nothing*/}
+    try {fs.mkdirSync(`${window.userSettings[`outpath_${game}`]}/${voiceId}`)} catch (e) {/*Do nothing*/}
+
+    if (generateVoiceButton.dataset.modelQuery && generateVoiceButton.dataset.modelQuery!="null") {
+        window.loadModel()
+    } else {
+        window.synthesizeSample()
+    }
+})
+
+
+
+
+window.saveFile = (from, to, skipUIRecord=false) => {
+    to = to.split("%20").join(" ")
+    to = to.replace(".wav", `.${window.userSettings.audio.format}`)
+
+    // Make the containing folder if it does not already exist
+    let containerFolderPath = to.split("/")
+    containerFolderPath = containerFolderPath.slice(0,containerFolderPath.length-1).join("/")
+
+    try {fs.mkdirSync(containerFolderPath)} catch (e) {/*Do nothing*/}
+
+    // For plugins
+    const pluginData = {
+        game: window.currentGame.gameId,
+        voiceId: window.currentModel.voiceId,
+        voiceName: window.currentModel.voiceName,
+        inputSequence: window.sequenceEditor.inputSequence,
+        letters: window.sequenceEditor.letters,
+        pitch: window.sequenceEditor.pitchNew,
+        durations: window.sequenceEditor.dursNew,
+        vocoder: vocoder_select.value,
+        from, to
+    }
+    const options = {
+        hz: window.userSettings.audio.hz,
+        padStart: window.userSettings.audio.padStart,
+        padEnd: window.userSettings.audio.padEnd,
+        bit_depth: window.userSettings.audio.bitdepth,
+        amplitude: window.userSettings.audio.amplitude,
+        pitchMult: window.userSettings.audio.pitchMult,
+        tempo: window.userSettings.audio.tempo,
+        deessing: window.userSettings.audio.deessing,
+        nr: window.userSettings.audio.nr,
+        nf: window.userSettings.audio.nf,
+        useNR: window.userSettings.audio.useNR,
+        useSR: useSRCkbx.checked
+    }
+    pluginData.audioOptions = options
+    window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["keep-sample"]["pre"], event="pre keep-sample", pluginData)
+
+    const jsonDataOut = {
+        modelType: window.currentModel.modelType,
+        modelVersion: window.currentModel.modelVersion,
+        version: window.currentModel.version,
+        inputSequence: dialogueInput.value.trim(),
+        pacing: parseFloat(pace_slid.value),
+        letters: window.sequenceEditor.letters,
+        currentVoice: window.sequenceEditor.currentVoice,
+        resetEnergy: window.sequenceEditor.resetEnergy,
+        resetPitch: window.sequenceEditor.resetPitch,
+        resetDurs: window.sequenceEditor.resetDurs,
+        resetEmAngry: window.sequenceEditor.resetEmAngry,
+        resetEmHappy: window.sequenceEditor.resetEmHappy,
+        resetEmSad: window.sequenceEditor.resetEmSad,
+        resetEmSurprise: window.sequenceEditor.resetEmSurprise,
+        styleValuesReset: window.sequenceEditor.styleValuesReset,
+        ampFlatCounter: window.sequenceEditor.ampFlatCounter,
+        inputSequence: window.sequenceEditor.inputSequence,
+        sequence: window.sequenceEditor.sequence,
+        pitchNew: window.sequenceEditor.pitchNew,
+        energyNew: window.sequenceEditor.energyNew,
+        dursNew: window.sequenceEditor.dursNew,
+        emAngryNew: window.sequenceEditor.emAngryNew,
+        emHappyNew: window.sequenceEditor.emHappyNew,
+        emSadNew: window.sequenceEditor.emSadNew,
+        emSurpriseNew: window.sequenceEditor.emSurpriseNew,
+        styleValuesNew: window.sequenceEditor.styleValuesNew,
+    }
+
+    let outputFileName = to.split("/").reverse()[0].split(".").reverse().slice(1, 1000)
+    const toExt = to.split(".").reverse()[0]
+
+    if (window.userSettings.filenameNumericalSeq) {
+        outputFileName = outputFileName[0]+"."+outputFileName.slice(1,1000).reverse().join(".")
+    } else {
+        outputFileName = outputFileName.reverse().join(".")
+    }
+    to = `${to.split("/").reverse().slice(1,10000).reverse().join("/")}/${outputFileName}`
+
+
+    const allFiles = fs.readdirSync(`${path}/output`).filter(fname => fname.includes(from.split("/").reverse()[0].split(".")[0]))
+    const toFolder = to.split("/").reverse().slice(1, 1000).reverse().join("/")
+
+
+    allFiles.forEach(fname => {
+        const ext = fname.split(".").reverse()[0]
+        fs.copyFile(`${path}/output/${fname}`, `${toFolder}/${outputFileName}.${ext}`, err => {
+            if (err) {
+                console.log(err)
+                window.appLogger.log(`Error in saveFile->outputAudio[no ffmpeg]: ${err}`)
+                if (!fs.existsSync(from)) {
+                    window.appLogger.log(`${window.i18n.TEMP_FILE_NOT_EXIST}: ${from}`)
+                }
+                if (!fs.existsSync(toFolder)) {
+                    window.appLogger.log(`${window.i18n.OUT_DIR_NOT_EXIST}: ${toFolder}`)
+                }
+            } else {
+                if (window.userSettings.outputJSON && window.sequenceEditor.letters.length) {
+                    fs.writeFileSync(`${to}.${toExt}.json`, JSON.stringify(jsonDataOut, null, 4))
+                }
+                if (!skipUIRecord) {
+                    window.initMainPagePagination(`${window.userSettings[`outpath_${window.currentGame.gameId}`]}/${window.currentModel.voiceId}`)
+                    window.refreshRecordsList()
+                }
+                window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["keep-sample"]["post"], event="post keep-sample", pluginData)
+            }
+        })
+    })
+}
+
+window.keepSampleFunction = shiftClick => {
+    if (keepSampleButton.dataset.newFileLocation) {
+
+        const skipUIRecord = keepSampleButton.dataset.newFileLocation.includes("BATCH_EDIT")
+        let fromLocation = window.tempFileLocation
+        let toLocation = keepSampleButton.dataset.newFileLocation.replace("BATCH_EDIT", "")
+
+        if (!skipUIRecord) {
+            toLocation = toLocation.split("/")
+            toLocation[toLocation.length-1] = toLocation[toLocation.length-1].replace(/[\/\\:\*?<>"|]*/g, "")
+            toLocation[toLocation.length-1] = toLocation[toLocation.length-1].replace(/\.wav$/, "").slice(0, window.userSettings.max_filename_chars).replace(/\.$/, "")
+        }
+
+
+        // Numerical file name counter
+        if (!skipUIRecord && window.userSettings.filenameNumericalSeq) {
+            let existingFiles = []
+            try {
+                existingFiles = fs.readdirSync(toLocation.slice(0, toLocation.length-1).join("/")).filter(fname => !fname.endsWith(".json"))
+            } catch (e) {
+                console.log(e)
+            }
+            existingFiles = existingFiles.filter(fname => fname.includes(toLocation[toLocation.length-1]))
+            existingFiles = existingFiles.map(fname => {
+                const parts = fname.split(".")
+                parts.reverse()
+                if (parts.length>2 && parts.reverse()[0].length) {
+                    if (parseInt(parts[0]) != NaN) {
+                        return parseInt(parts[0])
+                    }
+                }
+                return null
+            })
+            existingFiles = existingFiles.filter(val => !!val)
+            if (existingFiles.length==0) {
+                existingFiles.push(0)
+            }
+
+            if (existingFiles.length) {
+                existingFiles = existingFiles.sort((a,b) => {a<b?-1:1})
+                toLocation[toLocation.length-1] = `${toLocation[toLocation.length-1]}.${String(existingFiles[existingFiles.length-1]+1).padStart(4, "0")}`
+            }
+        }
+
+
+        if (!skipUIRecord) {
+            toLocation[toLocation.length-1] += ".wav"
+            toLocation = toLocation.join("/")
+        }
+
+
+        const outFolder = toLocation.split("/").reverse().slice(2, 100).reverse().join("/")
+        if (!fs.existsSync(outFolder)) {
+            return void window.errorModal(`${window.i18n.OUT_DIR_NOT_EXIST}:<br><br><i>${outFolder}</i><br><br>${window.i18n.YOU_CAN_CHANGE_IN_SETTINGS}`)
+        }
+
+        // File name conflict
+        const alreadyExists = fs.existsSync(toLocation)
+        if (alreadyExists || shiftClick) {
+
+            const promptText = alreadyExists ? window.i18n.FILE_EXISTS_ADJUST : window.i18n.ENTER_FILE_NAME
+
+            createModal("prompt", {
+                prompt: promptText,
+                value: toLocation.split("/").reverse()[0].replace(".wav", `.${window.userSettings.audio.format}`)
+            }).then(newFileName => {
+
+                let toLocationOut = toLocation.split("/").reverse()
+                toLocationOut[0] = newFileName.replace(`.${window.userSettings.audio.format}`, "") + `.${window.userSettings.audio.format}`
+                let outDir = toLocationOut
+                outDir.shift()
+
+                newFileName = (newFileName.replace(`.${window.userSettings.audio.format}`, "") + `.${window.userSettings.audio.format}`).replace(/[\/\\:\*?<>"|]*/g, "")
+                toLocationOut.reverse()
+                toLocationOut.push(newFileName)
+
+                if (fs.existsSync(outDir.slice(0, outDir.length-1).join("/"))) {
+                    const existingFiles = fs.readdirSync(outDir.slice(0, outDir.length-1).join("/"))
+                    const existingFileConflict = existingFiles.filter(name => name==newFileName)
+
+
+                    const finalOutLocation = toLocationOut.join("/")
+
+                    if (existingFileConflict.length) {
+                        // Remove the entry from the output files' preview
+                        Array.from(voiceSamples.querySelectorAll("div.sample")).forEach(sampleElem => {
+                            let sourceSrc = sampleElem.children[0].children[0].innerText
+                            sourceSrc = sourceSrc.split("/").reverse()
+                            const finalFileName = finalOutLocation.split("/").reverse()
+
+                            if (sourceSrc[0] == finalFileName[0]) {
+                                sampleElem.parentNode.removeChild(sampleElem)
+                            }
+                        })
+
+                        // Remove the old file and write the new one in
+                        fs.unlink(finalOutLocation, err => {
+                            if (err) {
+                                console.log(err)
+                                window.appLogger.log(`Error in keepSample: ${err}`)
+                            }
+                            window.saveFile(fromLocation, finalOutLocation, skipUIRecord)
+                        })
+                        return
+                    } else {
+                        window.saveFile(fromLocation, toLocationOut.join("/"), skipUIRecord)
+                        return
+                    }
+                }
+                window.saveFile(fromLocation, toLocationOut.join("/"), skipUIRecord)
+            })
+
+        } else {
+            window.saveFile(fromLocation, toLocation, skipUIRecord)
+        }
+    }
+}
+keepSampleButton.addEventListener("click", event => keepSampleFunction(event.shiftKey))
+
+
+
+// Weird recursive intermittent promises to repeatedly check if the server is up yet - but it works!
+window.serverIsUp = false
+const serverStartingMessage = `${window.i18n.LOADING}...<br>${window.i18n.MAY_TAKE_A_MINUTE}<br><br>${window.i18n.STARTING_PYTHON}...`
+window.doWeirdServerStartupCheck = () => {
+    const check = () => {
+        return new Promise(topResolve => {
+            if (window.serverIsUp) {
+                topResolve()
+            } else {
+                (new Promise((resolve, reject) => {
+                    // Gather the model paths to send to the server
+                    const modelsPaths = {}
+                    Object.keys(window.userSettings).filter(key => key.includes("modelspath_")).forEach(key => {
+                        modelsPaths[key.split("_")[1]] = window.userSettings[key]
+                    })
+
+                    doFetch(`http://localhost:8008/checkReady`, {
+                        method: "Post",
+                        body: JSON.stringify({
+                            device: (window.userSettings.useGPU&&window.userSettings.installation=="gpu")?"gpu":"cpu",
+                            modelsPaths: JSON.stringify(modelsPaths)
+                        })
+                    }).then(r => r.text()).then(r => {
+                        closeModal([document.querySelector("#activeModal"), modalContainer], [totdContainer, EULAContainer], true).then(() => {
+                            window.pluginsManager.updateUI()
+                            if (!window.pluginsManager.hasRunPostStartPlugins) {
+                                window.pluginsManager.hasRunPostStartPlugins = true
+                                window.pluginsManager.runPlugins(window.pluginsManager.pluginsModules["start"]["post"], event="post start")
+                                window.electronBrowserWindow.setProgressBar(-1)
+                                window.checkForWorkshopInstallations()
+                            }
+                        })
+                        window.serverIsUp = true
+                        if (window.userSettings.installation=="cpu") {
+
+                            if (useGPUCbx.checked) {
+                                doFetch(`http://localhost:8008/setDevice`, {
+                                    method: "Post",
+                                    body: JSON.stringify({device: "cpu"})
+                                })
+                            }
+                            useGPUCbx.checked = false
+                            useGPUCbx.disabled = true
+                            window.userSettings.useGPU = false
+                            saveUserSettings()
+                        }
+
+                        resolve()
+                    }).catch((err) => {
+                        reject()
+                    })
+                })).catch(() => {
+                    setTimeout(async () => {
+                        await check()
+                        topResolve()
+                    }, 100)
+                })
+            }
+        })
+    }
+
+    check()
+}
+window.doWeirdServerStartupCheck()
+
+modalContainer.addEventListener("click", event => {
+    try {
+        if (event.target==modalContainer && activeModal.dataset.type!="spinner") {
+            closeModal()
+        }
+    } catch (e) {}
+})
+
+
+// Cached UI stuff
+// =========
+dialogueInput.addEventListener("keyup", (event) => {
+    localStorage.setItem("dialogueInput", " "+dialogueInput.value.trim()+" ")
+    window.sequenceEditor.hasChanged = true
+})
+
+const dialogueInputCache = localStorage.getItem("dialogueInput")
+
+if (dialogueInputCache) {
+    dialogueInput.value = dialogueInputCache
+}
+
+// =========
+
+
+
+
+
+
+
+
+vocoder_select.value = window.userSettings.vocoder.includes(".hg.") ? "qnd" : window.userSettings.vocoder
+window.changeVocoder = vocoder => {
+    return new Promise(resolve => {
+        spinnerModal(window.i18n.CHANGING_MODELS)
+        doFetch(`http://localhost:8008/setVocoder`, {
+            method: "Post",
+            body: JSON.stringify({
+                vocoder,
+                modelPath: vocoder=="256_waveglow" ? window.userSettings.waveglow_path : window.userSettings.bigwaveglow_path
+            })
+        }).then(r=>r.text()).then((res) => {
+            closeModal().then(() => {
+                setTimeout(() => {
+                    if (res=="ENOENT") {
+                        vocoder_select.value = window.userSettings.vocoder
+                        window.errorModal(`${window.i18n.BATCH_MODEL_NOT_FOUND}.${vocoder.includes("waveglow")?" "+window.i18n.BATCH_DOWNLOAD_WAVEGLOW:""}`)
+                        resolve()
+                    } else {
+                        window.batch_state.lastVocoder = vocoder
+                        window.userSettings.vocoder = vocoder
+                        saveUserSettings()
+                        resolve()
+                    }
+                }, 300)
+            })
+        })
+    })
+}
+vocoder_select.addEventListener("change", () => window.changeVocoder(vocoder_select.value))
+
+useSRCkbx.addEventListener("click", () => {
+    let userHasSeenThisAlready = localStorage.getItem("useSRHintSeen")
+    if (useSRCkbx.checked && !userHasSeenThisAlready) {
+        window.confirmModal(window.i18n.USE_SR_HINT).then(resp => {
+            if (resp) {
+                localStorage.setItem("useSRHintSeen", "true")
+            }
+        })
+    }
+
+})
+
+dialogueInput.addEventListener("contextmenu", event => {
+    event.preventDefault()
+    ipcRenderer.send('show-context-menu')
+})
+ipcRenderer.on('context-menu-command', (e, command) => {
+    if (command=="context-copy") {
+        if (dialogueInput.selectionStart != dialogueInput.selectionEnd) {
+            clipboard.writeText(dialogueInput.value.slice(dialogueInput.selectionStart, dialogueInput.selectionEnd))
+        }
+    } else if (command=="context-paste") {
+        if (clipboard.readText().length) {
+            let newString = dialogueInput.value.slice(0, dialogueInput.selectionStart) + clipboard.readText() + dialogueInput.value.slice(dialogueInput.selectionEnd, dialogueInput.value.length)
+            dialogueInput.value = newString
+        }
+    }
+})
+
+
+window.setupModal(workbenchIcon, workbenchContainer, () => window.initVoiceWorkbench())
+
+
+// Info
+// ====
+window.setupModal(infoIcon, infoContainer)
+
+
+// Patreon
+// =======
+window.setupModal(patreonIcon, patreonContainer, () => {
+    const data = fs.readFileSync(`${path}/patreon.txt`, "utf8") + ", minermanb"
+    creditsList.innerHTML = data
+})
+
+
+// Updates
+// =======
+app_version.innerHTML = window.appVersion
+updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${window.appVersion}`
+
+const checkForUpdates = () => {
+    doFetch("http://danruta.co.uk/xvasynth_updates.txt").then(r=>r.json()).then(data => {
+        fs.writeFileSync(`${path}/updates.json`, JSON.stringify(data), "utf8")
+        checkUpdates.innerHTML = window.i18n.CHECK_FOR_UPDATES
+        window.showUpdates()
+    }).catch(() => {
+        checkUpdates.innerHTML = window.i18n.CANT_REACH_SERVER
+    })
+}
+window.showUpdates = () => {
+    window.updatesLog = fs.readFileSync(`${path}/updates.json`, "utf8")
+    window.updatesLog = JSON.parse(window.updatesLog)
+    const sortedLogVersions = Object.keys(window.updatesLog).map( a => a.split('.').map( n => +n+100000 ).join('.') ).sort()
+        .map( a => a.split('.').map( n => +n-100000 ).join('.') )
+
+    const appVersion = window.appVersion.replace("v", "")
+    const appIsUpToDate = sortedLogVersions.indexOf(appVersion)==(sortedLogVersions.length-1) || sortedLogVersions.indexOf(appVersion)==-1
+
+    if (!appIsUpToDate) {
+        update_nothing.style.display = "none"
+        update_something.style.display = "block"
+        updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${appVersion}. ${window.i18n.AVAILABLE}: ${sortedLogVersions[sortedLogVersions.length-1]}`
+    } else {
+        updatesVersions.innerHTML = `${window.i18n.THIS_APP_VERSION}: ${appVersion}. ${window.i18n.UPTODATE}`
+    }
+
+    updatesLogList.innerHTML = ""
+    sortedLogVersions.reverse().forEach(version => {
+        const versionLabel = createElem("h2", version)
+        const logItem = createElem("div", versionLabel)
+        window.updatesLog[version].split("\n").forEach(line => {
+            logItem.appendChild(createElem("div", line))
+        })
+        updatesLogList.appendChild(logItem)
+    })
+}
+checkForUpdates()
+window.setupModal(updatesIcon, updatesContainer)
+
+checkUpdates.addEventListener("click", () => {
+    checkUpdates.innerHTML = window.i18n.CHECKING_FOR_UPDATES
+    checkForUpdates()
+})
+window.showUpdates()
+
+
+// Batch generation
+// ========
+window.setupModal(batchIcon, batchGenerationContainer)
+
+// Settings
+// ========
+window.setupModal(settingsCog, settingsContainer)
+
+// Change Game
+// ===========
+window.setupModal(changeGameButton, gameSelectionContainer)
+changeGameButton.addEventListener("click", () => searchGameInput.focus())
+
+window.gameAssets = {}
+
+window.updateGameList = (doLoadAllModels=true) => {
+    gameSelectionListContainer.innerHTML = ""
+    const fileNames = fs.readdirSync(`${window.path}/assets`)
+
+    let totalVoices = 0
+    let totalGames = new Set()
+
+    const itemsToSort = []
+    // const gameIDs = doLoadAllModels ? fileNames.filter(fn=>fn.endsWith(".json")) : Object.keys(window.games).map(gID => gID+".json")
+    const gameIDs = fileNames.filter(fn=>fn.endsWith(".json"))
+
+    gameIDs.forEach(gameId => {
+
+        const metadata = fs.existsSync(`${window.path}/assets/${gameId}`) ? JSON.parse(fs.readFileSync(`${window.path}/assets/${gameId}`)) : window.games[gameId.replace(".json", "")].dummyGameTheme
+        gameId = gameId.replace(".json", "")
+        metadata.gameId = gameId
+        const assetFile = metadata.assetFile
+
+        const gameSelection = createElem("div.gameSelection")
+        gameSelection.style.background = `url("assets/${assetFile}")`
+
+        const gameName = metadata.gameName
+        const gameSelectionContent = createElem("div.gameSelectionContent")
+
+
+        let numVoices = 0
+        const modelsPath = window.userSettings[`modelspath_${gameId}`]
+        if (fs.existsSync(modelsPath)) {
+            const files = fs.readdirSync(modelsPath)
+            numVoices = files.filter(fn => fn.includes(".json")).length
+            totalVoices += numVoices
+        }
+        if (numVoices==0) {
+            gameSelectionContent.style.background = "rgba(150,150,150,0.7)"
+        } else {
+            gameSelectionContent.classList.add("gameSelectionContentToHover")
+            totalGames.add(gameId)
+        }
+
+        gameSelectionContent.appendChild(createElem("div", `${numVoices} ${(numVoices>1||numVoices==0)?window.i18n.VOICE_PLURAL:window.i18n.VOICE}`))
+        gameSelectionContent.appendChild(createElem("div", gameName))
+
+        gameSelection.appendChild(gameSelectionContent)
+
+        window.gameAssets[gameId] = metadata
+        gameSelectionContent.addEventListener("click", () => {
+            voiceSearchInput.focus()
+            searchGameInput.value = ""
+            changeGame(metadata)
+            closeModal(gameSelectionContainer)
+            Array.from(gameSelectionListContainer.children).forEach(elem => elem.style.display="flex")
+        })
+
+        itemsToSort.push([numVoices, gameSelection])
+
+        const modelsDir = window.userSettings[`modelspath_${gameId}`]
+        if (!window.watchedModelsDirs.includes(modelsDir)) {
+            window.watchedModelsDirs.push(modelsDir)
+
+            try {
+                fs.watch(modelsDir, {recursive: false, persistent: true}, (eventType, filename) => {
+                    if (window.userSettings.autoReloadVoices) {
+                        if (doLoadAllModels) {
+                            loadAllModels().then(() => changeGame(metadata))
+                        }
+                    }
+                })
+            } catch (e) {
+                // console.log(e)
+            }
+        }
+    })
+
+
+    itemsToSort.sort((a,b) => a[0]<b[0]?1:-1).forEach(([numVoices, elem]) => {
+        gameSelectionListContainer.appendChild(elem)
+    })
+
+    searchGameInput.addEventListener("keyup", (event) => {
+
+        if (event.key=="Enter") {
+            const voiceElems = Array.from(gameSelectionListContainer.children).filter(elem => elem.style.display=="flex")
+            if (voiceElems.length==1) {
+                voiceElems[0].children[0].click()
+                searchGameInput.value = ""
+            }
+        }
+
+        const voiceElems = Array.from(gameSelectionListContainer.children)
+        if (searchGameInput.value.length) {
+            voiceElems.forEach(elem => {
+                if (elem.children[0].children[1].innerHTML.toLowerCase().includes(searchGameInput.value)) {
+                    elem.style.display="flex"
+                } else {
+                    elem.style.display="none"
+                }
+            })
+
+        } else {
+            voiceElems.forEach(elem => elem.style.display="block")
+        }
+    })
+
+    searchGameInput.placeholder = window.i18n.SEARCH_N_GAMES_WITH_N2_VOICES.replace("_1", Array.from(totalGames).length).replace("_2", totalVoices)
+
+    if (doLoadAllModels) {
+        loadAllModels().then(() => {
+            // Load the last selected game
+            const lastGame = localStorage.getItem("lastGame")
+
+            if (lastGame) {
+                changeGame(JSON.parse(lastGame))
+            }
+        })
+    }
+}
+window.updateGameList()
+
+
+// Embeddings
+// ==========
+window.setupModal(embeddingsIcon, embeddingsContainer, () => {
+    setTimeout(() => {
+        if (window.embeddingsState.isReady) {
+            window.embeddings_updateSize()
+        }
+    }, 100)
+    window.embeddings_updateSize()
+    window.embeddingsState.isOpen = true
+    if (!window.embeddingsState.ready) {
+        setTimeout(() => {
+            window.embeddingsState.ready = true
+            window.initEmbeddingsScene()
+            setTimeout(() => {
+                window.computeEmbsAndDimReduction(true)
+            }, 300)
+        }, 100)
+    }
+}, () => {
+    window.embeddingsState.isOpen = false
+})
+
+// Arpabet
+// =======
+window.setupModal(arpabetIcon, arpabetContainer, () => setTimeout(()=> !window.arpabetMenuState.hasInitialised && window.refreshDictionariesList(), 100))
+
+
+// Plugins
+// =======
+window.setupModal(pluginsIcon, pluginsContainer)
+
+
+window.setupModal(style_emb_manage_btn, styleEmbeddingsContainer, window.styleEmbsModalOpenCallback)
+
+
+// Other
+// =====
+window.setupModal(reset_what_open_btn, resetContainer)
+window.setupModal(i18n_batch_metadata_open_btn, batchMetadataCSVContainer)
+
+voiceSearchInput.addEventListener("keyup", () => {
+
+    if (event.key=="Enter") {
+        const voiceElems = Array.from(voiceTypeContainer.children).filter(elem => elem.style.display=="block")
+        if (voiceElems.length==1) {
+            voiceElems[0].click()
+            generateVoiceButton.click()
+            voiceSearchInput.value = ""
+        }
+    }
+
+    const voiceElems = Array.from(voiceTypeContainer.children)
+
+    if (voiceSearchInput.value.length) {
+        voiceElems.forEach(elem => {
+            if (elem.innerHTML.toLowerCase().includes(voiceSearchInput.value)) {
+                elem.style.display="block"
+            } else {
+                elem.style.display="none"
+            }
+        })
+
+    } else {
+        voiceElems.forEach(elem => elem.style.display="block")
+    }
+})
+
+// Splash/EULA
+splashNextButton1.addEventListener("click", () => {
+    splash_screen1.style.display = "none"
+    splash_screen2.style.display = "flex"
+})
+EULA_closeButon.addEventListener("click", () => {
+    if (EULA_accept_ckbx.checked) {
+        closeModal(EULAContainer)
+        window.userSettings.EULA_accepted_2023 = true
+        saveUserSettings()
+
+        if (!window.totd_state.startupChecked) {
+            window.showTipIfEnabledAndNewDay().then(() => {
+                if (!serverIsUp) {
+                    spinnerModal(serverStartingMessage)
+                }
+            })
+        }
+
+        if (!serverIsUp && totdContainer.style.display=="none") {
+            window.spinnerModal(serverStartingMessage)
+        }
+    }
+})
+if (!Object.keys(window.userSettings).includes("EULA_accepted_2023") || !window.userSettings.EULA_accepted_2023) {
+    EULAContainer.style.opacity = 0
+    EULAContainer.style.display = "flex"
+    requestAnimationFrame(() => requestAnimationFrame(() => EULAContainer.style.opacity = 1))
+    requestAnimationFrame(() => requestAnimationFrame(() => chromeBar.style.opacity = 1))
+} else {
+    window.showTipIfEnabledAndNewDay().then(() => {
+        // If not, or the user closed the window quickly, show the server is starting message if still booting up
+        if (!window.serverIsUp) {
+            spinnerModal(serverStartingMessage)
+        }
+    })
+}
+
+
+// Links
+document.querySelectorAll('a[href^="http"]').forEach(a => a.addEventListener("click", e => {
+    event.preventDefault()
+    shell.openExternal(a.href)
+}))

javascript/settingsMenu.js

@@ -0,0 +1,960 @@
+"use strict"
+
+const er = require('@electron/remote')
+const saveUserSettings = () => localStorage.setItem("userSettings", JSON.stringify(window.userSettings))
+// const saveUserSettings = () => {}
+
+const deleteFolderRecursive = function (directoryPath) {
+    if (fs.existsSync(directoryPath)) {
+        fs.readdirSync(directoryPath).forEach((file, index) => {
+          const curPath = `${directoryPath}/${file}`;
+          if (fs.lstatSync(curPath).isDirectory()) {
+           // recurse
+            deleteFolderRecursive(curPath);
+          } else {
+            // delete file
+            fs.unlinkSync(curPath);
+          }
+        });
+        fs.rmdirSync(directoryPath);
+      }
+    };
+
+// Load user settings
+window.userSettings = localStorage.getItem("userSettings") ||
+// window.userSettings =
+    {
+        useGPU: false,
+        customWindowSize:`${window.innerHeight},${window.innerWidth}`,
+        base_speaker: "default",
+        autoplay: true,
+        autoPlayGen: false,
+        audio: {
+            format: "wav"
+        },
+        plugins: {
+
+        }
+    }
+if ((typeof window.userSettings)=="string") {
+    window.userSettings = JSON.parse(window.userSettings)
+}
+if (!Object.keys(window.userSettings).includes("installation")) { // For backwards compatibility
+    window.userSettings.installation = "cpu"
+}
+if (!Object.keys(window.userSettings).includes("audio")) { // For backwards compatibility
+    window.userSettings.audio = {format: "wav", hz: 44100, padStart: 0, padEnd: 0, pitchMult: 1, tempo: 1, nr: 5, nf: -20, deessing: 0.1}
+}
+if (!Object.keys(window.userSettings).includes("sliderTooltip")) { // For backwards compatibility
+    window.userSettings.sliderTooltip = true
+}
+// if (!Object.keys(window.userSettings).includes("darkPrompt")) { // For backwards compatibility
+//     window.userSettings.darkPrompt = false
+// }
+if (!Object.keys(window.userSettings).includes("showDiscordStatus")) { // For backwards compatibility
+    window.userSettings.showDiscordStatus = true
+}
+if (!Object.keys(window.userSettings).includes("prompt_fontSize")) { // For backwards compatibility
+    window.userSettings.prompt_fontSize = 15
+}
+if (!Object.keys(window.userSettings).includes("bg_gradient_opacity")) { // For backwards compatibility
+    window.userSettings.bg_gradient_opacity = 13
+}
+if (!Object.keys(window.userSettings).includes("autoReloadVoices")) { // For backwards compatibility
+    window.userSettings.autoReloadVoices = false
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("hz")) { // For backwards compatibility
+    window.userSettings.audio.hz = 44100
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("padStart")) { // For backwards compatibility
+    window.userSettings.audio.padStart = 0
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("padEnd")) { // For backwards compatibility
+    window.userSettings.audio.padEnd = 0
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("pitchMult")) { // For backwards compatibility
+    window.userSettings.audio.pitchMult = 1
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("tempo")) { // For backwards compatibility
+    window.userSettings.audio.tempo = 1
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("deessing")) { // For backwards compatibility
+    window.userSettings.audio.deessing = 0.1
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("nr")) { // For backwards compatibility
+    window.userSettings.audio.nr = 5
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("nf")) { // For backwards compatibility
+    window.userSettings.audio.nf = -20
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("ffmpeg")) { // For backwards compatibility
+    window.userSettings.audio.ffmpeg = true
+}
+// if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("ffmpeg_preview")) { // For backwards compatibility
+//     window.userSettings.audio.ffmpeg_preview = true
+// }
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("useNR")) { // For backwards compatibility
+    window.userSettings.audio.useNR = true
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("bitdepth")) { // For backwards compatibility
+    window.userSettings.audio.bitdepth = "pcm_s32le"
+}
+if (!Object.keys(window.userSettings).includes("showEditorFFMPEGAmplitude")) { // For backwards compatibility
+    window.userSettings.showEditorFFMPEGAmplitude = false
+}
+if (!Object.keys(window.userSettings).includes("vocoder")) { // For backwards compatibility
+    window.userSettings.vocoder = "256_waveglow"
+}
+if (!Object.keys(window.userSettings).includes("audio") || !Object.keys(window.userSettings.audio).includes("amplitude")) { // For backwards compatibility
+    window.userSettings.audio.amplitude = 1
+}
+if (!Object.keys(window.userSettings).includes("max_filename_chars")) { // For backwards compatibility
+    window.userSettings.max_filename_chars = 70
+}
+if (!Object.keys(window.userSettings).includes("clear_text_after_synth")) { // For backwards compatibility
+    window.userSettings.clear_text_after_synth = false
+}
+if (!Object.keys(window.userSettings).includes("do_model_version_highlight")) { // For backwards compatibility
+    window.userSettings.do_model_version_highlight = false
+}
+if (!Object.keys(window.userSettings).includes("model_version_highlight")) { // For backwards compatibility
+    window.userSettings.model_version_highlight = 3.0
+}
+if (!Object.keys(window.userSettings).includes("do_pitchrangeoverride")) { // For backwards compatibility
+    window.userSettings.do_pitchrangeoverride = false
+}
+if (!Object.keys(window.userSettings).includes("pitchrangeoverride")) { // For backwards compatibility
+    window.userSettings.pitchrangeoverride = 6.0
+}
+
+if (!Object.keys(window.userSettings).includes("keepPaceOnNew")) { // For backwards compatibility
+    window.userSettings.keepPaceOnNew = true
+}
+if (!Object.keys(window.userSettings).includes("batchOutFolder")) { // For backwards compatibility
+    window.userSettings.batchOutFolder = `${__dirname.replace(/\\/g,"/")}/batch`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+}
+if (!Object.keys(window.userSettings).includes("batch_clearDirFirst")) { // For backwards compatibility
+    window.userSettings.batch_clearDirFirst = false
+}
+// if (!Object.keys(window.userSettings).includes("batch_fastMode")) { // For backwards compatibility
+//     window.userSettings.batch_fastMode = false
+// }
+// if (!Object.keys(window.userSettings).includes("batch_fastModeMaxParallelizations")) { // For backwards compatibility
+//     window.userSettings.batch_fastModeMaxParallelizations = 1000
+// }
+if (!Object.keys(window.userSettings).includes("batch_json")) { // For backwards compatibility
+    window.userSettings.batch_json = false
+}
+if (!Object.keys(window.userSettings).includes("batch_useMP")) { // For backwards compatibility
+    window.userSettings.batch_useMP = false
+}
+if (!Object.keys(window.userSettings).includes("batch_MPCount")) { // For backwards compatibility
+    window.userSettings.batch_MPCount = 0
+}
+if (!Object.keys(window.userSettings).includes("batch_skipExisting")) { // For backwards compatibility
+    window.userSettings.batch_skipExisting = true
+}
+if (!Object.keys(window.userSettings).includes("batch_doGrouping")) { // For backwards compatibility
+    window.userSettings.batch_doGrouping = true
+}
+if (!Object.keys(window.userSettings).includes("batch_doVocoderGrouping")) { // For backwards compatibility
+    window.userSettings.batch_doVocoderGrouping = false
+}
+if (!Object.keys(window.userSettings).includes("batch_delimiter")) { // For backwards compatibility
+    window.userSettings.batch_delimiter = ","
+}
+if (!Object.keys(window.userSettings).includes("batch_paginationSize")) { // For backwards compatibility
+    window.userSettings.batch_paginationSize = 100
+}
+if (!Object.keys(window.userSettings).includes("defaultToHiFi")) { // For backwards compatibility
+    window.userSettings.defaultToHiFi = true
+}
+if (!Object.keys(window.userSettings).includes("batch_batchSize")) { // For backwards compatibility
+    window.userSettings.batch_batchSize = 1
+}
+if (!Object.keys(window.userSettings).includes("autoPlayGen")) { // For backwards compatibility
+    window.userSettings.autoPlayGen = true
+}
+if (!Object.keys(window.userSettings).includes("outputJSON")) { // For backwards compatibility
+    window.userSettings.outputJSON = true
+}
+if (!Object.keys(window.userSettings).includes("keepEditorOnVoiceChange")) { // For backwards compatibility
+    window.userSettings.keepEditorOnVoiceChange = false
+}
+if (!Object.keys(window.userSettings).includes("filenameNumericalSeq")) { // For backwards compatibility
+    window.userSettings.filenameNumericalSeq = false
+}
+if (!Object.keys(window.userSettings).includes("spacePadding")) { // For backwards compatibility
+    window.userSettings.spacePadding = true
+}
+if (!Object.keys(window.userSettings).includes("useErrorSound")) { // For backwards compatibility
+    window.userSettings.useErrorSound = false
+}
+if (!Object.keys(window.userSettings).includes("showTipOfTheDay")) { // For backwards compatibility
+    window.userSettings.showTipOfTheDay = true
+}
+if (!Object.keys(window.userSettings).includes("showUnseenTipOfTheDay")) { // For backwards compatibility
+    window.userSettings.showUnseenTipOfTheDay = false
+}
+if (!Object.keys(window.userSettings).includes("playChangedAudio")) { // For backwards compatibility
+    window.userSettings.playChangedAudio = false
+}
+
+if (!Object.keys(window.userSettings).includes("errorSoundFile")) { // For backwards compatibility
+    window.userSettings.errorSoundFile = `${__dirname.replace(/\\/g,"/")}/lib/xp_error.mp3`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+}
+if (!Object.keys(window.userSettings).includes("plugins")) { // For backwards compatibility
+    window.userSettings.plugins = {}
+}
+if (!Object.keys(window.userSettings.plugins).includes("loadOrder")) { // For backwards compatibility
+    window.userSettings.plugins.loadOrder = ""
+}
+if (!Object.keys(window.userSettings).includes("externalAudioEditor")) { // For backwards compatibility
+    window.userSettings.externalAudioEditor = ""
+}
+if (!Object.keys(window.userSettings).includes("s2s_autogenerate")) { // For backwards compatibility
+    window.userSettings.s2s_autogenerate = true
+}
+if (!Object.keys(window.userSettings).includes("s2s_prePitchShift")) { // For backwards compatibility
+    window.userSettings.s2s_prePitchShift = false
+}
+if (!Object.keys(window.userSettings).includes("s2s_removeNoise")) { // For backwards compatibility
+    window.userSettings.s2s_removeNoise = false
+}
+if (!Object.keys(window.userSettings).includes("s2s_noiseRemStrength")) { // For backwards compatibility
+    window.userSettings.s2s_noiseRemStrength = 0.25
+}
+if (!Object.keys(window.userSettings).includes("vc_strength")) { // For backwards compatibility
+    window.userSettings.vc_strength = 2
+}
+if (!Object.keys(window.userSettings).includes("waveglow_path")) { // For backwards compatibility
+    window.userSettings.waveglow_path = `${__dirname.replace(/\\/g,"/")}/models/waveglow_256channels_universal_v4.pt`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+}
+if (!Object.keys(window.userSettings).includes("bigwaveglow_path")) { // For backwards compatibility
+    window.userSettings.bigwaveglow_path = `${__dirname.replace(/\\/g,"/")}/models/nvidia_waveglowpyt_fp32_20190427.pt`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+}
+if (!Object.keys(window.userSettings).includes("arpabet_paginationSize")) { // For backwards compatibility
+    window.userSettings.arpabet_paginationSize = 200
+}
+if (!Object.keys(window.userSettings).includes("output_files_pagination_size")) { // For backwards compatibility
+    window.userSettings.output_files_pagination_size = 25
+}
+
+const updateUIWithSettings = () => {
+    useGPUCbx.checked = window.userSettings.useGPU
+    autoplay_ckbx.checked = window.userSettings.autoplay
+    // setting_slidersTooltip.checked = window.userSettings.sliderTooltip
+    setting_defaultToHiFi.checked = window.userSettings.defaultToHiFi
+    setting_keepPaceOnNew.checked = window.userSettings.keepPaceOnNew
+    setting_autoplaygenCbx.checked = window.userSettings.autoPlayGen
+    // setting_darkprompt.checked = window.userSettings.darkPrompt
+    setting_show_discord_status.checked = window.userSettings.showDiscordStatus
+    setting_prompt_fontSize.value = window.userSettings.prompt_fontSize
+    setting_bg_gradient_opacity.value = window.userSettings.bg_gradient_opacity
+    setting_areload_voices.checked = window.userSettings.autoReloadVoices
+    setting_output_json.checked = window.userSettings.outputJSON
+    setting_output_num_seq.checked = window.userSettings.filenameNumericalSeq
+    setting_space_padding.checked = window.userSettings.spacePadding
+    setting_keepEditorOnVoiceChange.checked = window.userSettings.keepEditorOnVoiceChange
+    setting_use_error_sound.checked = window.userSettings.useErrorSound
+    setting_error_sound_file.value = window.userSettings.errorSoundFile
+
+    setting_showTipOfTheDay.checked = window.userSettings.showTipOfTheDay
+    totdShowTips.checked = window.userSettings.showTipOfTheDay
+    setting_showUnseenTipOfTheDay.checked = window.userSettings.showUnseenTipOfTheDay
+    totdShowOnlyUnseenTips.checked = window.userSettings.showUnseenTipOfTheDay
+
+    setting_playChangedAudio.checked = window.userSettings.playChangedAudio
+
+    setting_external_audio_editor.value = window.userSettings.externalAudioEditor
+    setting_audio_ffmpeg.checked = window.userSettings.audio.ffmpeg
+    // setting_audio_ffmpeg_preview.checked = window.userSettings.audio.ffmpeg && window.userSettings.audio.ffmpeg_preview
+    setting_audio_useNR.checked = window.userSettings.audio.ffmpeg && window.userSettings.audio.useNR
+    setting_audio_format.value = window.userSettings.audio.format
+    setting_audio_hz.value = window.userSettings.audio.hz
+    setting_audio_pad_start.value = window.userSettings.audio.padStart
+    setting_audio_pad_end.value = window.userSettings.audio.padEnd
+    setting_audio_pitchMult.value = window.userSettings.audio.pitchMult
+    setting_audio_tempo.value = window.userSettings.audio.tempo
+    setting_audio_deessing.value = window.userSettings.audio.deessing
+    setting_audio_nr.value = window.userSettings.audio.nr
+    setting_audio_nf.value = window.userSettings.audio.nf
+    setting_audio_bitdepth.value = window.userSettings.audio.bitdepth
+    setting_audio_amplitude.value = window.userSettings.audio.amplitude
+    setting_editor_audio_amplitude.value = window.userSettings.audio.amplitude
+    setting_show_editor_ffmpegamplitude.checked = window.userSettings.showEditorFFMPEGAmplitude
+    editor_amplitude_options.style.display = window.userSettings.showEditorFFMPEGAmplitude ? "flex" : "none"
+
+    // setting_s2s_autogenerate.checked = window.userSettings.s2s_autogenerate
+    // setting_s2s_prePitchShift.checked = window.userSettings.s2s_prePitchShift
+    // setting_s2s_removeNoise.checked = window.userSettings.s2s_removeNoise
+    // setting_s2s_noiseRemStrength.value = window.userSettings.s2s_noiseRemStrength
+    setting_s2s_vcstrength.value = window.userSettings.vc_strength
+
+    setting_batch_json.checked = window.userSettings.batch_json
+    // setting_batch_fastmode.checked = window.userSettings.batch_fastMode // No more fast modde. TODO, remove completely
+    // setting_batch_maxFastModeParallelizations.value = window.userSettings.batch_fastModeMaxParallelizations // No more fast modde. TODO, remove completely
+    setting_batch_multip.checked = window.userSettings.batch_useMP
+    setting_batch_multip_count.value = window.userSettings.batch_MPCount
+    setting_batch_delimiter.value = window.userSettings.batch_delimiter
+    setting_batch_paginationSize.value = window.userSettings.batch_paginationSize
+    setting_batch_doGrouping.checked = window.userSettings.batch_doGrouping
+    setting_batch_doVocoderGrouping.checked = window.userSettings.batch_doVocoderGrouping
+
+    batch_batchSizeInput.value = parseInt(window.userSettings.batch_batchSize)
+    batch_skipExisting.checked = window.userSettings.batch_skipExisting
+    batch_clearDirFirstCkbx.checked = window.userSettings.batch_clearDirFirst
+
+    setting_256waveglow_path.value = window.userSettings.waveglow_path
+    setting_bigwaveglow_path.value = window.userSettings.bigwaveglow_path
+
+    setting_arpabet_paginationSize.value = window.userSettings.arpabet_paginationSize
+    setting_output_files_pagination_size.value = window.userSettings.output_files_pagination_size
+    setting_max_filename_chars.value = window.userSettings.max_filename_chars
+    setting_clear_text_after_synth.checked = window.userSettings.clear_text_after_synth
+    setting_do_model_version_highlight.checked = window.userSettings.do_model_version_highlight
+    setting_model_version_highlight.value = window.userSettings.model_version_highlight
+    setting_pitchrangeoverrideEnabledCkbx.checked = window.userSettings.do_pitchrangeoverride
+    setting_pitchrangeoverride.value = window.userSettings.pitchrangeoverride
+
+    const [height, width] = window.userSettings.customWindowSize.split(",").map(v => parseInt(v))
+    ipcRenderer.send("resize", {height, width})
+}
+updateUIWithSettings()
+saveUserSettings()
+
+
+// Add the SVG code this way, because otherwise the index.html file will be spammed with way too much svg code
+Array.from(window.document.querySelectorAll(".svgButton")).forEach(svgButton => {
+    svgButton.innerHTML = `<svg class="openFolderSVG" width="400" height="350" viewBox="0, 0, 400,350"><g id="svgg" ><path id="path0"  d="M39.960 53.003 C 36.442 53.516,35.992 53.635,30.800 55.422 C 15.784 60.591,3.913 74.835,0.636 91.617 C -0.372 96.776,-0.146 305.978,0.872 310.000 C 5.229 327.228,16.605 339.940,32.351 345.172 C 40.175 347.773,32.175 347.630,163.000 347.498 L 281.800 347.378 285.600 346.495 C 304.672 342.065,321.061 332.312,330.218 319.944 C 330.648 319.362,332.162 317.472,333.581 315.744 C 335.001 314.015,336.299 312.420,336.467 312.200 C 336.634 311.980,337.543 310.879,338.486 309.753 C 340.489 307.360,342.127 305.341,343.800 303.201 C 344.460 302.356,346.890 299.375,349.200 296.575 C 351.510 293.776,353.940 290.806,354.600 289.975 C 355.260 289.144,356.561 287.505,357.492 286.332 C 358.422 285.160,359.952 283.267,360.892 282.126 C 362.517 280.153,371.130 269.561,375.632 264.000 C 376.789 262.570,380.427 258.097,383.715 254.059 C 393.790 241.689,396.099 237.993,398.474 230.445 C 403.970 212.972,394.149 194.684,376.212 188.991 C 369.142 186.747,368.803 186.724,344.733 186.779 C 330.095 186.812,322.380 186.691,322.216 186.425 C 322.078 186.203,321.971 178.951,321.977 170.310 C 321.995 146.255,321.401 141.613,317.200 133.000 C 314.009 126.457,307.690 118.680,303.142 115.694 C 302.560 115.313,301.300 114.438,300.342 113.752 C 295.986 110.631,288.986 107.881,282.402 106.704 C 280.540 106.371,262.906 106.176,220.400 106.019 L 161.000 105.800 160.763 98.800 C 159.961 75.055,143.463 56.235,120.600 52.984 C 115.148 52.208,45.292 52.225,39.960 53.003 M120.348 80.330 C 130.472 83.988,133.993 90.369,133.998 105.071 C 134.003 120.968,137.334 127.726,147.110 131.675 L 149.400 132.600 213.800 132.807 C 272.726 132.996,278.392 133.071,280.453 133.690 C 286.872 135.615,292.306 141.010,294.261 147.400 C 294.928 149.578,294.996 151.483,294.998 168.000 L 295.000 186.200 292.800 186.449 C 291.590 186.585,254.330 186.725,210.000 186.759 C 163.866 186.795,128.374 186.977,127.000 187.186 C 115.800 188.887,104.936 192.929,96.705 198.458 C 95.442 199.306,94.302 200.000,94.171 200.000 C 93.815 200.000,89.287 203.526,87.000 205.583 C 84.269 208.039,80.083 212.649,76.488 217.159 C 72.902 221.657,72.598 222.031,70.800 224.169 C 70.030 225.084,68.770 226.620,68.000 227.582 C 67.230 228.544,66.054 229.977,65.387 230.766 C 64.720 231.554,62.727 234.000,60.957 236.200 C 59.188 238.400,56.346 241.910,54.642 244.000 C 52.938 246.090,50.163 249.510,48.476 251.600 C 44.000 257.146,36.689 266.126,36.212 266.665 C 35.985 266.921,34.900 268.252,33.800 269.623 C 32.700 270.994,30.947 273.125,29.904 274.358 C 28.861 275.591,28.006 276.735,28.004 276.900 C 28.002 277.065,27.728 277.200,27.395 277.200 C 26.428 277.200,26.700 96.271,27.670 93.553 C 30.020 86.972,35.122 81.823,40.800 80.300 C 44.238 79.378,47.793 79.296,81.800 79.351 L 117.800 79.410 120.348 80.330 M369.400 214.800 C 374.239 217.220,374.273 222.468,369.489 228.785 C 367.767 231.059,364.761 234.844,364.394 235.200 C 364.281 235.310,362.373 237.650,360.154 240.400 C 357.936 243.150,354.248 247.707,351.960 250.526 C 347.732 255.736,346.053 257.821,343.202 261.400 C 341.505 263.530,340.849 264.336,334.600 271.965 C 332.400 274.651,330.204 277.390,329.720 278.053 C 329.236 278.716,328.246 279.945,327.520 280.785 C 326.794 281.624,325.300 283.429,324.200 284.794 C 323.100 286.160,321.726 287.845,321.147 288.538 C 320.568 289.232,318.858 291.345,317.347 293.233 C 308.372 304.449,306.512 306.609,303.703 309.081 C 299.300 312.956,290.855 317.633,286.000 318.886 C 277.958 320.960,287.753 320.819,159.845 320.699 C 33.557 320.581,42.330 320.726,38.536 318.694 C 34.021 316.276,35.345 310.414,42.386 301.647 C 44.044 299.583,45.940 297.210,46.600 296.374 C 47.260 295.538,48.340 294.169,49.000 293.332 C 49.660 292.495,51.550 290.171,53.200 288.167 C 54.850 286.164,57.100 283.395,58.200 282.015 C 59.300 280.635,60.920 278.632,61.800 277.564 C 62.680 276.496,64.210 274.617,65.200 273.389 C 66.190 272.162,67.188 270.942,67.418 270.678 C 67.649 270.415,71.591 265.520,76.179 259.800 C 80.767 254.080,84.634 249.310,84.773 249.200 C 84.913 249.090,87.117 246.390,89.673 243.200 C 92.228 240.010,95.621 235.780,97.213 233.800 C 106.328 222.459,116.884 215.713,128.200 213.998 C 129.300 213.832,183.570 213.719,248.800 213.748 L 367.400 213.800 369.400 214.800 " stroke="none" fill="#fbfbfb" fill-rule="evenodd"></path><path id="path1" fill-opacity="0" d="M0.000 46.800 C 0.000 72.540,0.072 93.600,0.159 93.600 C 0.246 93.600,0.516 92.460,0.759 91.066 C 3.484 75.417,16.060 60.496,30.800 55.422 C 35.953 53.648,36.338 53.550,40.317 52.981 C 46.066 52.159,114.817 52.161,120.600 52.984 C 143.463 56.235,159.961 75.055,160.763 98.800 L 161.000 105.800 220.400 106.019 C 262.906 106.176,280.540 106.371,282.402 106.704 C 288.986 107.881,295.986 110.631,300.342 113.752 C 301.300 114.438,302.560 115.313,303.142 115.694 C 307.690 118.680,314.009 126.457,317.200 133.000 C 321.401 141.613,321.995 146.255,321.977 170.310 C 321.971 178.951,322.078 186.203,322.216 186.425 C 322.380 186.691,330.095 186.812,344.733 186.779 C 368.803 186.724,369.142 186.747,376.212 188.991 C 381.954 190.814,388.211 194.832,391.662 198.914 C 395.916 203.945,397.373 206.765,399.354 213.800 C 399.842 215.533,399.922 201.399,399.958 107.900 L 400.000 0.000 200.000 0.000 L 0.000 0.000 0.000 46.800 M44.000 79.609 C 35.903 81.030,30.492 85.651,27.670 93.553 C 26.700 96.271,26.428 277.200,27.395 277.200 C 27.728 277.200,28.002 277.065,28.004 276.900 C 28.006 276.735,28.861 275.591,29.904 274.358 C 30.947 273.125,32.700 270.994,33.800 269.623 C 34.900 268.252,35.985 266.921,36.212 266.665 C 36.689 266.126,44.000 257.146,48.476 251.600 C 50.163 249.510,52.938 246.090,54.642 244.000 C 56.346 241.910,59.188 238.400,60.957 236.200 C 62.727 234.000,64.720 231.554,65.387 230.766 C 66.054 229.977,67.230 228.544,68.000 227.582 C 68.770 226.620,70.030 225.084,70.800 224.169 C 72.598 222.031,72.902 221.657,76.488 217.159 C 80.083 212.649,84.269 208.039,87.000 205.583 C 89.287 203.526,93.815 200.000,94.171 200.000 C 94.302 200.000,95.442 199.306,96.705 198.458 C 104.936 192.929,115.800 188.887,127.000 187.186 C 128.374 186.977,163.866 186.795,210.000 186.759 C 254.330 186.725,291.590 186.585,292.800 186.449 L 295.000 186.200 294.998 168.000 C 294.996 151.483,294.928 149.578,294.261 147.400 C 292.306 141.010,286.872 135.615,280.453 133.690 C 278.392 133.071,272.726 132.996,213.800 132.807 L 149.400 132.600 147.110 131.675 C 137.334 127.726,134.003 120.968,133.998 105.071 C 133.993 90.369,130.472 83.988,120.348 80.330 L 117.800 79.410 81.800 79.351 C 62.000 79.319,44.990 79.435,44.000 79.609 M128.200 213.998 C 116.884 215.713,106.328 222.459,97.213 233.800 C 95.621 235.780,92.228 240.010,89.673 243.200 C 87.117 246.390,84.913 249.090,84.773 249.200 C 84.634 249.310,80.767 254.080,76.179 259.800 C 71.591 265.520,67.649 270.415,67.418 270.678 C 67.188 270.942,66.190 272.162,65.200 273.389 C 64.210 274.617,62.680 276.496,61.800 277.564 C 60.920 278.632,59.300 280.635,58.200 282.015 C 57.100 283.395,54.850 286.164,53.200 288.167 C 51.550 290.171,49.660 292.495,49.000 293.332 C 48.340 294.169,47.260 295.538,46.600 296.374 C 45.940 297.210,44.044 299.583,42.386 301.647 C 35.345 310.414,34.021 316.276,38.536 318.694 C 42.330 320.726,33.557 320.581,159.845 320.699 C 287.753 320.819,277.958 320.960,286.000 318.886 C 290.855 317.633,299.300 312.956,303.703 309.081 C 306.512 306.609,308.372 304.449,317.347 293.233 C 318.858 291.345,320.568 289.232,321.147 288.538 C 321.726 287.845,323.100 286.160,324.200 284.794 C 325.300 283.429,326.794 281.624,327.520 280.785 C 328.246 279.945,329.236 278.716,329.720 278.053 C 330.204 277.390,332.400 274.651,334.600 271.965 C 340.849 264.336,341.505 263.530,343.202 261.400 C 346.053 257.821,347.732 255.736,351.960 250.526 C 354.248 247.707,357.936 243.150,360.154 240.400 C 362.373 237.650,364.281 235.310,364.394 235.200 C 364.761 234.844,367.767 231.059,369.489 228.785 C 374.273 222.468,374.239 217.220,369.400 214.800 L 367.400 213.800 248.800 213.748 C 183.570 213.719,129.300 213.832,128.200 213.998 M399.600 225.751 C 399.600 231.796,394.623 240.665,383.715 254.059 C 380.427 258.097,376.789 262.570,375.632 264.000 C 371.130 269.561,362.517 280.153,360.892 282.126 C 359.952 283.267,358.422 285.160,357.492 286.332 C 356.561 287.505,355.260 289.144,354.600 289.975 C 353.940 290.806,351.510 293.776,349.200 296.575 C 346.890 299.375,344.460 302.356,343.800 303.201 C 342.127 305.341,340.489 307.360,338.486 309.753 C 337.543 310.879,336.634 311.980,336.467 312.200 C 336.299 312.420,335.001 314.015,333.581 315.744 C 332.162 317.472,330.648 319.362,330.218 319.944 C 321.061 332.312,304.672 342.065,285.600 346.495 L 281.800 347.378 163.000 347.498 C 32.175 347.630,40.175 347.773,32.351 345.172 C 16.471 339.895,3.810 325.502,0.820 309.326 C 0.591 308.085,0.312 306.979,0.202 306.868 C 0.091 306.757,-0.000 327.667,-0.000 353.333 L 0.000 400.000 200.000 400.000 L 400.000 400.000 400.000 312.400 C 400.000 264.220,399.910 224.800,399.800 224.800 C 399.690 224.800,399.600 225.228,399.600 225.751 " stroke="none" fill="#050505" fill-rule="evenodd"></path></g></svg>`
+})
+
+
+// Installation sever handling
+// =========================
+settings_installation.innerHTML = window.userSettings.installation=="cpu" ? `CPU` : "CPU+GPU"
+setting_change_installation.innerHTML = window.userSettings.installation=="cpu" ? `Change to CPU+GPU` : `Change to CPU`
+
+
+setting_change_installation.addEventListener("click", () => {
+    spinnerModal("Changing installation sever...")
+    doFetch(`http://localhost:8008/stopServer`, {
+        method: "Post",
+        body: JSON.stringify({})
+    }).then(r=>r.text()).then(console.log) // The server stopping should mean this never runs
+    .catch(() => {
+
+        if (window.userSettings.installation=="cpu") {
+            window.userSettings.installation = "gpu"
+            useGPUCbx.disabled = false
+            settings_installation.innerHTML = `GPU`
+            setting_change_installation.innerHTML = `Change to CPU`
+        } else {
+            doFetch(`http://localhost:8008/setDevice`, {
+                method: "Post",
+                body: JSON.stringify({device: "cpu"})
+            })
+
+            window.userSettings.installation = "cpu"
+            useGPUCbx.checked = false
+            useGPUCbx.disabled = true
+            window.userSettings.useGPU = false
+            settings_installation.innerHTML = `CPU`
+            setting_change_installation.innerHTML = `Change to CPU+GPU`
+        }
+        saveUserSettings()
+
+        // Start the new server
+        if (window.PRODUCTION) {
+            window.appLogger.log(window.userSettings.installation)
+            window.pythonProcess = spawn(`${path}/cpython_${window.userSettings.installation}/server.exe`, {stdio: "ignore"})
+        } else {
+            window.pythonProcess = spawn("python", [`${path}/server.py`], {stdio: "ignore"})
+        }
+
+        window.currentModel = undefined
+        titleName.innerHTML = window.i18n.SELECT_VOICE_TYPE
+        keepSampleButton.style.display = "none"
+        wavesurferContainer.innerHTML = ""
+        generateVoiceButton.dataset.modelQuery = "null"
+        generateVoiceButton.dataset.modelIDLoaded = undefined
+        generateVoiceButton.innerHTML = window.i18n.LOAD_MODEL
+        generateVoiceButton.disabled = true
+        window.serverIsUp = false
+        window.doWeirdServerStartupCheck(`${window.i18n.LOADING}...<br>${window.i18n.MAY_TAKE_A_MINUTE}<br><br>${window.i18n.STARTING_PYTHON}...`)
+    })
+})
+
+// =========================
+
+
+
+
+// Audio hardware
+// ==============
+navigator.mediaDevices.enumerateDevices().then(devices => {
+    devices = devices.filter(device => device.kind=="audiooutput" && device.deviceId!="communications")
+
+    // Base device
+    devices.forEach(device => {
+        const option = createElem("option", device.label)
+        option.value = device.deviceId
+        setting_base_speaker.appendChild(option)
+    })
+    setting_base_speaker.addEventListener("change", () => {
+        window.userSettings.base_speaker = setting_base_speaker.value
+        window.saveUserSettings()
+
+        window.document.querySelectorAll("audio").forEach(audioElem => {
+            audioElem.setSinkId(window.userSettings.base_speaker)
+        })
+    })
+    if (Object.keys(window.userSettings).includes("base_speaker")) {
+        setting_base_speaker.value = window.userSettings.base_speaker
+    } else {
+        window.userSettings.base_speaker = setting_base_speaker.value
+        window.saveUserSettings()
+    }
+
+    // Alternate device
+    devices.forEach(device => {
+        const option = createElem("option", device.label)
+        option.value = device.deviceId
+        setting_alt_speaker.appendChild(option)
+    })
+    setting_alt_speaker.addEventListener("change", () => {
+        window.userSettings.alt_speaker = setting_alt_speaker.value
+        window.saveUserSettings()
+    })
+    if (Object.keys(window.userSettings).includes("alt_speaker")) {
+        setting_alt_speaker.value = window.userSettings.alt_speaker
+    } else {
+        window.userSettings.alt_speaker = setting_alt_speaker.value
+        window.saveUserSettings()
+    }
+})
+
+
+
+// Settings Menu
+// =============
+useGPUCbx.addEventListener("change", () => {
+    spinnerModal(window.i18n.CHANGING_DEVICE)
+    doFetch(`http://localhost:8008/setDevice`, {
+        method: "Post",
+        body: JSON.stringify({device: useGPUCbx.checked ? "gpu" : "cpu"})
+    }).then(r=>r.text()).then(res => {
+        window.closeModal(undefined, settingsContainer)
+        window.userSettings.useGPU = useGPUCbx.checked
+        saveUserSettings()
+    }).catch(e => {
+        console.log(e)
+        if (e.code =="ENOENT") {
+            window.closeModal(undefined, settingsContainer).then(() => {
+                window.errorModal(window.i18n.THERE_WAS_A_PROBLEM)
+            })
+        }
+    })
+})
+
+
+const initMenuSetting = (elem, setting, type, callback=undefined, valFn=undefined) => {
+
+    valFn = valFn ? valFn : x=>x
+
+    if (type=="checkbox") {
+        elem.addEventListener("click", () => {
+            if (setting.includes(".")) {
+                window.userSettings[setting.split(".")[0]][setting.split(".")[1]] = valFn(elem.checked)
+            } else {
+                window.userSettings[setting] = valFn(elem.checked)
+            }
+            saveUserSettings()
+            if (callback) callback()
+        })
+    } else {
+        elem.addEventListener("change", () => {
+            if (setting.includes(".")) {
+                window.userSettings[setting.split(".")[0]][setting.split(".")[1]] = valFn(elem.value)
+            } else {
+                window.userSettings[setting] = valFn(elem.value)
+            }
+            saveUserSettings()
+            if (callback) callback()
+        })
+    }
+}
+window.initFilePickerButton = (button, input, setting, properties, filters=undefined, defaultPath=undefined, callback=undefined) => {
+    button.addEventListener("click", () => {
+        const defaultPath = input.value.replace(/\//g, "\\")
+        er.dialog.showOpenDialog({ properties, filters, defaultPath}).then(filePath => {
+            if (filePath) {
+                filePath = filePath.filePaths[0].replace(/\\/g, "/")
+                input.value = filePath.replace(/\\/g, "/")
+                setting = typeof(setting)=="function" ? setting() : setting
+                window.userSettings[setting] = filePath
+                saveUserSettings()
+                if (callback) {
+                    callback()
+                }
+            }
+        })
+    })
+}
+
+const setPromptTheme = () => {
+    // if (window.userSettings.darkPrompt) {
+    //     dialogueInput.style.backgroundColor = "rgba(25,25,25,0.9)"
+    //     dialogueInput.style.color = "white"
+    // } else {
+    //     dialogueInput.style.backgroundColor = "rgba(255,255,255,0.9)"
+    //     dialogueInput.style.color = "black"
+    // }
+}
+const updateDiscord = () => {
+    let gameName = undefined
+    if (window.userSettings.showDiscordStatus && window.currentGame) {
+        gameName = window.currentGame.gameName
+    }
+    ipcRenderer.send('updateDiscord', {details: gameName})
+}
+const setPromptFontSize = () => {
+    dialogueInput.style.fontSize = `${window.userSettings.prompt_fontSize}pt`
+}
+const updateBackground = () => {
+    const background = `linear-gradient(0deg, rgba(128,128,128,${window.userSettings.bg_gradient_opacity}) 0px, rgba(0,0,0,0)), url("assets/${window.currentGame.assetFile}")`
+    // Fade the background image transition
+    rightBG1.style.background = background
+    rightBG2.style.opacity = 0
+    setTimeout(() => {
+        rightBG2.style.background = rightBG1.style.background
+        rightBG2.style.opacity = 1
+    }, 1000)
+}
+
+initMenuSetting(setting_autoplaygenCbx, "autoPlayGen", "checkbox")
+// initMenuSetting(setting_slidersTooltip, "sliderTooltip", "checkbox")
+initMenuSetting(setting_defaultToHiFi, "defaultToHiFi", "checkbox")
+initMenuSetting(setting_keepPaceOnNew, "keepPaceOnNew", "checkbox")
+initMenuSetting(setting_areload_voices, "autoReloadVoices", "checkbox")
+initMenuSetting(setting_output_json, "outputJSON", "checkbox")
+initMenuSetting(setting_keepEditorOnVoiceChange, "keepEditorOnVoiceChange", "checkbox")
+initMenuSetting(setting_output_num_seq, "filenameNumericalSeq", "checkbox")
+initMenuSetting(setting_space_padding, "spacePadding", "checkbox")
+// initMenuSetting(setting_darkprompt, "darkPrompt", "checkbox", setPromptTheme)
+initMenuSetting(setting_show_discord_status, "showDiscordStatus", "checkbox", updateDiscord)
+initMenuSetting(setting_prompt_fontSize, "prompt_fontSize", "number", setPromptFontSize)
+initMenuSetting(setting_bg_gradient_opacity, "bg_gradient_opacity", "number", updateBackground)
+initMenuSetting(setting_use_error_sound, "useErrorSound", "checkbox")
+initMenuSetting(setting_error_sound_file, "errorSoundFile", "text")
+initFilePickerButton(setting_errorSoundFileBtn, setting_error_sound_file, "errorSoundFile", ["openFile"], [{name: "Audio", extensions: ["wav", "mp3", "ogg"]}])
+
+initMenuSetting(setting_showTipOfTheDay, "showTipOfTheDay", "checkbox", () => {
+    totdShowTips.checked = setting_showTipOfTheDay.checked
+})
+initMenuSetting(totdShowTips, "showTipOfTheDay", "checkbox", () => {
+    setting_showTipOfTheDay.checked = totdShowTips.checked
+})
+initMenuSetting(setting_showUnseenTipOfTheDay, "showUnseenTipOfTheDay", "checkbox", () => {
+    totdShowOnlyUnseenTips.checked = setting_showUnseenTipOfTheDay.checked
+})
+initMenuSetting(totdShowOnlyUnseenTips, "showUnseenTipOfTheDay", "checkbox", () => {
+    setting_showUnseenTipOfTheDay.checked = totdShowOnlyUnseenTips.checked
+})
+
+initMenuSetting(setting_playChangedAudio, "playChangedAudio", "checkbox")
+
+
+initMenuSetting(setting_external_audio_editor, "externalAudioEditor", "text")
+initFilePickerButton(setting_externalEditorButton, setting_external_audio_editor, "externalAudioEditor", ["openFile"])
+
+initMenuSetting(setting_audio_ffmpeg, "audio.ffmpeg", "checkbox", () => {
+    // setting_audio_ffmpeg_preview.checked = window.userSettings.audio.ffmpeg && window.userSettings.audio.ffmpeg_preview
+    // setting_audio_ffmpeg_preview.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_useNR.checked = window.userSettings.audio.ffmpeg && window.userSettings.audio.useNR
+    setting_audio_useNR.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_format.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_hz.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_pad_start.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_pad_end.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_pitchMult.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_tempo.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_deessing.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_nr.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_nf.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_bitdepth.disabled = !window.userSettings.audio.ffmpeg
+    setting_audio_amplitude.disabled = !window.userSettings.audio.ffmpeg
+    setting_editor_audio_amplitude.disabled = !window.userSettings.audio.ffmpeg
+})
+// initMenuSetting(setting_audio_ffmpeg_preview, "audio.ffmpeg_preview", "checkbox")
+initMenuSetting(setting_audio_useNR, "audio.useNR", "checkbox")
+initMenuSetting(setting_audio_format, "audio.format", "text")
+initMenuSetting(setting_audio_hz, "audio.hz", "text", undefined, parseInt)
+initMenuSetting(setting_audio_pad_start, "audio.padStart", "text", undefined, parseInt)
+initMenuSetting(setting_audio_pad_end, "audio.padEnd", "text", undefined, parseInt)
+initMenuSetting(setting_audio_pitchMult, "audio.pitchMult", "number", undefined, parseFloat)
+initMenuSetting(setting_audio_tempo, "audio.tempo", "number", undefined, parseFloat)
+initMenuSetting(setting_audio_deessing, "audio.deessing", "number", undefined, parseFloat)
+initMenuSetting(setting_audio_nr, "audio.nr", "number", undefined, parseFloat)
+initMenuSetting(setting_audio_nf, "audio.nf", "number", undefined, parseFloat)
+initMenuSetting(setting_audio_bitdepth, "audio.bitdepth", "select")
+initMenuSetting(setting_audio_amplitude, "audio.amplitude", "number", () => {
+    setting_editor_audio_amplitude.value = setting_audio_amplitude.value
+}, parseFloat)
+initMenuSetting(setting_editor_audio_amplitude, "audio.amplitude", "number", () => {
+    setting_audio_amplitude.value = setting_editor_audio_amplitude.value
+}, parseFloat)
+initMenuSetting(setting_show_editor_ffmpegamplitude, "showEditorFFMPEGAmplitude", "checkbox", () => {
+    editor_amplitude_options.style.display = window.userSettings.showEditorFFMPEGAmplitude ? "flex" : "none"
+})
+
+initMenuSetting(setting_batch_json, "batch_json", "checkbox")
+// initMenuSetting(setting_batch_fastmode, "batch_fastMode", "checkbox") // No more fast modde. TODO, remove completely
+// initMenuSetting(setting_batch_maxFastModeParallelizations, "batch_fastModeMaxParallelizations", "number") // No more fast modde. TODO, remove completely
+initMenuSetting(setting_batch_multip, "batch_useMP", "checkbox")
+initMenuSetting(setting_batch_multip_count, "batch_MPCount", "number", undefined, parseInt)
+initMenuSetting(setting_batch_doGrouping, "batch_doGrouping", "checkbox")
+initMenuSetting(setting_batch_doVocoderGrouping, "batch_doVocoderGrouping", "checkbox")
+initMenuSetting(batch_clearDirFirstCkbx, "batch_clearDirFirst", "checkbox")
+initMenuSetting(batch_skipExisting, "batch_skipExisting", "checkbox")
+initMenuSetting(batch_batchSizeInput, "batch_batchSize", "text", undefined, parseInt)
+initMenuSetting(setting_batch_delimiter, "batch_delimiter")
+initMenuSetting(setting_batch_paginationSize, "batch_paginationSize", "number", undefined, parseInt)
+
+// initMenuSetting(setting_s2s_autogenerate, "s2s_autogenerate", "checkbox")
+// initMenuSetting(setting_s2s_prePitchShift, "s2s_prePitchShift", "checkbox")
+// initMenuSetting(setting_s2s_removeNoise, "s2s_removeNoise", "checkbox")
+// initMenuSetting(setting_s2s_noiseRemStrength, "s2s_noiseRemStrength", "number", undefined, parseFloat)
+initMenuSetting(setting_s2s_vcstrength, "vc_strength", "number", undefined, parseFloat)
+
+initMenuSetting(setting_256waveglow_path, "waveglow_path", "text")
+initFilePickerButton(setting_waveglowPathButton, setting_256waveglow_path, "waveglow_path", ["openFile"], [{name: "Pytorch checkpoint", extensions: ["pt"]}])
+initMenuSetting(setting_bigwaveglow_path, "bigwaveglow_path", "text")
+initFilePickerButton(setting_bigwaveglowPathButton, setting_bigwaveglow_path, "bigwaveglow_path", ["openFile"], [{name: "Pytorch checkpoint", extensions: ["pt"]}])
+
+initFilePickerButton(setting_modelsPathButton, setting_models_path_input, ()=>`modelspath_${window.currentGame.gameId}`, ["openDirectory"], undefined, undefined, ()=>window.updateGameList())
+initFilePickerButton(setting_outPathButton, setting_out_path_input, ()=>`outpath_${window.currentGame.gameId}`, ["openDirectory"], undefined, undefined, ()=>{
+    if (window.currentModelButton) {
+        window.currentModelButton.click()
+    }
+})
+initMenuSetting(setting_arpabet_paginationSize, "arpabet_paginationSize", "number", undefined, parseInt)
+initMenuSetting(setting_output_files_pagination_size, "output_files_pagination_size", "number", () => {
+    window.resetPagination()
+    window.refreshRecordsList()
+}, parseInt)
+initMenuSetting(setting_max_filename_chars, "max_filename_chars", "number", undefined, parseInt)
+initMenuSetting(setting_clear_text_after_synth, "clear_text_after_synth", "checkbox")
+initMenuSetting(setting_do_model_version_highlight, "do_model_version_highlight", "checkbox", ()=>window.changeGame(window.currentGame))
+initMenuSetting(setting_model_version_highlight, "model_version_highlight", "number", ()=>window.changeGame(window.currentGame), parseFloat)
+const updateSequenceEditorRange = () => {
+    if (window.sequenceEditor.isCreated && window.currentModel) {
+        const pitchRange = window.userSettings.pitchrangeoverride ? window.userSettings.pitchrangeoverride : window.sequenceEditor.pitchSliderRange
+
+        // Make sure to cap the existing values if upding the range to be smaller than the current values
+        if (window.userSettings.pitchrangeoverride) {
+            window.sequenceEditor.pitchNew.forEach((val,vi) => {
+                if (Math.abs(val)>window.userSettings.pitchrangeoverride) {
+                   val = Math.max(-window.userSettings.pitchrangeoverride, Math.min(window.userSettings.pitchrangeoverride, val))
+                   window.sequenceEditor.pitchNew[vi] = val
+                }
+            })
+        }
+
+        window.sequenceEditor.update(window.currentModel.modelType, pitchRange)
+    }
+}
+initMenuSetting(setting_pitchrangeoverrideEnabledCkbx, "do_pitchrangeoverride", "checkbox", updateSequenceEditorRange)
+initMenuSetting(setting_pitchrangeoverride, "pitchrangeoverride", "number", updateSequenceEditorRange, parseFloat)
+
+
+setPromptTheme()
+setPromptFontSize()
+
+setting_audio_format.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_hz.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_pad_start.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_pad_end.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_pitchMult.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_tempo.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_deessing.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_nr.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_nf.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_bitdepth.disabled = !window.userSettings.audio.ffmpeg
+setting_audio_amplitude.disabled = !window.userSettings.audio.ffmpeg
+setting_editor_audio_amplitude.disabled = !window.userSettings.audio.ffmpeg
+
+
+openDiscord.addEventListener("click", () => {
+    shell.openExternal("https://discord.gg/nv7c6E2TzV")
+})
+
+
+setting_models_path_input.addEventListener("change", () => {
+    const gameFolder = window.currentGame.gameId
+
+    setting_models_path_input.value = setting_models_path_input.value.replace(/\/\//g, "/").replace(/\\/g,"/")
+    window.userSettings[`modelspath_${gameFolder}`] = setting_models_path_input.value
+    window.saveUserSettings()
+    window.loadAllModels().then(() => {
+        window.changeGame(window.currentGame)
+    })
+
+    if (!window.watchedModelsDirs.includes(setting_models_path_input.value)) {
+        window.watchedModelsDirs.push(setting_models_path_input.value)
+        fs.watch(setting_models_path_input.value, {recursive: false, persistent: true}, (eventType, filename) => {
+            window.changeGame(window.currentGame)
+        })
+    }
+    window.updateGameList()
+
+    // Gather the model paths to send to the server
+    const modelsPaths = {}
+    Object.keys(window.userSettings).filter(key => key.includes("modelspath_")).forEach(key => {
+        modelsPaths[key.split("_")[1]] = window.userSettings[key]
+    })
+    doFetch(`http://localhost:8008/setAvailableVoices`, {
+        method: "Post",
+        body: JSON.stringify({
+            modelsPaths: JSON.stringify(modelsPaths)
+        })
+    })
+})
+
+
+// Output path
+fs.readdir(`${window.path}/models`, (err, gameDirs) => {
+    gameDirs.filter(name => !name.includes(".")).forEach(gameFolder => {
+        // Initialize the default output directory setting for this game
+        if (!Object.keys(window.userSettings).includes(`outpath_${gameFolder}`)) {
+            window.userSettings[`outpath_${gameFolder}`] = `${__dirname.replace(/\\/g,"/")}/output/${gameFolder}`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+            window.saveUserSettings()
+        }
+    })
+})
+setting_out_path_input.addEventListener("change", () => {
+    const gameFolder = window.currentGame.gameId
+
+    setting_out_path_input.value = setting_out_path_input.value.replace(/\/\//g, "/").replace(/\\/g,"/")
+    window.userSettings[`outpath_${gameFolder}`] = setting_out_path_input.value
+    saveUserSettings()
+    if (window.currentModelButton) {
+        window.currentModelButton.click()
+    }
+})
+// Models path
+const assetFiles = fs.readdirSync(`${window.path}/assets`)
+
+assetFiles.filter(fn=>fn.endsWith(".json")).forEach(assetFileName => {
+    const gameId = assetFileName.split(".json")[0]
+
+    // Initialize the default models directory setting for this game
+    if (!Object.keys(window.userSettings).includes(`modelspath_${gameId}`)) {
+        window.userSettings[`modelspath_${gameId}`] = `${__dirname.replace(/\\/g,"/")}/models/${gameId}`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+        window.userSettings[`outpath_${gameId}`] = `${__dirname.replace(/\\/g,"/")}/output/${gameId}`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+        saveUserSettings()
+    }
+})
+
+
+// Batch stuff
+// Output folder
+batch_outputFolderInput.addEventListener("change", () => {
+    if (batch_outputFolderInput.value.length==0) {
+        window.errorModal(window.i18n.ENTER_DIR_PATH)
+        batch_outputFolderInput.value = window.userSettings.batchOutFolder
+    } else {
+        window.userSettings.batchOutFolder = batch_outputFolderInput.value
+        saveUserSettings()
+    }
+})
+batch_outputFolderInput.value = window.userSettings.batchOutFolder
+// ======
+
+
+
+reset_settings_btn.addEventListener("click", () => {
+    window.confirmModal(window.i18n.SURE_RESET_SETTINGS).then(confirmation => {
+        if (confirmation) {
+            window.userSettings.audio.format = "wav"
+            window.userSettings.audio.hz = 44100
+            window.userSettings.audio.padStart = 0
+            window.userSettings.audio.padEnd = 0
+            window.userSettings.audio.pitchMult = 1
+            window.userSettings.audio.tempo = 1
+            window.userSettings.audio.deessing = 0.1
+            window.userSettings.audio.nr = 5
+            window.userSettings.audio.nf = -20
+            window.userSettings.audio.ffmpeg = true
+            // window.userSettings.audio.ffmpeg_preview = true
+            window.userSettings.audio.useNR = true
+            window.userSettings.audio.amplitude = 1
+            window.userSettings.autoPlayGen = true
+            window.userSettings.autoReloadVoices = false
+            window.userSettings.autoplay = true
+            // window.userSettings.darkPrompt = false
+            window.userSettings.showDiscordStatus = true
+            window.userSettings.prompt_fontSize = 15
+            window.userSettings.bg_gradient_opacity = 13
+            window.userSettings.outputJSON = true
+            window.userSettings.keepEditorOnVoiceChange = false
+            window.userSettings.filenameNumericalSeq = false
+            window.userSettings.spacePadding = true
+            window.userSettings.useErrorSound = false
+            window.userSettings.showTipOfTheDay = true
+            window.userSettings.showUnseenTipOfTheDay = false
+            window.userSettings.playChangedAudio = false
+
+
+            window.userSettings.plugins = {}
+            window.userSettings.plugins.loadOrder = ""
+            window.userSettings.externalAudioEditor = ""
+            window.userSettings.s2s_autogenerate = true // TODO, remove
+            window.userSettings.s2s_prePitchShift = false // TODO, remove
+            window.userSettings.s2s_removeNoise = false // TODO, remove
+            window.userSettings.s2s_noiseRemStrength = 0.25 // TODO, remove
+            window.userSettings.vc_strength = 2
+
+            window.userSettings.defaultToHiFi = true
+            window.userSettings.keepPaceOnNew = true
+            window.userSettings.sliderTooltip = true
+            window.userSettings.audio.bitdepth = "pcm_s32le"
+            window.userSettings.showEditorFFMPEGAmplitude = false
+            window.userSettings.vocoder = "256_waveglow"
+            window.userSettings.max_filename_chars = 70
+            window.userSettings.clear_text_after_synth = false
+            window.userSettings.do_model_version_highlight = false
+            window.userSettings.model_version_highlight = 3.0
+            window.userSettings.do_pitchrangeoverride = false
+            window.userSettings.pitchrangeoverride = 6.0
+            window.userSettings.keepPaceOnNew = true
+            window.userSettings.arpabet_paginationSize = 200
+            window.userSettings.output_files_pagination_size = 25
+
+            window.userSettings.batch_clearDirFirst = false
+            window.userSettings.batch_fastMode = false
+            window.userSettings.batch_batchSize = 1
+            window.userSettings.batch_skipExisting = true
+            window.userSettings.batch_fastModeMaxParallelizations = 1000
+            window.userSettings.batch_json = false
+            window.userSettings.batch_useMP = false
+            window.userSettings.batch_MPCount = 0
+            window.userSettings.batch_doGrouping = true
+            window.userSettings.batch_doVocoderGrouping = false
+            window.userSettings.batch_delimiter = ","
+            window.userSettings.batch_paginationSize = 100
+
+            updateUIWithSettings()
+            saveUserSettings()
+        }
+    })
+})
+reset_paths_btn.addEventListener("click", () => {
+    window.confirmModal(window.i18n.SURE_RESET_PATHS).then(confirmation => {
+        if (confirmation) {
+
+            const pathKeys = Object.keys(window.userSettings).filter(key => key.includes("modelspath_"))
+            pathKeys.forEach(key => {
+                delete window.userSettings[key]
+            })
+
+            const currGame = window.currentGame ? window.currentGame.gameId : undefined
+
+            // Models and output paths
+            const assetFiles = fs.readdirSync(`${path}/assets`)
+            assetFiles.filter(fn=>fn.endsWith(".json")).forEach(jsonFileName => {
+
+                const gameId = jsonFileName.split(".")[0]
+                window.userSettings[`modelspath_${gameId}`] = `${__dirname.replace(/\\/g,"/")}/models/${gameId}`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+                window.userSettings[`outpath_${gameId}`] = `${__dirname.replace(/\\/g,"/")}/output/${gameId}`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+                if (gameId==currGame) {
+                    setting_models_path_input.value = window.userSettings[`modelspath_${gameId}`]
+                    setting_out_path_input.value = window.userSettings[`outpath_${gameId}`]
+                }
+            })
+
+            if (window.currentModelButton) {
+                window.currentModelButton.click()
+            }
+
+            window.userSettings.errorSoundFile = `${__dirname.replace(/\\/g,"/")}/lib/xp_error.mp3`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+            window.userSettings.batchOutFolder = `${__dirname.replace(/\\/g,"/")}/batch`.replace(/\/\//g, "/").replace("resources/app/resources/app", "resources/app").replace("/javascript", "")
+            batch_outputFolderInput.value = window.userSettings.batchOutFolder
+
+            window.loadAllModels().then(() => {
+                if (currGame) {
+                    window.changeGame(window.currentGame)
+                }
+            })
+            saveUserSettings()
+
+            // Gather the model paths to send to the server
+            const modelsPaths = {}
+            Object.keys(window.userSettings).filter(key => key.includes("modelspath_")).forEach(key => {
+                modelsPaths[key.split("_")[1]] = window.userSettings[key]
+            })
+            doFetch(`http://localhost:8008/setAvailableVoices`, {
+                method: "Post",
+                body: JSON.stringify({
+                    modelsPaths: JSON.stringify(modelsPaths)
+                })
+            })
+        }
+    })
+})
+
+// Search settings
+const settingItems = Array.from(settingsOptionsContainer.children)
+searchSettingsInput.addEventListener("keyup", () => {
+
+    const query = searchSettingsInput.value.trim().toLowerCase()
+
+    const filteredItems = settingItems.map(el => {
+        if (el.tagName=="HR") {return [el, true]}
+        if (el.tagName=="DIV") {
+            if (!query.length || el.children[0].innerHTML.toLowerCase().includes(query)) {
+                return [el, true]
+            }
+        }
+        return [el, false]
+    })
+
+    let lastIsHR = false
+    filteredItems.forEach(elem => {
+        const [el, showIt] = elem
+        if (el.tagName=="HR") {
+            if (lastIsHR) {
+                el.style.display = "none"
+                return
+            }
+            lastIsHR = true
+            el.style.display = "flex"
+        } else {
+            if (showIt) {
+                el.style.display = "flex"
+                lastIsHR = false
+            } else {
+                el.style.display = "none"
+            }
+        }
+    })
+})
+
+
+const currentWindow = er.getCurrentWindow()
+currentWindow.on("move", () => {
+    const bounds = er.getCurrentWindow().webContents.getOwnerBrowserWindow().getBounds()
+    window.userSettings.customWindowPosition = `${bounds.x},${bounds.y}`
+    saveUserSettings()
+})
+
+if (window.userSettings.customWindowPosition) {
+    ipcRenderer.send('updatePosition', {details: window.userSettings.customWindowPosition.split(",")})
+}
+
+
+
+
+window.saveUserSettings = saveUserSettings
+exports.saveUserSettings = saveUserSettings
+exports.deleteFolderRecursive = deleteFolderRecursive

javascript/speech2speech.js

@@ -0,0 +1,379 @@
+"use strict"
+
+window.speech2speechState = {
+    isReadingMic: false,
+    elapsedRecording: 0,
+    s2s_running: false
+}
+
+// Populate the microphone dropdown with the available options
+navigator.mediaDevices.enumerateDevices().then(devices => {
+    devices = devices.filter(device => device.kind=="audioinput" && device.deviceId!="default" && device.deviceId!="communications")
+    devices.forEach(device => {
+        const option = createElem("option", device.label)
+        option.value = device.deviceId
+        setting_mic_selection.appendChild(option)
+    })
+
+    setting_mic_selection.addEventListener("change", () => {
+        window.userSettings.microphone = setting_mic_selection.value
+        window.saveUserSettings()
+        window.initMic()
+    })
+
+    if (Object.keys(window.userSettings).includes("microphone")) {
+        setting_mic_selection.value = window.userSettings.microphone
+    } else {
+        window.userSettings.microphone = setting_mic_selection.value
+        window.saveUserSettings()
+    }
+})
+
+
+
+
+window.initMic = () => {
+    return new Promise(resolve => {
+        const deviceId = window.userSettings.microphone
+
+        navigator.mediaDevices.getUserMedia({audio: {deviceId: deviceId}}).then(stream => {
+            const audio_context = new AudioContext
+            const input = audio_context.createMediaStreamSource(stream)
+            window.speech2speechState.stream = stream
+            resolve()
+
+        }).catch(err => {
+            console.log(err)
+            resolve()
+        })
+    })
+}
+window.initMic()
+
+
+const animateRecordingProgress = () => {
+    const percentDone = (Date.now() - window.speech2speechState.elapsedRecording) / 10000
+
+    if (percentDone >= 1 && percentDone!=Infinity) {
+        if (window.speech2speechState.isReadingMic) {
+            window.stopRecord()
+        }
+    } else {
+        const circle = mic_progress_SVG_circle
+        const radius = circle.r.baseVal.value
+        const circumference = radius * 2 * Math.PI
+        const offset = circumference - percentDone * circumference
+
+        circle.style.strokeDasharray = `${circumference} ${circumference}`
+        circle.style.strokeDashoffset = circumference
+        circle.style.strokeDashoffset = Math.round(offset)
+
+        requestAnimationFrame(animateRecordingProgress)
+    }
+}
+
+
+window.clearVCMicSpinnerProgress = (percent=0) => {
+    const circle = mic_progress_SVG_circle
+    circle.style.stroke = "transparent"
+    const radius = circle.r.baseVal.value
+    const circumference = radius * 2 * Math.PI
+    const offset = circumference - percent * circumference
+
+    circle.style.strokeDasharray = `${circumference} ${circumference}`
+    circle.style.strokeDashoffset = circumference
+    circle.style.strokeDashoffset = Math.floor(offset)
+}
+window.clearVCMicSpinnerProgress = clearVCMicSpinnerProgress
+
+window.startRecord = async () => {
+
+    doFetch(`http://localhost:8008/start_microphone_recording`, {
+        method: "Post"
+    })
+
+    window.speech2speechState.isReadingMic = true
+    window.speech2speechState.elapsedRecording = Date.now()
+    window.clearVCMicSpinnerProgress()
+    mic_progress_SVG_circle.style.stroke = "red"
+    requestAnimationFrame(animateRecordingProgress)
+}
+
+window.outputS2SRecording = (outPath, callback) => {
+    toggleSpinnerButtons()
+    doFetch(`http://localhost:8008/move_recorded_file`, {
+        method: "Post",
+        body: JSON.stringify({
+            file_path: outPath
+        })
+    }).then(r=>r.text()).then(res => {
+        callback()
+    })
+}
+
+window.useWavFileForspeech2speech = (fileName) => {
+    // let sequence = dialogueInput.value.trim().replace("…", "...")
+
+    // For some reason, the samplePlay audio element does not update the source when the file name is the same
+    const tempFileNum = `${Math.random().toString().split(".")[1]}`
+    let tempFileLocation = `${path}/output/temp-${tempFileNum}.wav`
+
+    let style_emb = window.currentModel.audioPreviewPath // Default to the preview audio file, if an embedding can't be found in the json - This shouldn't happen
+    try {
+        style_emb = window.currentModel.games[0].base_speaker_emb // If this fails, the json isn't complete
+    } catch (e) {
+        console.log(e)
+    }
+
+    if (window.wavesurfer) {
+        window.wavesurfer.stop()
+        wavesurferContainer.style.opacity = 0
+    }
+    window.tempFileLocation = `${__dirname.replace("/javascript", "").replace("\\javascript", "")}/output/temp-${tempFileNum}.wav`
+
+
+    const options = {
+        hz: window.userSettings.audio.hz,
+        padStart: window.userSettings.audio.padStart,
+        padEnd: window.userSettings.audio.padEnd,
+        bit_depth: window.userSettings.audio.bitdepth,
+        amplitude: window.userSettings.audio.amplitude,
+        pitchMult: window.userSettings.audio.pitchMult,
+        tempo: window.userSettings.audio.tempo,
+        deessing: window.userSettings.audio.deessing,
+        nr: window.userSettings.audio.nr,
+        nf: window.userSettings.audio.nf,
+        useNR: window.userSettings.audio.useNR,
+        useSR: useSRCkbx.checked,
+        useCleanup: useCleanupCkbx.checked
+    }
+
+
+    doFetch(`http://localhost:8008/runSpeechToSpeech`, {
+        method: "Post",
+        body: JSON.stringify({
+            input_path: fileName,
+            useSR: useSRCkbx.checked,
+            useCleanup: useCleanupCkbx.checked,
+            isBatchMode: false,
+
+            style_emb: style_emb_select.value=="default" ? window.currentModel.games[0].base_speaker_emb : style_emb_select.value.split(",").map(v=>parseFloat(v)),
+            audio_out_path: tempFileLocation,
+
+            doPitchShift: window.userSettings.s2s_prePitchShift,
+            removeNoise: window.userSettings.s2s_removeNoise, // Removed from UI
+            removeNoiseStrength: window.userSettings.s2s_noiseRemStrength, // Removed from UI
+            vc_strength: window.userSettings.vc_strength,
+            n_speakers: undefined,
+            modelPath: undefined,
+            voiceId: undefined,
+
+            options: JSON.stringify(options)
+        })
+    }).then(r=>r.text()).then(res => {
+        // This block of code sometimes gets called before the audio file has actually finished flushing to file
+        // I need a better way to make sure that this doesn't get called until it IS finished, but "for now",
+        // I've set up some recursive re-attempts, below doTheRest
+        window.clearVCMicSpinnerProgress()
+        mic_progress_SVG.style.animation = "none"
+
+        if (res=="TOO_SHORT") {
+            window.toggleSpinnerButtons(true)
+            window.errorModal(`<h3>${window.i18n.VC_TOO_SHORT}</h3>`)
+            return
+        }
+
+        generateVoiceButton.disabled = true
+        let hasLoaded = false
+        let numRetries = 0
+        window.toggleSpinnerButtons(true)
+
+        const doTheRest = () => {
+            if (hasLoaded) {
+                return
+            }
+            // window.wavesurfer = undefined
+            tempFileLocation = tempFileLocation.replaceAll(/\\/g, "/")
+            tempFileLocation = tempFileLocation.replaceAll('/resources/app/resources/app', "/resources/app")
+            tempFileLocation = tempFileLocation.replaceAll('/resources/app', "")
+
+            dialogueInput.value = ""
+            textEditorElem.innerHTML = ""
+            window.isGenerating = false
+
+            window.speech2speechState.s2s_running = true
+
+
+
+            if (res.includes("Traceback")) {
+                window.errorModal(`<h3>${window.i18n.SOMETHING_WENT_WRONG}</h3>${res.replaceAll("\n", "<br>")}`)
+
+            } else if (res.includes("ERROR:APP_VERSION")) {
+                const speech2speechModelVersion = "v"+res.split(",")[1]
+                window.errorModal(`${window.i18n.ERR_XVASPEECH_MODEL_VERSION.replace("_1", speech2speechModelVersion)} ${window.appVersion}`)
+            } else {
+
+                keepSampleButton.disabled = false
+                window.tempFileLocation = tempFileLocation
+
+                // Wavesurfer
+                if (!window.wavesurfer) {
+                    window.initWaveSurfer(window.tempFileLocation)
+                } else {
+                    window.wavesurfer.load(window.tempFileLocation)
+                }
+                window.wavesurfer.on("ready",  () => {
+
+                    hasLoaded = true
+                    wavesurferContainer.style.opacity = 1
+
+                    if (window.userSettings.autoPlayGen) {
+
+                        if (window.userSettings.playChangedAudio) {
+                            const playbackStartEnd = window.sequenceEditor.getChangedTimeStamps(start_index, end_index, window.wavesurfer.getDuration())
+                            if (playbackStartEnd) {
+                                wavesurfer.play(playbackStartEnd[0], playbackStartEnd[1])
+                            } else {
+                                wavesurfer.play()
+                            }
+                        } else {
+                            wavesurfer.play()
+                        }
+                        window.sequenceEditor.adjustedLetters = new Set()
+                        samplePlayPause.innerHTML = window.i18n.PAUSE
+                    }
+                })
+
+                // Persistance across sessions
+                localStorage.setItem("tempFileLocation", tempFileLocation)
+                generateVoiceButton.innerHTML = window.i18n.GENERATE_VOICE
+
+                if (window.userSettings.s2s_autogenerate) {
+                    speech2speechState.s2s_autogenerate = true
+                    generateVoiceButton.click()
+                }
+
+                keepSampleButton.dataset.newFileLocation = `${window.userSettings[`outpath_${window.currentGame.gameId}`]}/${title.dataset.modelId}/vc_${tempFileNum}.wav`
+                keepSampleButton.disabled = false
+                keepSampleButton.style.display = "block"
+                samplePlayPause.style.display = "block"
+
+                setTimeout(doTheRest, 100)
+            }
+
+        }
+
+        doTheRest()
+    }).catch(e => {
+        console.log(e)
+        window.toggleSpinnerButtons(true)
+        window.errorModal(`<h3>${window.i18n.SOMETHING_WENT_WRONG}</h3>`)
+        mic_progress_SVG.style.animation = "none"
+    })
+}
+
+window.stopRecord = (cancelled) => {
+    fs.writeFileSync(`${window.path}/python/temp_stop_recording`, "")
+
+    if (!cancelled) {
+        window.clearVCMicSpinnerProgress(0.35)
+        mic_progress_SVG.style.animation = "spin 1.5s linear infinite"
+        mic_progress_SVG_circle.style.stroke = "white"
+        const fileName = `${__dirname.replace("\\javascript", "").replace("/javascript", "").replace(/\\/g,"/")}/output/recorded_file.wav`
+
+        window.sequenceEditor.clear()
+
+        window.outputS2SRecording(fileName, () => {
+            window.useWavFileForspeech2speech(fileName)
+        })
+    }
+
+    window.speech2speechState.isReadingMic = false
+    window.speech2speechState.elapsedRecording = 0
+    window.clearVCMicSpinnerProgress()
+}
+
+window.micClickHandler = (ctrlKey) => {
+    if (window.speech2speechState.isReadingMic) {
+        window.stopRecord()
+    } else {
+        if (window.currentModel && generateVoiceButton.innerHTML == window.i18n.GENERATE_VOICE) {
+            if (window.currentModel.modelType.toLowerCase()=="xvapitch") {
+                window.startRecord()
+            }
+        } else {
+            window.errorModal(window.i18n.LOAD_TARGET_MODEL)
+        }
+    }
+}
+mic_SVG.addEventListener("mouseenter", () => {
+    if (!window.currentModel || window.currentModel.modelType.toLowerCase()!="xvapitch") {
+        s2s_voiceId_selected_label.style.display = "inline-block"
+    }
+})
+mic_SVG.addEventListener("mouseleave", () => {
+    s2s_voiceId_selected_label.style.display = "none"
+})
+mic_SVG.addEventListener("click", event => window.micClickHandler(event.ctrlKey))
+mic_SVG.addEventListener("contextmenu", () => {
+    if (window.speech2speechState.isReadingMic) {
+        window.stopRecord(true)
+    } else {
+        const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+            src: `${__dirname.replace("\\javascript", "").replace("/javascript", "").replace(/\\/g,"/")}/output/recorded_file_post${window.userSettings.s2s_prePitchShift?"_praat":""}.wav`
+        }))
+        audioPreview.setSinkId(window.userSettings.base_speaker)
+    }
+})
+window.clearVCMicSpinnerProgress()
+
+
+
+// File dragging
+window.uploadS2SFile = (eType, event) => {
+
+    if (["dragenter", "dragover"].includes(eType)) {
+        clearVCMicSpinnerProgress(1)
+        mic_progress_SVG_circle.style.stroke = "white"
+    }
+    if (["dragleave", "drop"].includes(eType)) {
+        window.clearVCMicSpinnerProgress()
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+
+    if (eType=="drop") {
+        if (window.currentModel && generateVoiceButton.innerHTML == window.i18n.GENERATE_VOICE) {
+            const dataTransfer = event.dataTransfer
+            const files = Array.from(dataTransfer.files)
+            const file = files[0]
+
+            if (!file.name.endsWith(".wav")) {
+                window.errorModal(window.i18n.ONLY_WAV_S2S)
+                return
+            }
+
+            clearVCMicSpinnerProgress(0.35)
+            // mic_progress_SVG.style.animation = "spin 1.5s linear infinite"
+            // mic_progress_SVG_circle.style.stroke = "white"
+
+            const fileName = `${__dirname.replace("\\javascript", "").replace("/javascript", "").replace(/\\/g,"/")}/output/recorded_file.wav`
+            fs.copyFileSync(file.path, fileName)
+            window.sequenceEditor.clear()
+            toggleSpinnerButtons()
+            window.useWavFileForspeech2speech(fileName)
+        } else {
+            window.errorModal(window.i18n.LOAD_TARGET_MODEL)
+        }
+    }
+}
+
+micContainer.addEventListener("dragenter", event => window.uploadS2SFile("dragenter", event), false)
+micContainer.addEventListener("dragleave", event => window.uploadS2SFile("dragleave", event), false)
+micContainer.addEventListener("dragover", event => window.uploadS2SFile("dragover", event), false)
+micContainer.addEventListener("drop", event => window.uploadS2SFile("drop", event), false)
+
+// Disable page navigation on badly dropped file
+window.document.addEventListener("dragover", event => event.preventDefault(), false)
+window.document.addEventListener("drop", event => event.preventDefault(), false)

javascript/style_embeddings.js

@@ -0,0 +1,335 @@
+"use strict"
+
+window.allStyleEmbs = {}
+window.styleEmbsMenuState = {
+    embeddingsDir: `${window.path}/embeddings`,
+    hasChangedEmb: false, // For clearing the use of the editor state when re-generating a line with a different embedding
+    selectedEmb: undefined,
+    activatedEmbeddings: {}
+}
+
+
+window.loadStyleEmbsFromDisk = () => {
+    window.allStyleEmbs = {}
+
+    // Read the activated embeddings file
+    window.styleEmbsMenuState.activatedEmbeddings = {}
+    if (fs.existsSync(`./embeddings.txt`)) {
+        const embeddingsEnabled = fs.readFileSync(`./embeddings.txt`, "utf8").split("\n")
+        embeddingsEnabled.forEach(emb => {
+            window.styleEmbsMenuState.activatedEmbeddings[emb.replace("*","")] = emb.includes("*")
+        })
+    }
+
+
+    // Read all the embedding files
+    fs.mkdirSync(window.styleEmbsMenuState.embeddingsDir, {recursive: true})
+    const embFiles = fs.readdirSync(window.styleEmbsMenuState.embeddingsDir)
+    embFiles.forEach(jsonFName => {
+        const jsonData = JSON.parse(fs.readFileSync(`${window.styleEmbsMenuState.embeddingsDir}/${jsonFName}`))
+        jsonData.fileName = `${window.styleEmbsMenuState.embeddingsDir}/${jsonFName}`
+        if (!Object.keys(window.styleEmbsMenuState.activatedEmbeddings).includes(jsonData.emb_id)) {
+            window.styleEmbsMenuState.activatedEmbeddings[jsonData.emb_id] = true
+        }
+        jsonData.enabled = window.styleEmbsMenuState.activatedEmbeddings[jsonData.emb_id]
+        window.allStyleEmbs[jsonData.voiceId] = window.allStyleEmbs[jsonData.voiceId] || []
+
+        window.allStyleEmbs[jsonData.voiceId].push(jsonData)
+    })
+    window.saveEnabledStyleEmbs()
+}
+window.saveEnabledStyleEmbs = () => {
+    fs.writeFileSync(`./embeddings.txt`, Object.keys(window.styleEmbsMenuState.activatedEmbeddings).map(key => {
+        return `${window.styleEmbsMenuState.activatedEmbeddings[key]?"*":""}${key}`
+    }).join("\n"), "utf8")
+}
+window.loadStyleEmbsFromDisk()
+
+
+window.resetStyleEmbFields = () => {
+    styleEmbAuthorInput.value = ""
+    styleEmbGameIdInput.value = ""
+    styleEmbVoiceIdInput.value = ""
+    styleEmbNameInput.value = ""
+    styleEmbDescriptionInput.value = ""
+    styleEmbIdInput.value = ""
+    wavFilepathForEmbComputeInput.value = ""
+    styleEmbValuesInput.value = ""
+
+    styleEmbGameIdInput.value = window.currentGame.gameId
+    if (window.currentModel) {
+        styleEmbVoiceIdInput.value = window.currentModel.voiceId
+    }
+}
+
+window.refreshStyleEmbsTable = () => {
+    styleembsRecordsContainer.innerHTML = ""
+    window.styleEmbsMenuState.selectedEmb = undefined
+    styleEmbDelete.disabled = true
+    window.resetStyleEmbFields()
+
+
+    Object.keys(window.allStyleEmbs).sort().forEach(key => {
+        window.allStyleEmbs[key].forEach((emb,ei) => {
+            const record = createElem("div")
+            const enabledCkbx = createElem("input", {type: "checkbox"})
+            enabledCkbx.checked = emb.enabled
+            record.appendChild(createElem("div", enabledCkbx))
+
+            const embName = createElem("div", emb["embeddingName"])
+            embName.title = emb["embeddingName"]
+            record.appendChild(embName)
+
+            const embGameID = createElem("div", emb["gameId"])
+            embGameID.title = emb["gameId"]
+            record.appendChild(embGameID)
+
+            const embVoiceID = createElem("div", emb["voiceId"])
+            embVoiceID.title = emb["voiceId"]
+            record.appendChild(embVoiceID)
+
+            const embDescription = createElem("div", emb["description"]||"")
+            embDescription.title = emb["description"]||""
+            record.appendChild(embDescription)
+
+            const embID = createElem("div", emb["emb_id"])
+            embID.title = emb["emb_id"]
+            record.appendChild(embID)
+
+            const embVersion = createElem("div", emb["version"]||"1.0")
+            embVersion.title = emb["version"]||"1.0"
+            record.appendChild(embVersion)
+
+            enabledCkbx.addEventListener("click", () => {
+                window.allStyleEmbs[key][ei].enabled = !window.allStyleEmbs[key][ei].enabled
+                window.styleEmbsMenuState.activatedEmbeddings[emb["emb_id"]] = window.allStyleEmbs[key][ei].enabled
+                window.saveEnabledStyleEmbs()
+
+                if (window.currentModel) {
+                    window.loadStyleEmbsForVoice(window.currentModel)
+                }
+            })
+
+
+            record.addEventListener("click", (e) => {
+                if (e.target==enabledCkbx || e.target.nodeName=="BUTTON") {
+                    return
+                }
+                // Clear visual selection of the old selected item, if there was already an item selected before
+                if (window.styleEmbsMenuState.selectedEmb) {
+                    window.styleEmbsMenuState.selectedEmb[0].style.background = "none"
+                    Array.from(window.styleEmbsMenuState.selectedEmb[0].children).forEach(child => child.style.color = "white")
+                }
+
+                window.styleEmbsMenuState.selectedEmb = [record, emb]
+
+                // Visually show that this row is selected
+                window.styleEmbsMenuState.selectedEmb[0].style.background = "white"
+                Array.from(window.styleEmbsMenuState.selectedEmb[0].children).forEach(child => child.style.color = "black")
+                styleEmbDelete.disabled = false
+
+
+                // Populate the edit fields
+                styleEmbAuthorInput.value = emb.author||""
+                styleEmbGameIdInput.value = emb.gameId||""
+                styleEmbVoiceIdInput.value = emb.voiceId||""
+                styleEmbNameInput.value = emb.embeddingName||""
+                styleEmbDescriptionInput.value = emb.description||""
+                styleEmbIdInput.value = emb.emb_id||""
+                wavFilepathForEmbComputeInput.value = ""
+                styleEmbValuesInput.value = emb.emb||""
+            })
+
+            styleembsRecordsContainer.appendChild(record)
+        })
+    })
+}
+styleembs_main.addEventListener("click", (e) => {
+    if (e.target == styleembs_main) {
+        window.refreshStyleEmbsTable()
+    }
+})
+
+styleEmbSave.addEventListener("click", () => {
+
+    const missingFieldsValues = []
+
+    if (!styleEmbAuthorInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.AUTHOR)
+    }
+    if (!styleEmbGameIdInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.GAME_ID)
+    }
+    if (!styleEmbVoiceIdInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.VOICE_ID)
+    }
+    if (!styleEmbNameInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.EMB_NAME)
+    }
+    if (!styleEmbIdInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.EMB_ID)
+    }
+    if (!styleEmbValuesInput.value.trim().length) {
+        missingFieldsValues.push(window.i18n.STYLE_EMB_VALUES)
+    }
+
+    if (missingFieldsValues.length) {
+        window.errorModal(window.i18n.ERROR_MISSING_FIELDS.replace("_1", missingFieldsValues.join(", ")))
+    } else {
+        let outputFilename
+        if (window.styleEmbsMenuState.selectedEmb) {
+            outputFilename = window.styleEmbsMenuState.selectedEmb[1].fileName
+        } else {
+            outputFilename = `${window.styleEmbsMenuState.embeddingsDir}/${styleEmbVoiceIdInput.value.trim().toLowerCase()}.${styleEmbGameIdInput.value.trim().toLowerCase()}.${styleEmbIdInput.value.trim().toLowerCase()}.${styleEmbAuthorInput.value.trim().toLowerCase()}.json`
+        }
+
+        const jsonData = {
+            "author": styleEmbAuthorInput.value.trim(),
+            "version": "1.0", // Should I make this editable in the UI?
+            "gameId": styleEmbGameIdInput.value.trim().toLowerCase(),
+            "voiceId": styleEmbVoiceIdInput.value.trim().toLowerCase(),
+            "description": styleEmbDescriptionInput.value.trim()||"",
+            "embeddingName": styleEmbNameInput.value.trim(),
+            "emb": styleEmbValuesInput.value.trim().split(",").map(v=>parseFloat(v)),
+            "emb_id": styleEmbIdInput.value.trim()
+        }
+
+        fs.writeFileSync(outputFilename, JSON.stringify(jsonData, null, 4), "utf8")
+        window.loadStyleEmbsFromDisk()
+        window.refreshStyleEmbsTable()
+    }
+    if (window.currentModel) {
+        window.loadStyleEmbsForVoice(window.currentModel)
+    }
+})
+
+
+styleEmbDelete.addEventListener("click", () => {
+    window.confirmModal(window.i18n.CONFIRM_DELETE_STYLE_EMB).then(response => {
+        if (response) {
+            fs.unlinkSync(window.styleEmbsMenuState.selectedEmb[1].fileName)
+            window.loadStyleEmbsFromDisk()
+            window.refreshStyleEmbsTable()
+            if (window.currentModel) {
+                window.loadStyleEmbsForVoice(window.currentModel)
+            }
+        }
+    })
+})
+
+
+// Return the default embedding, plus any other ones
+window.loadStyleEmbsForVoice = (currentModel) => {
+
+    const embeddings = {}
+
+    // Add the default option from the model json
+    embeddings["default"] = [window.i18n.DEFAULT, currentModel.games[0].base_speaker_emb] // TODO, specialize to specific game?
+
+    // Load any other style embeddings available
+    if (Object.keys(window.allStyleEmbs).includes(currentModel.voiceId)) {
+        window.allStyleEmbs[currentModel.voiceId].forEach(loadedStyleEmb => {
+            if (loadedStyleEmb.enabled) {
+                embeddings[loadedStyleEmb.emb_id] = [loadedStyleEmb.embeddingName, loadedStyleEmb.emb]
+            }
+        })
+    }
+
+
+    // Add every option to the embeddings selection dropdown
+    style_emb_select.innerHTML = ""
+    Array.from(seq_edit_edit_select.children).forEach(option => {
+        if (option.value.startsWith("style_")) {
+            seq_edit_edit_select.removeChild(option)
+        }
+    })
+    // Add Default first
+    const opt = createElem("option", embeddings["default"][0])
+    opt.value = embeddings["default"][1].join(",")
+    style_emb_select.appendChild(opt)
+
+    Object.keys(embeddings).forEach(key => {
+        if (key=="default") {
+            return
+        }
+        const opt = createElem("option", embeddings[key][0])
+        opt.value = embeddings[key][1].join(",")
+        style_emb_select.appendChild(opt)
+    })
+
+
+    // First remove all existing styles from the dropdown
+    Array.from(seq_edit_view_select.children).forEach(elem => {
+        if (elem.value.startsWith("style")) {
+            seq_edit_view_select.removeChild(elem)
+        }
+    })
+
+    // Add every option (except Default) to the sliders viewing/editing dropdowns
+    Object.keys(embeddings).forEach(key => {
+        if (key=="default") {
+            return
+        }
+        const opt = createElem("option", `${window.i18n.STYLE_EMB_IS} ${embeddings[key][0]}`)
+        opt.value = `style_${key}`
+        seq_edit_view_select.appendChild(opt)
+
+        const opt2 = createElem("option", `${window.i18n.STYLE_EMB_IS} ${embeddings[key][0]}`)
+        opt2.value = `style_${key}`
+        seq_edit_edit_select.appendChild(opt2)
+    })
+
+    window.appState.currentModelEmbeddings = embeddings
+}
+style_emb_select.addEventListener("change", () => window.styleEmbsMenuState.hasChangedEmb)
+
+
+
+window.styleEmbsModalOpenCallback = () => {
+    styleEmbGameIdInput.value = window.currentGame.gameId
+    if (window.currentModel) {
+        styleEmbVoiceIdInput.value = window.currentModel.voiceId
+    }
+    window.refreshStyleEmbsTable()
+}
+window.dragDropWavForEmbComputeFilepathInput = (eType, event) => {
+    if (["dragenter", "dragover"].includes(eType)) {
+        wavFileDragDropArea.style.background = "#5b5b5b"
+        wavFileDragDropArea.style.color = "white"
+    }
+    if (["dragleave", "drop"].includes(eType)) {
+        wavFileDragDropArea.style.background = "rgba(0,0,0,0)"
+        wavFileDragDropArea.style.color = "white"
+    }
+
+    event.preventDefault()
+    event.stopPropagation()
+
+    const dataLines = []
+
+    if (eType=="drop") {
+        const dataTransfer = event.dataTransfer
+        const files = Array.from(dataTransfer.files)
+
+        if (files[0].path.endsWith(".wav")) {
+            wavFilepathForEmbComputeInput.value = String(files[0].path).replaceAll(/\\/g, "/")
+        } else {
+            window.errorModal(window.i18n.ERROR_FILE_MUST_BE_WAV)
+        }
+    }
+}
+
+wavFileDragDropArea.addEventListener("dragenter", event => window.dragDropWavForEmbComputeFilepathInput("dragenter", event), false)
+wavFileDragDropArea.addEventListener("dragleave", event => window.dragDropWavForEmbComputeFilepathInput("dragleave", event), false)
+wavFileDragDropArea.addEventListener("dragover", event => window.dragDropWavForEmbComputeFilepathInput("dragover", event), false)
+wavFileDragDropArea.addEventListener("drop", event => window.dragDropWavForEmbComputeFilepathInput("drop", event), false)
+
+
+getStyleEmbeddingBtn.addEventListener("click", async () => {
+    if (!wavFilepathForEmbComputeInput.value.trim().length) {
+        window.errorModal(window.i18n.ERROR_NEED_WAV_FILE)
+    } else {
+        const embedding = await window.getSpeakerEmbeddingFromFilePath(wavFilepathForEmbComputeInput.value)
+        styleEmbValuesInput.value = embedding
+    }
+})

javascript/textarea.js

@@ -0,0 +1,580 @@
+"use strict"
+
+
+// This doesn't seem to work anymore. TODO, make it work again
+function getCaretPosition() {
+    var sel = document.selection, range, rect;
+    var x = 0, y = 0;
+    if (sel) {
+        if (sel.type != "Control") {
+            range = sel.createRange();
+            range.collapse(true);
+            x = range.boundingLeft;
+            y = range.boundingTop;
+        }
+    } else if (window.getSelection) {
+        sel = window.getSelection();
+        if (sel.rangeCount) {
+            range = sel.getRangeAt(0).cloneRange();
+            if (range.getClientRects) {
+                range.collapse(true);
+                if (range.getClientRects().length>0){
+                    rect = range.getClientRects()[0];
+                    x = rect.left;
+                    y = rect.top;
+                }
+            }
+            // Fall back to inserting a temporary element
+            if (x == 0 && y == 0) {
+                var span = document.createElement("span");
+                if (span.getClientRects) {
+                    // Ensure span has dimensions and position by
+                    // adding a zero-width space character
+                    span.appendChild( document.createTextNode("\u200b") );
+                    range.insertNode(span);
+                    rect = span.getClientRects()[0];
+                    x = rect.left;
+                    y = rect.top;
+                    var spanParent = span.parentNode;
+                    spanParent.removeChild(span);
+
+                    // Glue any broken text nodes back together
+                    spanParent.normalize();
+                }
+            }
+        }
+    }
+    return { x: x, y: y };
+}
+
+
+window.ARPABET_SYMBOLS_v2 = [
+    "AA0", "AA1", "AA2", "AE0", "AE1", "AE2", "AH0", "AH1", "AH2", "AO0", "AO1","AO2", "AW0", "AW1", "AW2", "AY0", "AY1", "AY2", "B", "CH", "D", "DH",
+    "EH0", "EH1", "EH2", "ER0", "ER1", "ER2",     "EY0", "EY1", "EY2", "F", "G", "HH", "IH0", "IH1", "IH2", "IY0", "IY1", "IY2", "JH", "K", "L", "M",
+    "N", "NG", "OW0", "OW1", "OW2", "OY0", "OY1", "OY2", "P", "R", "S", "SH", "T", "TH", "UH0", "UH1", "UH2", "UW0", "UW1", "UW2", "V", "W", "Y", "Z", "ZH"
+]
+
+let ARPABET_SYMBOLS = [
+  'AA0', 'AA1', 'AA2', 'AA', 'AE0', 'AE1', 'AE2', 'AE', 'AH0', 'AH1', 'AH2', 'AH',
+  'AO0', 'AO1', 'AO2', 'AO', 'AW0', 'AW1', 'AW2', 'AW', 'AY0', 'AY1', 'AY2', 'AY',
+  'B', 'CH', 'D', 'DH', 'EH0', 'EH1', 'EH2', 'EH', 'ER0', 'ER1', 'ER2', 'ER',
+  'EY0', 'EY1', 'EY2', 'EY', 'F', 'G', 'HH', 'IH0', 'IH1', 'IH2', 'IH', 'IY0', 'IY1',
+  'IY2', 'IY', 'JH', 'K', 'L', 'M', 'N', 'NG', 'OW0', 'OW1', 'OW2', 'OW', 'OY0',
+  'OY1', 'OY2', 'OY', 'P', 'R', 'S', 'SH', 'T', 'TH', 'UH0', 'UH1', 'UH2', 'UH',
+  'UW0', 'UW1', 'UW2', 'UW', 'V', 'W', 'Y', 'Z', 'ZH'
+]
+
+let extra_arpabet_symbols = [
+    "AX",
+    "AXR",
+    "IX",
+    "UX",
+    "DX",
+    "EL",
+    "EM",
+    "EN0",
+    "EN1",
+    "EN2",
+    "EN",
+    "NX",
+    "Q",
+    "WH",
+]
+let new_arpabet_symbols = [
+    "RRR",
+    "HR",
+    "OE",
+    "RH",
+    "TS",
+
+    "RR",
+    "UU",
+    "OO",
+    "KH",
+    "SJ",
+    "HJ",
+    "BR",
+]
+window.ARPABET_SYMBOLS_v3 = ARPABET_SYMBOLS.concat(extra_arpabet_symbols).concat(new_arpabet_symbols).sort((a,b)=>a<b?-1:1)
+
+const preprocess = (caretStart) => {
+
+    const defaultLang = "en"
+    let text = dialogueInput.value
+
+    const finishedParts = []
+    // const parts = text.split(/\\lang\{[a-z]{0,2}\}\{/gi)
+    const parts = text.split(/\\lang\[[a-z]{0,2}\]\[/gi)
+    // const matchIterator = text.matchAll(/\\lang\{[a-z]{0,2}\}\{/gi)
+    const matchIterator = text.matchAll(/\\lang\[[a-z]{0,2}\]\[/gi)
+    finishedParts.push([defaultLang, parts[0]])
+
+    const langStack = []
+
+    // console.log("parts", parts)
+    let textCounter = parts[0].length
+    let caretInARPAbet = false
+
+    parts.forEach((part,pi) => {
+        if (pi) {
+            const match = matchIterator.next().value[0]
+            const langCode = match.split("lang[")[1].split("]")[0]
+            langStack.push(langCode)
+            // console.log("add langStack", langStack)
+
+            textCounter += match.length
+
+            let unescaped_part = ""
+
+            part.split("]").forEach(sub_part => {
+                // console.log("sub_part", sub_part, textCounter, textCounter+sub_part.length)
+
+                if (caretStart > textCounter && caretStart <textCounter+sub_part.length) {
+                    caretInARPAbet = true
+
+                                                        // If backspace-ing a "{", and the next non-space character is "}", then delete that also
+
+                                                        // Add ctrl+<space> to open the auto-complete
+
+                }
+
+                // if (sub_part.includes("[")) {
+                //     unescaped_part += sub_part+"]"
+                //     return
+                // }
+
+                sub_part = unescaped_part+sub_part
+
+                unescaped_part = ""
+
+                if (part.includes("]")) {
+                    finishedParts.push([langStack.pop()||defaultLang, sub_part])
+                } else {
+                    finishedParts.push([langStack[langStack.length-1], sub_part])
+                }
+                // finishedParts.push([langStack.pop()||defaultLang, sub_part])
+            })
+        }
+    })
+    return caretInARPAbet
+}
+
+window.hideAutocomplete = () => {
+    textEditorTooltip.style.display = "none"
+    textEditorTooltip.innerHTML = ""
+    autocomplete_callback = undefined
+}
+let textWrittenSinceAutocompleteWasShown = ""
+const filterOrHideAutocomplete = () => {
+    if (textEditorTooltip.style.display=="flex") {
+        highlightedAutocompleteIndex = 0
+        let childrenShown = 0
+        Array.from(textEditorTooltip.children).forEach(child => {
+            if (child.classList.contains("autocomplete_option_active")) {
+                child.classList.toggle("autocomplete_option_active")
+            }
+
+            if (child.innerText.toLowerCase().startsWith(textWrittenSinceAutocompleteWasShown) || textWrittenSinceAutocompleteWasShown.length==0) {
+                child.style.display = "flex"
+                childrenShown += 1
+            } else {
+                child.style.display = "none"
+            }
+        })
+        if (childrenShown==0) {
+            hideAutocomplete()
+            return
+        }
+        setHighlightedAutocomplete(0, true)
+    }
+}
+let autocomplete_callback = undefined
+const showAutocomplete = (options, callback) => {
+    const position = getCaretPosition(dialogueInput)
+
+    // The getCaretPosition function doesn't work anymore. At least center it
+    position.x = window.visualViewport.width/2
+
+    textEditorTooltip.style.left = position.x + "px"
+    textEditorTooltip.style.top = position.y + "px"
+
+    highlightedAutocompleteIndex = 0
+    textWrittenSinceAutocompleteWasShown = ""
+    autocomplete_callback = callback
+
+    options.forEach(option => {
+        const optElem = createElem("div.autocomplete_option", option[0])
+        optElem.dataset.autocomplete_return = option.length>1 ? option[1] : option[0]
+        optElem.addEventListener("click", () => {
+            callback(optElem.dataset.autocomplete_return)
+            hideAutocomplete()
+            refreshText()
+        })
+        textEditorTooltip.appendChild(optElem)
+    })
+    textEditorTooltip.style.display = "flex"
+    setHighlightedAutocomplete(0, true)
+    return
+}
+
+let highlightedAutocompleteIndex = 0
+const setHighlightedAutocomplete = (delta, override=false) => {
+
+    let NEW_highlightedAutocompleteIndex = Math.min(textEditorTooltip.children.length-1, Math.max(0, highlightedAutocompleteIndex+delta))
+    if (override || NEW_highlightedAutocompleteIndex != highlightedAutocompleteIndex) {
+        if (!override) {
+            textEditorTooltip.children[highlightedAutocompleteIndex].classList.toggle("autocomplete_option_active")
+        }
+        textEditorTooltip.children[override ? delta : NEW_highlightedAutocompleteIndex].classList.toggle("autocomplete_option_active")
+        highlightedAutocompleteIndex = NEW_highlightedAutocompleteIndex
+        // textEditorTooltip.children[highlightedAutocompleteIndex].scrollIntoView()
+    }
+}
+
+
+dialogueInput.addEventListener("keydown", event => {
+    if (event.key=="Tab" || event.key=="Enter") {
+        event.preventDefault()
+
+        if (autocomplete_callback!==undefined) {
+            autocomplete_callback(textEditorTooltip.children[highlightedAutocompleteIndex].dataset.autocomplete_return)
+            hideAutocomplete()
+            refreshText()
+            return
+        }
+
+        let cursorIndex = dialogueInput.selectionStart
+        if (cursorIndex) {
+            // Move into the next [] bracket if already wrote down language
+            let textPreCursor = dialogueInput.value.slice(0, cursorIndex)
+            let textPostCursor = dialogueInput.value.slice(cursorIndex, dialogueInput.value.length)
+
+            if (textPreCursor.slice(textPreCursor.length-8, 7)=="\\lang[") {
+                dialogueInput.setSelectionRange(cursorIndex+2,cursorIndex+2)
+
+            // Move out of [] if at the end
+            } else if (textEditorTooltip.style.display=="none" && (textPostCursor.startsWith("]") || textPostCursor.startsWith("}"))) {
+                console.log("moving one")
+                dialogueInput.setSelectionRange(cursorIndex+1,cursorIndex+1)
+            }
+
+        }
+
+    }
+})
+
+const splitWords = (sequence, addSpace) => {
+    const words = []
+
+    // const sequenceProcessed = sequence
+    const sequenceProcessed = [] // Do further processing to also split on { } symbols, not just spaces
+    sequence.forEach(word => {
+        if (word.includes("{")) {
+            word.split("{").forEach((w, wi) => {
+                sequenceProcessed.push(wi ? ["{"+w, addSpace] : [w, false])
+            })
+        } else if (word.includes("}")) {
+            word.split("}").forEach((w, wi) => {
+                sequenceProcessed.push(wi ? [w, addSpace] : [w+"}", false])
+            })
+        } else {
+            sequenceProcessed.push([word, addSpace])
+        }
+    })
+
+    sequenceProcessed.forEach(([word, addSpace]) => {
+
+        if (word.startsWith("\\lang[")) {
+            words.push(word.split("][")[0]+"][")
+            word = word.split("][")[1]
+        }
+
+        ["}","]","[","{"].forEach(char => {
+            if (word.startsWith(char)) {
+                words.push(char)
+                word = word.slice(1,word.length)
+            }
+        })
+
+        const endExtras = [];
+
+        ["}","]","[","{"].forEach(char => {
+            if (word.endsWith(char)) {
+                endExtras.push(char)
+                word = word.slice(0,word.length-1)
+            }
+        })
+
+        words.push(word)
+        endExtras.reverse().forEach(extra => words.push(extra))
+
+        // if (word.startsWith("{")) {
+        //     split_words.push("{")
+        //     word = word.slice(1,word.length)
+        // }
+        // if (word.endsWith("}")) {
+        //     split_words.push("{")
+        //     word = word.slice(1,word.length)
+        // }
+
+        if (addSpace) {
+            words.push(" ")
+        }
+    })
+
+    return words
+}
+
+window.refreshText = () => {
+    let all_text = dialogueInput.value
+    textEditorElem.innerHTML = ""
+
+    let openedCurlys = 0
+    let openedLangs = 0
+
+    let split_words = splitWords(all_text.split(" "), true)
+    split_words = splitWords(split_words)
+    split_words = splitWords(split_words)
+    split_words = splitWords(split_words)
+
+    // console.log("split_words", split_words)
+    // dfgd()
+
+    let caretCounter = 0
+    let caretInARPAbet = false
+
+    let firstOpenCurly = undefined
+    let lastOpenCurly = undefined
+
+    split_words.forEach(word => {
+
+        if (caretCounter<=dialogueInput.selectionStart && (caretCounter+word.length)>dialogueInput.selectionStart) {
+            // console.log(`caret (${dialogueInput.selectionStart}) in counter (${caretCounter}): `, word, openedCurlys, openedLangs)
+            caretInARPAbet = openedCurlys > 0
+        }
+        caretCounter += word.length
+        const spanElem = createElem("span.manyWhitespace", word)
+
+        if (word.startsWith("\\lang[")) {
+            openedLangs += 1
+        }
+        if (word.startsWith("{")) {
+            openedCurlys += 1
+            if (!caretInARPAbet) {
+                firstOpenCurly = spanElem
+            }
+        }
+
+        if (openedCurlys) {
+            spanElem.style.fontWeight = "bold"
+            spanElem.style.fontStyle = "italic"
+        }
+        if (openedLangs) {
+            spanElem.style.background = "rgba(50, 150, 250, 0.2)"
+        }
+
+        ///====
+        if (word.includes("part-highlighted")) {
+            spanElem.style.textDecoration = "underline dotted red"
+        } else  if (word.includes("highlighted")) {
+            spanElem.style.textDecoration = "underline solid red"
+        }
+        ///====
+
+        if (word.endsWith("]")) {
+            openedLangs -= 1
+        }
+        if (word.endsWith("}")) {
+            openedCurlys -= 1
+            if (caretInARPAbet && lastOpenCurly===undefined) {
+                lastOpenCurly = spanElem
+            }
+        }
+
+        textEditorElem.appendChild(spanElem)
+
+    })
+
+    preprocess(dialogueInput.selectionStart)
+    return [caretInARPAbet, firstOpenCurly, lastOpenCurly]
+}
+
+const languagesList = Object.keys(window.supportedLanguages)
+
+const insertText = (inputTextArea, textToInsert, caretOffset=0) => {
+    let cursorIndex = inputTextArea.selectionStart
+    inputTextArea.value = inputTextArea.value.slice(0, cursorIndex) + textToInsert + inputTextArea.value.slice(cursorIndex, inputTextArea.value.length)
+    caretOffset += textToInsert.length
+    inputTextArea.setSelectionRange(cursorIndex+caretOffset,cursorIndex+caretOffset)
+    refreshText()
+}
+
+dialogueInput.addEventListener("keydown", event => {
+    generateVoiceButton.disabled = window.currentModel==undefined || !dialogueInput.value.length
+
+    if (event.key=="Enter") {
+        event.stopPropagation()
+        event.preventDefault()
+        return
+    }
+
+    if (textEditorTooltip.style.display=="flex" && (event.key=="ArrowDown" || event.key=="ArrowUp" || (!window.shiftKeyIsPressed && event.key=="ArrowLeft") || (!window.shiftKeyIsPressed && event.key=="ArrowRight"))) {
+    // if (textEditorTooltip.style.display=="flex" && (event.key=="ArrowDown" || event.key=="ArrowUp")) {
+        event.stopPropagation()
+        event.preventDefault()
+        return
+    }
+    if (event.key=="}") {
+        if (dialogueInput.value.slice(dialogueInput.selectionStart, dialogueInput.value.length-1).startsWith("}")) {
+            dialogueInput.setSelectionRange(dialogueInput.selectionStart+1, dialogueInput.selectionStart+1)
+            event.stopPropagation()
+            event.preventDefault()
+            return
+        }
+    }
+    if (event.key=="]") {
+        if (dialogueInput.value.slice(dialogueInput.selectionStart, dialogueInput.value.length-1).startsWith("]")) {
+            dialogueInput.setSelectionRange(dialogueInput.selectionStart+1, dialogueInput.selectionStart+1)
+            event.stopPropagation()
+            event.preventDefault()
+            return
+        }
+    }
+})
+
+let is_doing_gp2 = false
+window.get_g2p = (text_to_g2p) => {
+    return new Promise(resolve => {
+        doFetch("http://localhost:8008/getG2P", {method: "Post", body: JSON.stringify({base_lang: base_lang_select.value, text: text_to_g2p})})
+        .then(r=>r.text()).then(res => {
+            is_doing_gp2 = false
+            resolve(res)
+        })
+    })
+}
+
+const handleTextUpdate = (event) => {
+    generateVoiceButton.disabled = window.currentModel==undefined || !dialogueInput.value.length
+
+    window.shiftKeyIsPressed = event.shiftKey
+
+    if (textEditorTooltip.style.display=="flex" && (event.type=="click" || (!window.shiftKeyIsPressed && event.key=="ArrowDown") || (!window.shiftKeyIsPressed && event.key=="ArrowRight"))) {
+        event.stopPropagation()
+        event.preventDefault()
+        setHighlightedAutocomplete(1)
+        return
+    }
+    if (textEditorTooltip.style.display=="flex" && (event.type=="click" || (!window.shiftKeyIsPressed && event.key=="ArrowLeft") || (!window.shiftKeyIsPressed && event.key=="ArrowUp"))) {
+        event.stopPropagation()
+        event.preventDefault()
+        setHighlightedAutocomplete(-1)
+        return
+    }
+
+
+    if (event.type!="click" && (event.key=="Shift" || event.key=="Control")) {
+        event.stopPropagation()
+        event.preventDefault()
+        return
+    }
+
+    const [caretInARPAbet, firstOpenCurly, lastOpenCurly] = refreshText()
+    if (caretInARPAbet) {
+        firstOpenCurly && (firstOpenCurly.style.color = "red")
+        lastOpenCurly && (lastOpenCurly.style.color = "red")
+    }
+
+
+    textEditorElem.scrollTop = dialogueInput.scrollTop
+
+
+    if (dialogueInput.selectionStart!=dialogueInput.selectionEnd && !is_doing_gp2) {
+
+        hideAutocomplete()
+
+        showAutocomplete([["&lt;Convert to phonemes&gt;"]], () => {
+
+            const text_to_g2p = dialogueInput.value.slice(dialogueInput.selectionStart, dialogueInput.selectionEnd)
+            is_doing_gp2 = true
+
+            get_g2p(text_to_g2p).then(phonemes => {
+                const initialStart = dialogueInput.selectionStart
+                dialogueInput.value = dialogueInput.value.slice(0, dialogueInput.selectionStart) + dialogueInput.value.slice(dialogueInput.selectionEnd, dialogueInput.value.length)
+
+                dialogueInput.selectionStart = initialStart
+
+                insertText(dialogueInput, phonemes, 0)
+            })
+        })
+
+    } else
+    // } else {
+        if (event.type!="click" && event.key.length==1 && event.key.match(/[a-z]/i)) {
+            textWrittenSinceAutocompleteWasShown += event.key.toLowerCase()
+            filterOrHideAutocomplete()
+        } else if (event.type!="click" && event.key=="Backspace") {
+            if (textWrittenSinceAutocompleteWasShown.length==0) {
+                hideAutocomplete()
+            } else {
+                textWrittenSinceAutocompleteWasShown = textWrittenSinceAutocompleteWasShown.slice(0,textWrittenSinceAutocompleteWasShown.length-1)
+                filterOrHideAutocomplete()
+            }
+        } else {
+            hideAutocomplete()
+        }
+
+        const ctrlSpace = event.ctrlKey && event.code=="Space"
+
+        if (event.type!="click" && (event.key=="{" || event.key=="") || ctrlSpace) {
+            if (!ctrlSpace && event.key!="") {
+                insertText(dialogueInput, "}", -1)
+            }
+
+            if (caretInARPAbet) {
+                let symbols = window.ARPABET_SYMBOLS_v3
+                if (window.currentModel&&window.currentModel.modelType=="FastPitch1.1") {
+                    symbols = window.ARPABET_SYMBOLS_v2
+                } else if (window.currentModel&&window.currentModel.modelType=="FastPitch") {
+                    symbols = ["&lt;ARPAbet only available for v2+ models&gt;"]
+                }
+                showAutocomplete(symbols.map(v=>{return [v]}), option => {
+                    if (symbols.length>1) {
+                        insertText(dialogueInput, option.slice(textWrittenSinceAutocompleteWasShown.length, option.length)+" ", 0)
+                    }
+                })
+            }
+            if (event.key!="") {
+                handleTextUpdate({type: "keydown", key: ""})
+            }
+        }
+
+        if (event.type!="click" && event.key=="\\") {
+            // showAutocomplete([["\\lang[language][text]", "\\lang[][]"], ["\\sil[milliseconds]", "\\sil[]"]], (option) => {
+            showAutocomplete([["\\lang[language][text]", "\\lang[][]"]], (option) => {
+
+                if (option.includes("lang")) {
+                    insertText(dialogueInput, option.slice(1, option.length), -3)
+                } else {
+                    insertText(dialogueInput, option.slice(1, option.length), -1)
+                }
+
+                setTimeout(() => {
+                    showAutocomplete(languagesList.map(v=>{return [v]}), option => {
+                        insertText(dialogueInput, option.slice(textWrittenSinceAutocompleteWasShown.length, option.length), 2)
+                    })
+                }, 100)
+            })
+        }
+    // }
+// })
+}
+dialogueInput.addEventListener("click", event => handleTextUpdate(event))
+dialogueInput.addEventListener("keyup", event => handleTextUpdate(event))
+refreshText()
+setTimeout(window.refreshText, 500)
+
+window.addEventListener("click", event => {
+    if (event.target && event.target!=textEditorTooltip && event.target.className && event.target.className.includes && !event.target.className.includes("autocomplete_option")) {
+        hideAutocomplete()
+    }
+})

javascript/totd.js

@@ -0,0 +1,145 @@
+"use strict"
+// tip of the day
+
+const tips = {
+    "1": window.i18n.TOTD_1,
+    "2": window.i18n.TOTD_2,
+    "3": window.i18n.TOTD_3,
+    "4": window.i18n.TOTD_4,
+    "5": window.i18n.TOTD_5,
+    "6": window.i18n.TOTD_6,
+    "7": window.i18n.TOTD_7,
+    "8": window.i18n.TOTD_8,
+    "9": window.i18n.TOTD_9,
+    "10": window.i18n.TOTD_10,
+    "11": window.i18n.TOTD_11,
+    "12": window.i18n.TOTD_12,
+    "13": window.i18n.TOTD_13,
+    "14": window.i18n.TOTD_14,
+    "15": window.i18n.TOTD_15,
+    "16": window.i18n.TOTD_16,
+    "17": window.i18n.TOTD_17,
+    "18": window.i18n.TOTD_18,
+    "19": window.i18n.TOTD_19,
+    "20": window.i18n.TOTD_20,
+    "21": window.i18n.TOTD_21,
+    "22": window.i18n.TOTD_22,
+    "23": window.i18n.TOTD_23,
+    "24": window.i18n.TOTD_24,
+    "25": window.i18n.TOTD_25,
+    "26": window.i18n.TOTD_26,
+    "27": window.i18n.TOTD_27,
+    "28": window.i18n.TOTD_28,
+    "29": window.i18n.TOTD_29,
+    "30": window.i18n.TOTD_30,
+    "31": window.i18n.TOTD_31,
+    "32": window.i18n.TOTD_32,
+}
+
+window.totd_state = {
+    startupChecked: false,
+    filteredIDs: [],
+    tipPageIndex: 0
+}
+
+const initTipOfTheDayMenu = (now, tipIDs) => {
+
+    window.totd_state.filteredIDs = tipIDs
+
+    totdContainer.style.opacity = 1
+    totdContainer.style.display = "flex"
+    chromeBar.style.opacity = 1
+    requestAnimationFrame(() => requestAnimationFrame(() => totdContainer.style.opacity = 1))
+
+    return new Promise(resolve => {
+        // Close button
+        totd_close.addEventListener("click", () => {
+            closeModal(totdContainer)
+            resolve()
+        })
+
+        localStorage.setItem("totd_lastDate", now.toJSON(now))
+        tipMessage.innerHTML = tips[window.totd_state.filteredIDs[0]]
+
+        totd_counter.innerHTML = `1/${window.totd_state.filteredIDs.length}`
+
+        saveSeenTip(window.totd_state.filteredIDs[0])
+    })
+}
+
+
+const saveSeenTip = ID => {
+    let seenTipIDs = localStorage.getItem("totd_seenIDs")
+    seenTipIDs = seenTipIDs ? seenTipIDs.split(",") : []
+    seenTipIDs = new Set(seenTipIDs)
+    seenTipIDs.add(ID)
+    localStorage.setItem("totd_seenIDs", Array.from(seenTipIDs).join(","))
+}
+
+setting_btnShowTOTD.addEventListener("click", () => {
+    window.showTipIfEnabledAndNewDay(true)
+})
+
+
+totdPrevTipBtn.addEventListener("click", () => {
+    const newIndex = Math.max(0, window.totd_state.tipPageIndex-1)
+    if (newIndex!=window.totd_state.tipPageIndex) {
+        window.totd_state.tipPageIndex = newIndex
+        tipMessage.innerHTML = tips[window.totd_state.filteredIDs[window.totd_state.tipPageIndex]]
+        saveSeenTip(window.totd_state.filteredIDs[window.totd_state.tipPageIndex])
+        totd_counter.innerHTML = `${window.totd_state.tipPageIndex+1}/${window.totd_state.filteredIDs.length}`
+    }
+})
+
+totdNextTipBtn.addEventListener("click", () => {
+    const newIndex = Math.min(window.totd_state.filteredIDs.length-1, window.totd_state.tipPageIndex+1)
+    if (newIndex!=window.totd_state.tipPageIndex) {
+        window.totd_state.tipPageIndex = newIndex
+        tipMessage.innerHTML = tips[window.totd_state.filteredIDs[window.totd_state.tipPageIndex]]
+        saveSeenTip(window.totd_state.filteredIDs[window.totd_state.tipPageIndex])
+        totd_counter.innerHTML = `${window.totd_state.tipPageIndex+1}/${window.totd_state.filteredIDs.length}`
+    }
+})
+
+
+window.showTipIfEnabledAndNewDay = (justShowIt) => {
+
+    window.totd_state.startupChecked = true
+
+    return new Promise(async resolve => {
+        const lastDate = localStorage.getItem("totd_lastDate")
+        const now = new Date()
+
+        // If this has never happened before, or the last date is not today, then show the tip menu
+        if (justShowIt || !lastDate || lastDate.split("T")[0]!=now.toJSON().split("T")[0]) {
+
+            // If the tips of the day are enabled
+            if (justShowIt || window.userSettings.showTipOfTheDay) {
+
+                let shuffledTipIDs = window.shuffle(Object.keys(tips))
+
+                // If only new/unseen tips are to be shown, get the seen list, and filter out the seen tips
+                if (window.userSettings.showUnseenTipOfTheDay) {
+                    let seenTipIDs = localStorage.getItem("totd_seenIDs")
+                    if (seenTipIDs) {
+                        seenTipIDs = seenTipIDs.split(",")
+                        shuffledTipIDs = shuffledTipIDs.filter(id => !seenTipIDs.includes(id))
+                    }
+                }
+
+                // If there are any tips remaining, after any filtering, then show the menu
+                if (shuffledTipIDs && shuffledTipIDs.length) {
+                    await initTipOfTheDayMenu(now, shuffledTipIDs)
+                    resolve()
+                } else if (justShowIt) {
+                    window.errorModal(window.i18n.TOTD_NO_UNSEEN)
+                }
+            } else {
+                resolve()
+            }
+        } else {
+            resolve()
+        }
+    })
+}
+

javascript/util.js

@@ -0,0 +1,740 @@
+"use strict"
+
+const unzipper = require('unzipper')
+const er = require('@electron/remote')
+
+/**
+ * String.prototype.replaceAll() polyfill
+ * https://gomakethings.com/how-to-replace-a-section-of-a-string-with-another-one-with-vanilla-js/
+ * @author Chris Ferdinandi
+ * @license MIT
+ */
+if (!String.prototype.replaceAll) {
+    String.prototype.replaceAll = function(str, newStr){
+
+        // If a regex pattern
+        if (Object.prototype.toString.call(str).toLowerCase() === '[object regexp]') {
+            return this.replace(str, newStr);
+        }
+
+        // If a string
+        return this.replace(new RegExp(str, 'g'), newStr);
+
+    };
+}
+
+
+window.toggleSpinnerButtons = (spinnerVisible=undefined) => {
+
+    if (spinnerVisible===undefined) {
+        spinnerVisible = window.getComputedStyle(spinner).display == "block"
+    }
+
+    spinner.style.display = spinnerVisible ? "none" : "block"
+    keepSampleButton.style.display = spinnerVisible ? "block" : "none"
+    generateVoiceButton.style.display = spinnerVisible ? "block" : "none"
+    samplePlayPause.style.display = spinnerVisible ? "flex" : "none"
+}
+
+window.infoModal = message => new Promise(resolve => resolve(createModal("info", message)))
+window.confirmModal = message => new Promise(resolve => resolve(createModal("confirm", message)))
+window.spinnerModal = message => new Promise(resolve => resolve(createModal("spinner", message)))
+window.errorModal = message => {
+    window.errorModalHasOpened = true
+    if (window.userSettings.useErrorSound) {
+        const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+            src: window.userSettings.errorSoundFile
+        }))
+        audioPreview.setSinkId(window.userSettings.base_speaker)
+    }
+    window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent?window.batch_state.taskBarPercent:1, {mode: "error"})
+    return new Promise(topResolve => {
+        createModal("error", message).then(() => {
+            window.electronBrowserWindow.setProgressBar(window.batch_state.taskBarPercent?window.batch_state.taskBarPercent:-1, {mode: window.batch_state.state?"normal":"paused"})
+            topResolve()
+        })
+    })
+}
+window.createModal = (type, message) => {
+    dialogueInput.blur()
+    return new Promise(resolve => {
+        modalContainer.innerHTML = ""
+        const displayMessage = message.prompt ? message.prompt : message
+        const modal = createElem("div.modal#activeModal", {style: {opacity: 0}}, createElem("span.createModalContents", displayMessage))
+        modal.dataset.type = type
+
+        if (type=="confirm") {
+            const yesButton = createElem("button", {style: {background: `#${themeColour}`}})
+            yesButton.innerHTML = window.i18n.YES
+            const noButton = createElem("button", {style: {background: `#${themeColour}`}})
+            noButton.innerHTML = window.i18n.NO
+            modal.appendChild(createElem("div", yesButton, noButton))
+
+            yesButton.addEventListener("click", () => {
+                closeModal(modalContainer).then(() => {
+                    resolve(true)
+                })
+            })
+            noButton.addEventListener("click", () => {
+                closeModal(modalContainer).then(() => {
+                    resolve(false)
+                })
+            })
+        } else if (type=="error" || type=="info") {
+            const closeButton = createElem("button", {style: {background: `#${themeColour}`}})
+            closeButton.innerHTML = window.i18n.CLOSE
+            modal.appendChild(createElem("div", closeButton))
+
+            closeButton.addEventListener("click", () => {
+                closeModal(modalContainer).then(() => {
+                    resolve(false)
+                })
+            })
+        } else if (type=="prompt") {
+            const closeButton = createElem("button", {style: {background: `#${themeColour}`}})
+            closeButton.innerHTML = window.i18n.SUBMIT
+            const inputElem = createElem("input", {type: "text", value: message.value})
+            modal.appendChild(createElem("div", inputElem))
+            modal.appendChild(createElem("div", closeButton))
+
+            closeButton.addEventListener("click", () => {
+                closeModal(modalContainer).then(() => {
+                    resolve(inputElem.value)
+                })
+            })
+        } else {
+            modal.appendChild(createElem("div.spinner", {style: {borderLeftColor: document.querySelector("button").style.background}}))
+        }
+
+        modalContainer.appendChild(modal)
+        modalContainer.style.opacity = 0
+        modalContainer.style.display = "flex"
+
+        requestAnimationFrame(() => requestAnimationFrame(() => modalContainer.style.opacity = 1))
+        requestAnimationFrame(() => requestAnimationFrame(() => chromeBar.style.opacity = 1))
+    })
+}
+window.closeModal = (container=undefined, notThisOne=undefined, skipIfErrorOpen=false) => {
+    return new Promise(resolve => {
+        if (window.errorModalHasOpened && skipIfErrorOpen) {
+            return resolve()
+        }
+        window.errorModalHasOpened = false
+        const allContainers = [batchGenerationContainer, gameSelectionContainer, updatesContainer, infoContainer, settingsContainer, patreonContainer, pluginsContainer, modalContainer, nexusContainer, embeddingsContainer, totdContainer, nexusReposContainer, EULAContainer, arpabetContainer, styleEmbeddingsContainer, workbenchContainer]
+        const containers = container==undefined ? allContainers : (Array.isArray(container) ? container.filter(c=>c!=undefined) : [container])
+
+        notThisOne = Array.isArray(notThisOne) ? notThisOne : (notThisOne==undefined ? [] : [notThisOne])
+
+        containers.forEach(cont => {
+            // Fade out the containers except the exceptions
+            if (cont!=undefined && !notThisOne.includes(cont)) {
+                cont.style.opacity = 0
+            }
+        })
+
+        const someOpenContainer = allContainers.filter(c=>c!=undefined).find(cont => cont.style.opacity==1 && cont.style.display!="none" && cont!=modalContainer)
+        if (!someOpenContainer || someOpenContainer==container) {
+            chromeBar.style.opacity = 0.88
+        }
+
+        setTimeout(() => {
+            if (window.errorModalHasOpened && skipIfErrorOpen) {
+            } else {
+                containers.forEach(cont => {
+                    // Hide the containers except the exceptions
+                    if (cont!=undefined && !notThisOne.includes(cont)) {
+                        cont.style.display = "none"
+                        const someOpenContainer2 = allContainers.filter(c=>c!=undefined).find(cont => cont.style.opacity==1 && cont.style.display!="none" && cont!=modalContainer)
+                        if (!someOpenContainer2 || someOpenContainer2==container) {
+                            chromeBar.style.opacity = 0.88
+                        }
+                    }
+                })
+                window.errorModalHasOpened = false
+            }
+            // resolve()
+        }, 200)
+        try {
+            activeModal.remove()
+        } catch (e) {}
+        resolve()
+    })
+}
+
+
+window.setTheme = (meta) => {
+
+    const primaryColour = meta.themeColourPrimary
+    const secondaryColour = meta.themeColourSecondary
+    const gameName = meta.gameName
+
+    if (window.userSettings.showDiscordStatus) {
+        ipcRenderer.send('updateDiscord', {details: gameName})
+    }
+
+    // Change batch panel colours, if it is initialized
+    try {
+        Array.from(batchRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(pluginsRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(styleembsRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(nexusRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(nexusSearchHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(nexusReposUsedHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(embeddingsRecordsHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        Array.from(arpabetWordsListHeader.children).forEach(item => item.style.backgroundColor = `#${primaryColour}`)
+    } catch (e) {}
+    try {
+        window.sequenceEditor.grabbers.forEach(grabber => grabber.fillStyle = `#${primaryColour}`)
+        window.sequenceEditor.energyGrabbers.forEach(grabber => grabber.fillStyle = `#${primaryColour}`)
+    } catch (e) {}
+
+    const background = `linear-gradient(0deg, rgba(128,128,128,${window.userSettings.bg_gradient_opacity}) 0px, rgba(0,0,0,0)), url("assets/${meta.assetFile}")`
+    Array.from(document.querySelectorAll("button:not(.fixedColour)")).forEach(e => e.style.background = `#${primaryColour}`)
+    Array.from(document.querySelectorAll(".voiceType")).forEach(e => e.style.background = `#${primaryColour}`)
+    Array.from(document.querySelectorAll(".spinner")).forEach(e => e.style.borderLeftColor = `#${primaryColour}`)
+    Array.from(document.querySelectorAll(".checkbox")).forEach(e => e.style.accentColor = `#${primaryColour}`)
+    Array.from(document.querySelectorAll(".input[type=range]")).forEach(e => e.style.accentColor = `#${primaryColour}`)
+
+    if (secondaryColour) {
+        Array.from(document.querySelectorAll("button:not(.fixedColour)")).forEach(e => e.style.color = `#${secondaryColour}`)
+        Array.from(document.querySelectorAll(".voiceType")).forEach(e => e.style.color = `#${secondaryColour}`)
+        Array.from(document.querySelectorAll("button")).forEach(e => e.style.textShadow  = `none`)
+        Array.from(document.querySelectorAll(".voiceType")).forEach(e => e.style.textShadow  = `none`)
+    } else {
+        Array.from(document.querySelectorAll("button:not(.fixedColour)")).forEach(e => e.style.color = `white`)
+        Array.from(document.querySelectorAll(".voiceType")).forEach(e => e.style.color = `white`)
+        Array.from(document.querySelectorAll("button")).forEach(e => e.style.textShadow = `0 0 2px black`)
+        Array.from(document.querySelectorAll(".voiceType")).forEach(e => e.style.textShadow = `0 0 2px black`)
+    }
+
+    if (window.wavesurfer) {
+        window.wavesurfer.setWaveColor(`#${window.currentGame.themeColourPrimary}`)
+    }
+
+    // Fade the background image transition
+    rightBG1.style.background = background
+    rightBG2.style.opacity = 0
+    setTimeout(() => {
+        rightBG2.style.background = rightBG1.style.background
+        rightBG2.style.opacity = 1
+    }, 1000)
+
+    cssHack.innerHTML = `::selection {
+        background: #${primaryColour};
+    }
+    ::-webkit-scrollbar-thumb {
+        background-color: #${primaryColour} !important;
+    }
+    .slider::-webkit-slider-thumb {
+        background-color: #${primaryColour} !important;
+    }
+    input[type=checkbox], input[type=range] {accent-color: #${primaryColour} !important;}
+    a {color: #${primaryColour}};
+    #batchRecordsHeader > div {background-color: #${primaryColour} !important;}
+    #pluginsRecordsHeader > div {background-color: #${primaryColour} !important;}
+
+    .invertedButton {
+       background: none !important;
+       border: 2px solid #${primaryColour} !important;
+    }
+
+    `
+    if (secondaryColour) {
+        cssHack.innerHTML += `
+            #batchRecordsHeader > div {color: #${secondaryColour} !important;text-shadow: none}
+            #pluginsRecordsHeader > div {color: #${secondaryColour} !important;text-shadow: none}
+        `
+    } else {
+        cssHack.innerHTML += `
+            #batchRecordsHeader > div {color: white !important;text-shadow: 0 0 2px black;}
+            #pluginsRecordsHeader > div {color: white !important;text-shadow: 0 0 2px black;}
+        `
+    }
+}
+
+window.getAudioPlayTriangleSVG = () => {
+    const div = createElem("div", `<svg class="renameSVG" version="1.0" xmlns="http://www.w3.org/2000/svg" width="770.000000pt" height="980.000000pt" viewBox="0 0 770.000000 980.000000"
+ preserveAspectRatio="xMidYMid meet"><g transform="translate(0.000000,980.000000) scale(0.100000,-0.100000)"fill="#555555" stroke="none">
+        <path d="M26 9718 c-3 -46 -9 -2249 -12 -4897 -5 -4085 -4 -4813 8 -4809 8 3
+        389 244 848 535 459 291 1598 1013 2530 1603 2872 1819 3648 2311 4182 2656
+        60 38 108 75 108 81 0 55 -595 448 -2855 1886 -1259 801 -4552 2877 -4792
+        3020 -8 5 -13 -16 -17 -75z"/>
+        </g>
+        </svg>`)
+    return div
+}
+
+
+window.addEventListener("resize", e => {
+    window.userSettings.customWindowSize = `${window.innerHeight},${window.innerWidth}`
+    saveUserSettings()
+})
+
+// Keyboard actions
+// ================
+window.addEventListener("keyup", event => {
+    if (!event.ctrlKey) {
+        window.ctrlKeyIsPressed = false
+    }
+    if (!event.shiftKey) {
+        window.shiftKeyIsPressed = false
+    }
+})
+
+dialogueInput.addEventListener("keydown", event => {
+    if (event.target==dialogueInput || event.target==letterPitchNumb || event.target==letterLengthNumb) {
+        // Enter: Generate sample
+        if (event.key=="Enter") {
+            generateVoiceButton.click()
+            event.preventDefault()
+        }
+        return
+    }
+})
+
+window.addEventListener("click", event => {
+    if (event.target.id!="dialogueInput") {
+        window.hideAutocomplete()
+    }
+})
+
+window.addEventListener("keydown", event => {
+
+    if (event.ctrlKey) {
+        window.ctrlKeyIsPressed = true
+    }
+    if (event.shiftKey) {
+        window.shiftKeyIsPressed = true
+    }
+
+    if (event.ctrlKey && event.key.toLowerCase()=="r") {
+        location.reload()
+    }
+
+    if (event.ctrlKey && event.shiftKey && event.key.toLowerCase()=="i") {
+        window.electron = require("electron")
+        er.BrowserWindow.getFocusedWindow().webContents.openDevTools()
+        return
+    }
+
+    if (event.ctrlKey) {
+        window.ctrlKeyIsPressed = true
+    }
+
+    // Re-gen the line if the user presses CTRL-ENTER, evne outside the prompt box
+    if (event.key=="Enter" && window.ctrlKeyIsPressed) {
+        generateVoiceButton.click()
+    }
+    // The Enter key to submit text input prompts in modals
+    if (event.key=="Enter" && modalContainer.style.display!="none" && event.target.tagName=="INPUT") {
+        activeModal.querySelector("button").click()
+    }
+    const key = event.key.toLowerCase()
+
+    // CTRL-S: Keep sample
+    if (key=="s" && event.ctrlKey && !event.shiftKey) {
+        keepSampleFunction(false)
+    }
+    // CTRL-SHIFT-S: Keep sample (but with rename prompt)
+    if (key=="s" && event.ctrlKey && event.shiftKey) {
+        keepSampleFunction(true)
+    }
+
+    // Disable keyboard controls while in a text input
+    if (event.target.tagName=="INPUT" && event.target.tagName!=dialogueInput || event.target.tagName=="TEXTAREA") {
+        return
+    }
+
+    if (event.target==dialogueInput || event.target==letterPitchNumb || event.target==letterLengthNumb) {
+        // Enter: Generate sample
+        if (event.key=="Enter") {
+            generateVoiceButton.click()
+            event.preventDefault()
+        }
+        return
+    }
+
+    // Escape: close modals
+    if (key=="escape") {
+        closeModal()
+    }
+    // Space: bring focus to the input textarea
+    if (key==" ") {
+        setTimeout(() => dialogueInput.focus(), 0)
+    }
+    // Create selection for all of the editor letters
+    if (key=="a" && event.ctrlKey && !event.shiftKey) {
+        window.sequenceEditor.letterFocus = []
+        window.sequenceEditor.sliderBoxes.forEach((_,i) => {
+            window.sequenceEditor.letterFocus.push(i)
+            window.sequenceEditor.setLetterFocus(i, true)
+        })
+        event.preventDefault()
+        return
+    }
+    // Y/N for prompt modals
+    if (key=="y" || key=="n" || key==" ") {
+        if (document.querySelector("#activeModal")) {
+            const buttons = Array.from(document.querySelector("#activeModal").querySelectorAll("button"))
+            const yesBtn = buttons.find(btn => btn.innerHTML.toLowerCase()=="yes")
+            const noBtn = buttons.find(btn => btn.innerHTML.toLowerCase()=="no")
+            if (key=="y") yesBtn.click()
+            if (key==" ") yesBtn.click()
+            if (key=="n") noBtn.click()
+        }
+    }
+    // Left/Right arrows: Move between letter focused (clears multi-select, picks the min(0,first-1) if left, max($L, last+1) if right)
+    // SHIFT-Left/Right: multi-letter create selection range
+    if ((key=="arrowleft" || key=="arrowright") && !event.ctrlKey) {
+        event.preventDefault()
+        if (window.sequenceEditor.letterFocus.length==0) {
+            window.sequenceEditor.setLetterFocus(0)
+        } else if (window.sequenceEditor.letterFocus.length==1) {
+            const curr_l = window.sequenceEditor.letterFocus[0]
+            const newIndex = key=="arrowleft" ? Math.max(0, curr_l-1) : Math.min(curr_l+1, window.sequenceEditor.letters.length-1)
+            window.sequenceEditor.setLetterFocus(newIndex, event.shiftKey)
+        } else {
+            if (key=="arrowleft") {
+                window.sequenceEditor.setLetterFocus(Math.max(0, Math.min(...window.sequenceEditor.letterFocus)-1), event.shiftKey)
+            } else {
+                window.sequenceEditor.setLetterFocus(Math.min(Math.max(...window.sequenceEditor.letterFocus)+1, window.sequenceEditor.letters.length-1), event.shiftKey)
+            }
+        }
+    }
+
+    // Up/Down arrows: Move pitch up/down for the letter(s) selected
+    if ((key=="arrowup" || key=="arrowdown") && !event.ctrlKey) {
+        event.preventDefault()
+        if (window.sequenceEditor.letterFocus.length) {
+            window.sequenceEditor.letterFocus.forEach(li => {
+                window.sequenceEditor.pitchNew[li] += (key=="arrowup" ? 0.1 : -0.1)
+                window.sequenceEditor.grabbers[li].setValueFromValue(window.sequenceEditor.pitchNew[li])
+                window.sequenceEditor.hasChanged = true
+            })
+            if (window.sequenceEditor.autoInferTimer != null) {
+                clearTimeout(window.sequenceEditor.autoInferTimer)
+                window.sequenceEditor.autoInferTimer = null
+            }
+            if (autoplay_ckbx.checked) {
+                window.sequenceEditor.autoInferTimer = setTimeout(infer, 500)
+            }
+
+            if (window.sequenceEditor.letterFocus.length==1) {
+                letterPitchNumb.value = window.sequenceEditor.pitchNew[window.sequenceEditor.letterFocus[0]]
+            }
+        }
+    }
+
+    // CTRL+Left/Right arrows: change the sequence-wide pacing
+    if ((key=="arrowleft" || key=="arrowright") && event.ctrlKey) {
+        if (event.altKey) {
+            window.sequenceEditor.letterFocus.forEach(li => {
+                window.sequenceEditor.dursNew[li] = window.sequenceEditor.dursNew[li] + (key=="arrowleft"? -0.1 : 0.1)
+                window.sequenceEditor.hasChanged = true
+            })
+            if (window.sequenceEditor.autoInferTimer != null) {
+                clearTimeout(window.sequenceEditor.autoInferTimer)
+                window.sequenceEditor.autoInferTimer = null
+            }
+            if (autoplay_ckbx.checked) {
+                window.sequenceEditor.autoInferTimer = setTimeout(infer, 500)
+            }
+            window.sequenceEditor.sliderBoxes.forEach((box, i) => box.setValueFromValue(window.sequenceEditor.dursNew[i]))
+
+            if (window.sequenceEditor.letterFocus.length==1) {
+                letterLengthNumb.value = parseInt(window.sequenceEditor.dursNew[window.sequenceEditor.letterFocus[0]]*100)/100
+            }
+        } else {
+            pace_slid.value = parseFloat(pace_slid.value) + (key=="arrowleft"? -0.01 : 0.01)
+            paceNumbInput.value = pace_slid.value
+            const new_lengths = window.sequenceEditor.dursNew.map((v,l) => v * pace_slid.value)
+            window.sequenceEditor.sliderBoxes.forEach((box, i) => box.setValueFromValue(window.sequenceEditor.dursNew[i]))
+            window.sequenceEditor.pacing = parseFloat(pace_slid.value)
+            window.sequenceEditor.init()
+
+        }
+    }
+
+    // CTRL+Up/Down arrows: increase/decrease buttons
+    if (key=="arrowup" && event.ctrlKey && !event.shiftKey) {
+        increase_btn.click()
+    }
+    if (key=="arrowdown" && event.ctrlKey && !event.shiftKey) {
+        decrease_btn.click()
+    }
+    // CTRL+SHIFT+Up/Down arrows: amplify/flatten buttons
+    if (key=="arrowup" && event.ctrlKey && event.shiftKey) {
+        amplify_btn.click()
+    }
+    if (key=="arrowdown" && event.ctrlKey && event.shiftKey) {
+        flatten_btn.click()
+    }
+})
+
+
+
+window.setupModal = (openingButton, modalContainerElem, callback, exitCallback) => {
+    if (openingButton) {
+        openingButton.addEventListener("click", () => {
+            closeModal(undefined, modalContainerElem).then(() => {
+                modalContainerElem.style.opacity = 0
+                modalContainerElem.style.display = "flex"
+                requestAnimationFrame(() => requestAnimationFrame(() => {
+                    modalContainerElem.style.opacity = 1
+                    chromeBar.style.opacity = 1
+                    requestAnimationFrame(() => {
+                        setTimeout(() => {
+                            if (callback) {
+                                callback()
+                            }
+                        }, 250)
+                    })
+                }))
+            })
+        })
+    }
+    modalContainerElem.addEventListener("click", event => {
+        if (event.target==modalContainerElem) {
+            if (exitCallback) {
+                exitCallback()
+            }
+            window.closeModal(modalContainerElem)
+        }
+    })
+}
+
+window.checkVersionRequirements = (requirements, appVersion, checkMax=false) => {
+
+    if (!requirements) {
+        return true
+    }
+
+    const appVersionRequirement = requirements.toString().split(".").map(v=>parseInt(v))
+    const appVersionInts = appVersion.replace("v", "").split(".").map(v=>parseInt(v))
+    let appVersionOk = true
+
+    if (checkMax) {
+
+        if (appVersionRequirement[0] >= appVersionInts[0] ) {
+            if (appVersionRequirement.length>1 && parseInt(appVersionRequirement[0]) == appVersionInts[0]) {
+                if (appVersionRequirement[1] >= appVersionInts[1] ) {
+                    if (appVersionRequirement.length>2 && parseInt(appVersionRequirement[1]) == appVersionInts[1]) {
+                        if (appVersionRequirement[2] >= appVersionInts[2] ) {
+                        } else {
+                            appVersionOk = false
+                        }
+                    }
+                } else {
+                    appVersionOk = false
+                }
+            }
+        } else {
+            appVersionOk = false
+        }
+
+
+    } else {
+        if (appVersionRequirement[0] <= appVersionInts[0] ) {
+            if (appVersionRequirement.length>1 && parseInt(appVersionRequirement[0]) == appVersionInts[0]) {
+                if (appVersionRequirement[1] <= appVersionInts[1] ) {
+                    if (appVersionRequirement.length>2 && parseInt(appVersionRequirement[1]) == appVersionInts[1]) {
+                        if (appVersionRequirement[2] <= appVersionInts[2] ) {
+                        } else {
+                            appVersionOk = false
+                        }
+                    }
+                } else {
+                    appVersionOk = false
+                }
+            }
+        } else {
+            appVersionOk = false
+        }
+    }
+    return appVersionOk
+}
+
+
+// https://stackoverflow.com/questions/18052762/remove-directory-which-is-not-empty
+const path = require('path')
+window.deleteFolderRecursive = function (directoryPath, keepRoot=false) {
+if (fs.existsSync(directoryPath)) {
+    fs.readdirSync(directoryPath).forEach((file, index) => {
+      const curPath = path.join(directoryPath, file);
+      if (fs.lstatSync(curPath).isDirectory()) {
+       // recurse
+        window.deleteFolderRecursive(curPath);
+      } else {
+        // delete file
+        fs.unlinkSync(curPath);
+      }
+    });
+    if (!keepRoot) {
+        fs.rmdirSync(directoryPath);
+    }
+  }
+};
+
+window.createFolderRecursive = (pathToMake) => {
+    console.log("createFolderRecursive", pathToMake)
+    pathToMake.split('/').reduce((directories, directory) => {
+        directories += `${directory}/`
+
+        if (!fs.existsSync(directories)) {
+          fs.mkdirSync(directories)
+        }
+
+        return directories
+      }, '')
+}
+
+window.uuidv4 = () => {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+        var r = Math.random() * 16 | 0, v = c == 'x' ? r : (r & 0x3 | 0x8)
+        return v.toString(16)
+    })
+}
+
+// https://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
+window.shuffle = (array) => {
+    var currentIndex = array.length,  randomIndex;
+
+    // While there remain elements to shuffle...
+    while (0 !== currentIndex) {
+
+        // Pick a remaining element...
+        randomIndex = Math.floor(Math.random() * currentIndex);
+        currentIndex--;
+
+        // And swap it with the current element.
+        [array[currentIndex], array[randomIndex]] = [
+          array[randomIndex], array[currentIndex]];
+    }
+
+    return array;
+}
+
+
+// Just for easier packaging of the voice models for publishing - yes, lazy
+window.packageVoice_variantIndex = 0
+window.packageVoice = (doVoicePreviewCreate, variants, {modelsPath, gameId}={}) => {
+
+    const {voiceId, hifi} = variants[window.packageVoice_variantIndex]
+
+    if (doVoicePreviewCreate) {
+        const files = fs.readdirSync(`./output`).filter(fname => fname.includes("temp-") && fname.includes(".wav"))
+        if (files.length) {
+            const options = {
+                hz: window.userSettings.audio.hz,
+                padStart: window.userSettings.audio.padStart,
+                padEnd: window.userSettings.audio.padEnd,
+                bit_depth: window.userSettings.audio.bitdepth,
+                amplitude: window.userSettings.audio.amplitude,
+                pitchMult: window.userSettings.audio.pitchMult,
+                tempo: window.userSettings.audio.tempo
+            }
+
+            doFetch(`http://localhost:8008/outputAudio`, {
+                method: "Post",
+                body: JSON.stringify({
+                    input_path: `./output/${files[0]}`,
+                    isBatchMode: false,
+                    output_path: `${modelsPath}/${voiceId}_raw.wav`,
+                    options: JSON.stringify(options)
+                })
+            }).then(r=>r.text()).then(() => {
+                try {
+                    fs.unlinkSync(`${modelsPath}/${voiceId}.wav`)
+                } catch (e) {}
+                doFetch(`http://localhost:8008/normalizeAudio`, {
+                    method: "Post",
+                    body: JSON.stringify({
+                        input_path: `${modelsPath}/${voiceId}_raw.wav`,
+                        output_path: `${modelsPath}/${voiceId}.wav`
+                    })
+                }).then(r=>r.text()).then((resp) => {
+                    console.log(resp)
+                    fs.unlinkSync(`${modelsPath}/${voiceId}_raw.wav`)
+                })
+            })
+        }
+    } else {
+        fs.mkdirSync(`./build/${voiceId}`)
+        fs.mkdirSync(`./build/${voiceId}/resources`)
+        fs.mkdirSync(`./build/${voiceId}/resources/app`)
+        fs.mkdirSync(`./build/${voiceId}/resources/app/models`)
+        fs.mkdirSync(`./build/${voiceId}/resources/app/models/${gameId}`)
+        fs.copyFileSync(`${modelsPath}/${voiceId}.json`, `./build/${voiceId}/resources/app/models/${gameId}/${voiceId}.json`)
+        fs.copyFileSync(`${modelsPath}/${voiceId}.wav`, `./build/${voiceId}/resources/app/models/${gameId}/${voiceId}.wav`)
+        fs.copyFileSync(`${modelsPath}/${voiceId}.pt`, `./build/${voiceId}/resources/app/models/${gameId}/${voiceId}.pt`)
+        // if (hifi) {
+        //     fs.copyFileSync(`${modelsPath}/${voiceId}.hg.pt`, `./build/${voiceId}/resources/app/models/${gameId}/${voiceId}.hg.pt`)
+        // }
+        zipdir(`./build/${voiceId}`, {saveTo: `./build/${voiceId}.zip`}, (err, buffer) => deleteFolderRecursive(`./build/${voiceId}`))
+    }
+}
+
+
+const assetFiles = fs.readdirSync(`${window.path}/assets`)
+const jsonFiles = fs.readdirSync(`${window.path}/assets`).filter(fn => fn.endsWith(".json"))
+const missingAssetFiles = jsonFiles.filter(jsonFile => !(assetFiles.includes(jsonFile.replace(".json", ".png"))||assetFiles.includes(jsonFile.replace(".json", ".jpg"))) )
+if (missingAssetFiles.length) {
+    noAssetFilesFoundMessage.style.display = "block"
+    assetDirLink.addEventListener("click", () => {
+        // shell.showItemInFolder((require("path")).resolve(`${window.path}/assets/other.jpg`))
+        er.shell.showItemInFolder((require("path")).resolve(`${window.path}/assets/other.jpg`))
+        spawn(`explorer`, [(require("path")).resolve(`${window.path}/assets`)], {stdio: "ignore"})
+    })
+}
+
+
+window.getSpeakerEmbeddingFromFilePath = (filePath) => {
+    spinnerModal(`${window.i18n.GETTING_SPEAKER_EMBEDDING}`)
+
+    return new Promise(resolve => {
+        doFetch(`http://localhost:8008/getWavV3StyleEmb`, {
+            method: "Post",
+            body: JSON.stringify({wav_path: filePath})
+        }).then(r=>r.text()).then(v => {
+            closeModal(undefined, [styleEmbeddingsContainer, workbenchContainer])
+            if (v=="ENOENT") {
+                window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}<br><br>ENOENT`)
+            } else {
+                resolve(v)
+            }
+        }).catch(() => {
+            window.errorModal(`${window.i18n.SOMETHING_WENT_WRONG}`)
+        })
+    })
+}
+
+window.unzipFileTo = (zipPath, outputFolder) => {
+    return fs.createReadStream(zipPath).pipe(unzipper.Parse()).on("entry", entry => {
+        const fileName = entry.path
+        const dirOrFile = entry.type
+
+        if (/\/$/.test(fileName)) { // It's a directory
+            return
+        }
+
+        let fileContainerFolderPath = fileName.split("/").reverse()
+        const justFileName = fileContainerFolderPath[0]
+
+        entry.pipe(fs.createWriteStream(`${outputFolder}/${justFileName}`))
+    })
+    .promise()
+}

javascript/workbench.js

@@ -0,0 +1,497 @@
+"use strict"
+const er = require('@electron/remote')
+const dialog = er.dialog
+
+
+window.voiceWorkbenchState = {
+    isInit: false,
+    isStarted: false,
+    currentAudioFilePath: undefined,
+    newAudioFilePath: undefined,
+    currentEmb: undefined,
+    refAEmb: undefined,
+    refBEmb: undefined,
+}
+
+window.initVoiceWorkbench = () => {
+    if (!window.voiceWorkbenchState.isInit) {
+        window.voiceWorkbenchState.isInit = true
+        window.refreshExistingCraftedVoices()
+        window.initDropdowns()
+        voiceWorkbenchLanguageDropdown.value = "en"
+    }
+    window.refreshExistingCraftedVoices()
+}
+
+window.refreshExistingCraftedVoices = () => {
+    voiceWorkbenchVoicesList.innerHTML = ""
+    Object.keys(window.games).sort((a,b)=>a>b?1:-1).forEach(gameId => {
+        if (Object.keys(window.gameAssets).includes(gameId)) {
+            const themeColour = window.gameAssets[gameId].themeColourPrimary
+            window.games[gameId].models.forEach(model => {
+                if (model.embOverABaseModel) {
+                    const button = createElem("div.voiceType", model.voiceName)
+                    button.style.background = `#${themeColour}`
+                    button.addEventListener("click", () => window.voiceWorkbenchLoadOrResetCraftedVoice(model))
+                    voiceWorkbenchVoicesList.appendChild(button)
+                }
+            })
+        }
+    })
+}
+
+window.voiceWorkbenchLoadOrResetCraftedVoice = (model) => {
+
+    voiceWorkbenchModelDropdown.value = model ? model.embOverABaseModel : "<base>/base_v1.0"
+    voiceWorkbenchVoiceNameInput.value = model ? model.voiceName : ""
+    voiceWorkbenchVoiceIDInput.value = model ? model.variants[0].voiceId : ""
+    voiceWorkbenchGenderDropdown.value = model ? model.variants[0].gender : "male"
+    voiceWorkbenchAuthorInput.value = model ? (model.variants[0].author || "Anonymous") : ""
+    voiceWorkbenchLanguageDropdown.value = model ? model.variants[0].lang : "en"
+    voiceWorkbenchGamesDropdown.value = model ? model.gameId : "other"
+    voiceWorkbenchCurrentEmbeddingInput.value = model ? model.variants[0].base_speaker_emb : ""
+    window.voiceWorkbenchState.currentEmb = model ? model.variants[0].base_speaker_emb : undefined
+
+    window.voiceWorkbenchState.currentAudioFilePath = undefined
+    window.voiceWorkbenchState.newAudioFilePath = undefined
+    window.voiceWorkbenchState.refAEmb = undefined
+    window.voiceWorkbenchState.refBEmb = undefined
+
+    voiceWorkbenchRefAInput.value = ""
+    voiceWorkbenchRefBInput.value = ""
+
+    if (model) {
+        voiceWorkbenchDeleteButton.disabled = false
+        voiceWorkbenchStartButton.click()
+    }
+}
+
+window.voiceWorkbenchGenerateVoice = async () => {
+
+    if (!voiceWorkbenchCurrentEmbeddingInput.value.length) {
+        return window.errorModal(window.i18n.ENTER_VOICE_CRAFTING_STARTING_EMB)
+    }
+
+    // Load the model if it hasn't been loaded already
+    let voiceId = voiceWorkbenchModelDropdown.value.split("/").at(-1)
+    if (!window.currentModel || window.currentModel.voiceId!=voiceId) {
+        let modelPath
+        if (voiceId.includes("Base xVAPitch Model")) {
+            modelPath = `${window.path}/python/xvapitch/base_v1.0.pt`
+        } else {
+            const gameId = voiceWorkbenchModelDropdown.value.split("/").at(0)
+            modelPath = window.userSettings[`modelspath_${gameId}`]+"/"+voiceId
+        }
+        await window.voiceWorkbenchChangeModel(modelPath, voiceId)
+    }
+
+    const base_lang = voiceWorkbenchLanguageDropdown.value//voiceId.includes("Base xVAPitch Model") ? "en" : window.currentModel.lang
+    let newEmb = undefined
+
+    // const currentEmbedding = voiceWorkbenchCurrentEmbeddingInput.value.split(",").map(v=>parseFloat(v))
+    const currentEmbedding = window.voiceWorkbenchState.currentEmb
+    // const currentDelta = voiceWorkbenchCurrentDeltaInput.value.split(",").map(v=>parseFloat(v))
+    const newEmbedding = window.getVoiceWorkbenchNewEmbedding()
+
+    const tempFileNum = `${Math.random().toString().split(".")[1]}`
+    const currentTempFileLocation = `${path}/output/temp-${tempFileNum}_current.wav`
+    const newTempFileLocation = `${path}/output/temp-${tempFileNum}_new.wav`
+
+    // Do the current embedding first
+    const synthRequests = []
+    synthRequests.push(doSynth(JSON.stringify({
+            sequence: voiceWorkbenchInputTextArea.value.trim(),
+            useCleanup: true, // TODO, user setting?
+            base_lang, base_emb: currentEmbedding.join(","), outfile: currentTempFileLocation
+        })))
+    let doingNewAudioFile = false
+    if (voiceWorkbenchCurrentDeltaInput.value.length) {
+        doingNewAudioFile = true
+        synthRequests.push(doSynth(JSON.stringify({
+            sequence: voiceWorkbenchInputTextArea.value.trim(),
+            useCleanup: true, // TODO, user setting?
+            base_lang, base_emb: newEmbedding.join(","), outfile: newTempFileLocation
+        })))
+    }
+
+    // toggleSpinnerButtons()
+    spinnerModal(`${window.i18n.SYNTHESIZING}`)
+    Promise.all(synthRequests).then(res => {
+        closeModal(undefined, [workbenchContainer])
+        window.voiceWorkbenchState.currentAudioFilePath = currentTempFileLocation
+        voiceWorkbenchAudioCurrentPlayPauseBtn.disabled = false
+        voiceWorkbenchAudioCurrentSaveBtn.disabled = false
+
+        if (doingNewAudioFile) {
+            window.voiceWorkbenchState.newAudioFilePath = newTempFileLocation
+            voiceWorkbenchAudioNewPlayBtn.disabled = false
+            voiceWorkbenchAudioNewSaveBtn.disabled = false
+        }
+    })
+}
+const doSynth = (body) => {
+    return new Promise(resolve => {
+        doFetch("http://localhost:8008/synthesizeSimple", {
+            method: "Post",
+            body
+        }).then(r=>r.text()).then(resolve)
+    })
+}
+
+window.getVoiceWorkbenchNewEmbedding = () => {
+    const currentDelta = voiceWorkbenchCurrentDeltaInput.value.split(",").map(v=>parseFloat(v))
+    const newEmb = window.voiceWorkbenchState.currentEmb.map((v,vi) => {
+        return v + currentDelta[vi]//*strength
+    })
+    return newEmb
+}
+
+window.voiceWorkbenchChangeModel = (modelPath, voiceId) => {
+    window.currentModel = {
+        outputs: undefined,
+        model: modelPath.replace(".pt", ""),
+        modelType: "xVAPitch",
+        base_lang: voiceWorkbenchLanguageDropdown.value,
+        isBaseModel: true,
+        voiceId: voiceId
+    }
+    generateVoiceButton.dataset.modelQuery = JSON.stringify(window.currentModel)
+    return window.loadModel()
+}
+voiceWorkbenchGenerateSampleButton.addEventListener("click", window.voiceWorkbenchGenerateVoice)
+
+
+window.initDropdowns = () => {
+    // Games dropdown
+    Object.keys(window.games).sort((a,b)=>a>b?1:-1).forEach(gameId => {
+        if (gameId!="other") {
+            if (Object.keys(window.gameAssets).includes(gameId)) {
+                const gameName = window.games[gameId].gameTheme.gameName
+                const option = createElem("option", gameName)
+                option.value = gameId
+                voiceWorkbenchGamesDropdown.appendChild(option)
+            }
+        }
+    })
+
+    // Models dropdown
+    Object.keys(window.games).forEach(gameId => {
+        if (window.games[gameId].gameTheme) {
+            const gameName = window.games[gameId].gameTheme.gameName
+            window.games[gameId].models.forEach(modelMeta => {
+                const voiceName = modelMeta.voiceName
+                const voiceId = modelMeta.variants[0].voiceId
+
+                // Variants are not supported by v3 models, so pick the first one only. Also, filter out crafted voices
+                if (modelMeta.variants[0].modelType=="xVAPitch" && !modelMeta.embOverABaseModel) {
+
+                    const option = createElem("option", `[${gameName}] ${voiceName}`)
+                    option.value = `${gameId}/${voiceId}`
+                    voiceWorkbenchModelDropdown.appendChild(option)
+                }
+            })
+        }
+    })
+}
+
+// Change the available languages when the model is changed
+voiceWorkbenchModelDropdown.addEventListener("change", () => {
+    let voiceId = voiceWorkbenchModelDropdown.value.split("/").at(-1)
+    if (voiceId.includes("base_v1.0")) {
+        window.populateLanguagesDropdownsFromModel(voiceWorkbenchLanguageDropdown)
+        voiceWorkbenchLanguageDropdown.value = "en"
+    } else {
+        const gameId = voiceWorkbenchModelDropdown.value.split("/")[0]
+        if (Object.keys(window.games).includes(gameId)) {
+            const baseModelData = window.games[gameId].models.filter(model => {
+                return model.variants[0].voiceId == voiceWorkbenchModelDropdown.value.split("/").at(-1)
+            })[0]
+            window.populateLanguagesDropdownsFromModel(voiceWorkbenchLanguageDropdown, baseModelData)
+            voiceWorkbenchLanguageDropdown.value = baseModelData.variants[0].lang
+        }
+    }
+})
+
+voiceWorkbenchStartButton.addEventListener("click", () => {
+    window.voiceWorkbenchState.isStarted = true
+
+    voiceWorkbenchLoadedContent.style.display = "flex"
+    voiceWorkbenchLoadedContent2.style.display = "flex"
+    voiceWorkbenchStartButton.style.display = "none"
+
+
+    // Load the base model's embedding as a starting point, if it's not the built-in base model
+    let voiceId = voiceWorkbenchModelDropdown.value.split("/").at(-1)
+    if (voiceId.includes("base_v1.0")) {
+    } else {
+        const gameId = voiceWorkbenchModelDropdown.value.split("/")[0]
+        if (Object.keys(window.games).includes(gameId)) {
+            const baseModelData = window.games[gameId].models.filter(model => {
+                return model.variants[0].voiceId == voiceWorkbenchModelDropdown.value.split("/").at(-1)
+            })[0]
+            voiceWorkbenchCurrentEmbeddingInput.value = baseModelData.variants[0].base_speaker_emb.join(",")
+            window.voiceWorkbenchState.currentEmb = baseModelData.variants[0].base_speaker_emb
+        }
+    }
+})
+
+window.setupVoiceWorkbenchDropArea = (container, inputField, callback=undefined) => {
+    const dropFn = (eType, event) => {
+        if (["dragenter", "dragover"].includes(eType)) {
+            container.style.background = "#5b5b5b"
+            container.style.color = "white"
+        }
+        if (["dragleave", "drop"].includes(eType)) {
+            container.style.background = "rgba(0,0,0,0)"
+            container.style.color = "white"
+        }
+
+        event.preventDefault()
+        event.stopPropagation()
+
+        const dataLines = []
+
+        if (eType=="drop") {
+            const dataTransfer = event.dataTransfer
+            const files = Array.from(dataTransfer.files)
+
+            if (files[0].path.endsWith(".wav")) {
+                const filePath = String(files[0].path).replaceAll(/\\/g, "/")
+                console.log("filePath", filePath)
+                window.getSpeakerEmbeddingFromFilePath(filePath).then(embedding => {
+                    inputField.value = embedding
+                    if (callback) {
+                        callback(filePath)
+                    }
+                })
+            } else {
+                window.errorModal(window.i18n.ERROR_FILE_MUST_BE_WAV)
+            }
+        }
+    }
+
+    container.addEventListener("dragenter", event => dropFn("dragenter", event), false)
+    container.addEventListener("dragleave", event => dropFn("dragleave", event), false)
+    container.addEventListener("dragover", event => dropFn("dragover", event), false)
+    container.addEventListener("drop", event => dropFn("drop", event), false)
+}
+
+window.setupVoiceWorkbenchDropArea(voiceWorkbenchCurrentEmbeddingDropzone, voiceWorkbenchCurrentEmbeddingInput, () => {
+    window.voiceWorkbenchState.currentEmb = voiceWorkbenchCurrentEmbeddingInput.value.split(",").map(v=>parseFloat(v))
+})
+voiceWorkbenchCurrentEmbeddingInput.addEventListener("change", ()=>{
+    window.voiceWorkbenchState.currentEmb = voiceWorkbenchCurrentEmbeddingInput.value.split(",").map(v=>parseFloat(v))
+})
+window.setupVoiceWorkbenchDropArea(voiceWorkbenchRefADropzone, voiceWorkbenchRefAInput, (filePath) => {
+    voiceWorkbenchRefAFilePath.innerHTML = window.i18n.FROM_FILE_IS_FILEPATH.replace("_1", filePath)
+    voiceWorkshopApplyDeltaButton.disabled = false
+    window.voiceWorkbenchState.refAEmb = voiceWorkbenchRefAInput.value.split(",").map(v=>parseFloat(v))
+    window.voiceWorkbenchUpdateDelta()
+})
+window.setupVoiceWorkbenchDropArea(voiceWorkbenchRefBDropzone, voiceWorkbenchRefBInput, (filePath) => {
+    voiceWorkbenchRefBFilePath.innerHTML = window.i18n.FROM_FILE_IS_FILEPATH.replace("_1", filePath)
+    window.voiceWorkbenchState.refBEmb = voiceWorkbenchRefBInput.value.split(",").map(v=>parseFloat(v))
+    window.voiceWorkbenchUpdateDelta()
+})
+
+voiceWorkbenchInputTextArea.addEventListener("keyup", () => {
+    voiceWorkbenchGenerateSampleButton.disabled = voiceWorkbenchInputTextArea.value.trim().length==0
+})
+voiceWorkbenchAudioCurrentPlayPauseBtn.addEventListener("click", () => {
+    const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+        src: window.voiceWorkbenchState.currentAudioFilePath
+    }))
+    audioPreview.setSinkId(window.userSettings.base_speaker)
+})
+voiceWorkbenchAudioCurrentSaveBtn.addEventListener("click", async () => {
+    const userChosenPath = await dialog.showSaveDialog({ defaultPath: window.voiceWorkbenchState.currentAudioFilePath })
+    if (userChosenPath && userChosenPath.filePath) {
+        const outFilePath = userChosenPath.filePath.split(".").at(-1)=="wav" ? userChosenPath.filePath : userChosenPath.filePath+".wav"
+        fs.copyFileSync(window.voiceWorkbenchState.currentAudioFilePath, outFilePath)
+    }
+})
+voiceWorkbenchAudioNewPlayBtn.addEventListener("click", () => {
+    const audioPreview = createElem("audio", {autoplay: false}, createElem("source", {
+        src: window.voiceWorkbenchState.newAudioFilePath
+    }))
+    audioPreview.setSinkId(window.userSettings.base_speaker)
+})
+voiceWorkbenchAudioNewSaveBtn.addEventListener("click", async () => {
+    const userChosenPath = await dialog.showSaveDialog({ defaultPath: window.voiceWorkbenchState.newAudioFilePath })
+    if (userChosenPath && userChosenPath.filePath) {
+        const outFilePath = userChosenPath.filePath.split(".").at(-1)=="wav" ? userChosenPath.filePath : userChosenPath.filePath+".wav"
+        fs.copyFileSync(window.voiceWorkbenchState.newAudioFilePath, outFilePath)
+    }
+})
+
+window.voiceWorkbenchUpdateDelta = () => {
+    // Don't do anything if reference file A isn't given
+    if (!window.voiceWorkbenchState.refAEmb) {
+        return
+    }
+
+    const strengthValue = parseFloat(voiceWorkbenchStrengthInput.value)
+
+    let delta
+
+    // When only Ref A is used, the delta is from <current> towards the first reference file A
+    if (window.voiceWorkbenchState.refBEmb == undefined) {
+        delta = window.voiceWorkbenchState.currentEmb.map((v,vi) => {
+            return (window.voiceWorkbenchState.refAEmb[vi] - v) * strengthValue
+        })
+    } else {
+        // When Ref B is also used, the delta is from ref A to ref B
+        delta = window.voiceWorkbenchState.refAEmb.map((v,vi) => {
+            return (window.voiceWorkbenchState.refBEmb[vi] - v) * strengthValue
+        })
+    }
+
+    voiceWorkbenchCurrentDeltaInput.value = delta.join(",")
+}
+
+voiceWorkbenchStrengthSlider.addEventListener("change", () => {
+    voiceWorkbenchStrengthInput.value = voiceWorkbenchStrengthSlider.value
+    window.voiceWorkbenchUpdateDelta()
+})
+voiceWorkbenchStrengthInput.addEventListener("change", () => {
+    voiceWorkbenchStrengthSlider.value = voiceWorkbenchStrengthInput.value
+    window.voiceWorkbenchUpdateDelta()
+})
+voiceWorkshopApplyDeltaButton.addEventListener("click", () => {
+    if (voiceWorkbenchCurrentDeltaInput.value.length) {
+        const newEmb = window.getVoiceWorkbenchNewEmbedding()
+        window.voiceWorkbenchState.currentEmb = newEmb
+        voiceWorkbenchCurrentEmbeddingInput.value = newEmb.join(",")
+        voiceWorkbenchCurrentDeltaInput.value = ""
+        voiceWorkshopApplyDeltaButton.disabled = true
+        voiceWorkbenchRefAInput.value = ""
+        window.voiceWorkbenchState.refAEmb = undefined
+        voiceWorkbenchRefBInput.value = ""
+        window.voiceWorkbenchState.refBEmb = undefined
+    }
+})
+
+/*
+Drop file A over the reference audio file A area, to get its embedding
+    When only the reference A file is used, the current delta is this embedding multiplied by the strength
+
+Drop file B over the B area, to get a second embedding
+    When both this and A are active, the current delta is the direction from A to B, multiplied by the strength
+        direction meaning B minus A, instead of <current> minus A
+*/
+
+voiceWorkbenchSaveButton.addEventListener("click", () => {
+
+    const voiceName = voiceWorkbenchVoiceNameInput.value
+    const voiceId = voiceWorkbenchVoiceIDInput.value
+    const gender = voiceWorkbenchGenderDropdown.value
+    const author = voiceWorkbenchAuthorInput.value || "Anonymous"
+    const lang = voiceWorkbenchLanguageDropdown.value
+
+
+    if (!voiceName.trim().length) {
+        return window.errorModal(window.i18n.ENTER_VOICE_NAME)
+    }
+    if (!voiceId.trim().length) {
+        return window.errorModal(window.i18n.ENTER_VOICE_ID)
+    }
+
+    const modelJson = {
+        "version": "3.0",
+        "modelVersion": "3.0",
+        "modelType": "xVAPitch",
+        "author": author,
+        "lang": lang,
+        "embOverABaseModel": voiceWorkbenchModelDropdown.value,
+        "games": [
+            {
+                "gameId": voiceWorkbenchGamesDropdown.value,
+                "voiceId": voiceId,
+                "variant": "Default",
+                "voiceName": voiceName,
+                "base_speaker_emb": window.voiceWorkbenchState.currentEmb,
+                "gender": gender
+            }
+        ]
+    }
+    const gameModelsPath = `${window.userSettings[`modelspath_${voiceWorkbenchGamesDropdown.value}`]}`
+
+    const jsonDestination = `${gameModelsPath}/${voiceId}.json`
+    fs.writeFileSync(jsonDestination, JSON.stringify(modelJson, null, 4))
+
+    doSynth(JSON.stringify({
+        sequence: " This is what my voice sounds like. ",
+        useCleanup: true, // TODO, user setting?
+        base_lang: lang,
+        base_emb: window.voiceWorkbenchState.currentEmb.join(","), outfile: jsonDestination.replace(".json", ".wav")
+    })).then(() => {
+        voiceWorkbenchDeleteButton.disabled = false
+        window.currentModel = undefined
+        generateVoiceButton.dataset.modelQuery = null
+        window.infoModal(window.i18n.VOICE_CREATED_AT.replace("_1", jsonDestination))
+
+        // Clean up the temp file from the clean-up post-processing, if it exists
+        if (fs.existsSync(jsonDestination.replace(".json", "_preCleanup.wav"))) {
+            fs.unlinkSync(jsonDestination.replace(".json", "_preCleanup.wav"))
+        }
+
+        window.loadAllModels().then(() => {
+            window.refreshExistingCraftedVoices()
+
+            // Refresh the main page voice models if the same game is loaded as the target game models directory as saved into
+            if (window.currentGame.gameId==voiceWorkbenchGamesDropdown.value) {
+                window.changeGame(window.currentGame)
+                window.refreshExistingCraftedVoices()
+            }
+        })
+    })
+})
+
+voiceWorkbenchGamesDropdown.addEventListener("change", () => {
+    const gameModelsPath = `${window.userSettings[`modelspath_${voiceWorkbenchGamesDropdown.value}`]}`
+    const voiceId = voiceWorkbenchVoiceIDInput.value
+    const jsonLocation = `${gameModelsPath}/${voiceId}.json`
+    voiceWorkbenchDeleteButton.disabled = !fs.existsSync(jsonLocation)
+})
+voiceWorkbenchVoiceIDInput.addEventListener("change", () => {
+    const gameModelsPath = `${window.userSettings[`modelspath_${voiceWorkbenchGamesDropdown.value}`]}`
+    const voiceId = voiceWorkbenchVoiceIDInput.value
+    const jsonLocation = `${gameModelsPath}/${voiceId}.json`
+    voiceWorkbenchDeleteButton.disabled = !fs.existsSync(jsonLocation)
+})
+voiceWorkbenchDeleteButton.addEventListener("click", () => {
+    const gameModelsPath = `${window.userSettings[`modelspath_${voiceWorkbenchGamesDropdown.value}`]}`
+    const voiceId = voiceWorkbenchVoiceIDInput.value
+    const jsonLocation = `${gameModelsPath}/${voiceId}.json`
+    window.confirmModal(window.i18n.CONFIRM_DELETE_CRAFTED_VOICE.replace("_1", voiceWorkbenchVoiceNameInput.value).replace("_2", jsonLocation)).then(resp => {
+        if (resp) {
+            if (fs.existsSync(jsonLocation.replace(".json", ".wav"))) {
+                fs.unlinkSync(jsonLocation.replace(".json", ".wav"))
+            }
+            fs.unlinkSync(jsonLocation)
+        }
+        window.infoModal(window.i18n.SUCCESSFULLY_DELETED_CRAFTED_VOICE)
+        window.loadAllModels().then(() => {
+
+            // Refresh the main page voice models if the same game is loaded as the target game models directory deleted from
+            if (window.currentGame.gameId==voiceWorkbenchGamesDropdown.value) {
+
+                window.changeGame(window.currentGame)
+                window.refreshExistingCraftedVoices()
+            }
+            voiceWorkbenchCancelButton.click()
+        })
+    })
+})
+
+
+
+voiceWorkbenchCancelButton.addEventListener("click", () => {
+    window.voiceWorkbenchState.isStarted = false
+
+    voiceWorkbenchLoadedContent.style.display = "none"
+    voiceWorkbenchLoadedContent2.style.display = "none"
+    voiceWorkbenchStartButton.style.display = "flex"
+
+    window.voiceWorkbenchLoadOrResetCraftedVoice()
+})

lib/AbortControllerPolyfill.js

@@ -0,0 +1,4 @@
+/* Polyfill service v3.105.0
+ * Disable minification (remove `.min` from URL path) for more info */
+
+(function(self, undefined) {!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e(t.WHATWGFetch={})}(this,function(t){"use strict";function e(t){return t&&DataView.prototype.isPrototypeOf(t)}function r(t){if("string"!=typeof t&&(t=String(t)),/[^a-z0-9\-#$%&'*+.^_`|~]/i.test(t))throw new TypeError("Invalid character in header field name");return t.toLowerCase()}function o(t){return"string"!=typeof t&&(t=String(t)),t}function n(t){var e={next:function(){var e=t.shift();return{done:e===undefined,value:e}}};return v.iterable&&(e[Symbol.iterator]=function(){return e}),e}function i(t){this.map={},t instanceof i?t.forEach(function(t,e){this.append(e,t)},this):Array.isArray(t)?t.forEach(function(t){this.append(t[0],t[1])},this):t&&Object.getOwnPropertyNames(t).forEach(function(e){this.append(e,t[e])},this)}function s(t){if(t.bodyUsed)return Promise.reject(new TypeError("Already read"));t.bodyUsed=!0}function a(t){return new Promise(function(e,r){t.onload=function(){e(t.result)},t.onerror=function(){r(t.error)}})}function f(t){var e=new FileReader,r=a(e);return e.readAsArrayBuffer(t),r}function u(t){var e=new FileReader,r=a(e);return e.readAsText(t),r}function h(t){for(var e=new Uint8Array(t),r=new Array(e.length),o=0;o<e.length;o++)r[o]=String.fromCharCode(e[o]);return r.join("")}function d(t){if(t.slice)return t.slice(0);var e=new Uint8Array(t.byteLength);return e.set(new Uint8Array(t)),e.buffer}function c(){return this.bodyUsed=!1,this._initBody=function(t){this._bodyInit=t,t?"string"==typeof t?this._bodyText=t:v.blob&&Blob.prototype.isPrototypeOf(t)?this._bodyBlob=t:v.formData&&FormData.prototype.isPrototypeOf(t)?this._bodyFormData=t:v.searchParams&&URLSearchParams.prototype.isPrototypeOf(t)?this._bodyText=t.toString():v.arrayBuffer&&v.blob&&e(t)?(this._bodyArrayBuffer=d(t.buffer),this._bodyInit=new Blob([this._bodyArrayBuffer])):v.arrayBuffer&&(ArrayBuffer.prototype.isPrototypeOf(t)||A(t))?this._bodyArrayBuffer=d(t):this._bodyText=t=Object.prototype.toString.call(t):this._bodyText="",this.headers.get("content-type")||("string"==typeof t?this.headers.set("content-type","text/plain;charset=UTF-8"):this._bodyBlob&&this._bodyBlob.type?this.headers.set("content-type",this._bodyBlob.type):v.searchParams&&URLSearchParams.prototype.isPrototypeOf(t)&&this.headers.set("content-type","application/x-www-form-urlencoded;charset=UTF-8"))},v.blob&&(this.blob=function(){var t=s(this);if(t)return t;if(this._bodyBlob)return Promise.resolve(this._bodyBlob);if(this._bodyArrayBuffer)return Promise.resolve(new Blob([this._bodyArrayBuffer]));if(this._bodyFormData)throw new Error("could not read FormData body as blob");return Promise.resolve(new Blob([this._bodyText]))},this.arrayBuffer=function(){return this._bodyArrayBuffer?s(this)||Promise.resolve(this._bodyArrayBuffer):this.blob().then(f)}),this.text=function(){var t=s(this);if(t)return t;if(this._bodyBlob)return u(this._bodyBlob);if(this._bodyArrayBuffer)return Promise.resolve(h(this._bodyArrayBuffer));if(this._bodyFormData)throw new Error("could not read FormData body as text");return Promise.resolve(this._bodyText)},v.formData&&(this.formData=function(){return this.text().then(l)}),this.json=function(){return this.text().then(JSON.parse)},this}function y(t){var e=t.toUpperCase();return _.indexOf(e)>-1?e:t}function p(t,e){e=e||{};var r=e.body;if(t instanceof p){if(t.bodyUsed)throw new TypeError("Already read");this.url=t.url,this.credentials=t.credentials,e.headers||(this.headers=new i(t.headers)),this.method=t.method,this.mode=t.mode,this.signal=t.signal,r||null==t._bodyInit||(r=t._bodyInit,t.bodyUsed=!0)}else this.url=String(t);if(this.credentials=e.credentials||this.credentials||"same-origin",!e.headers&&this.headers||(this.headers=new i(e.headers)),this.method=y(e.method||this.method||"GET"),this.mode=e.mode||this.mode||null,this.signal=e.signal||this.signal,this.referrer=null,("GET"===this.method||"HEAD"===this.method)&&r)throw new TypeError("Body not allowed for GET or HEAD requests");this._initBody(r)}function l(t){var e=new FormData;return t.trim().split("&").forEach(function(t){if(t){var r=t.split("="),o=r.shift().replace(/\+/g," "),n=r.join("=").replace(/\+/g," ");e.append(decodeURIComponent(o),decodeURIComponent(n))}}),e}function b(t){var e=new i;return t.replace(/\r?\n[\t ]+/g," ").split(/\r?\n/).forEach(function(t){var r=t.split(":"),o=r.shift().trim();if(o){var n=r.join(":").trim();e.append(o,n)}}),e}function m(t,e){e||(e={}),this.type="default",this.status=e.status===undefined?200:e.status,this.ok=this.status>=200&&this.status<300,this.statusText="statusText"in e?e.statusText:"OK",this.headers=new i(e.headers),this.url=e.url||"",this._initBody(t)}function w(e,r){return new Promise(function(o,n){function i(){a.abort()}var s=new p(e,r);if(s.signal&&s.signal.aborted)return n(new t.DOMException("Aborted","AbortError"));var a=new XMLHttpRequest;a.onload=function(){var t={status:a.status,statusText:a.statusText,headers:b(a.getAllResponseHeaders()||"")};t.url="responseURL"in a?a.responseURL:t.headers.get("X-Request-URL");var e="response"in a?a.response:a.responseText;o(new m(e,t))},a.onerror=function(){n(new TypeError("Network request failed"))},a.ontimeout=function(){n(new TypeError("Network request failed"))},a.onabort=function(){n(new t.DOMException("Aborted","AbortError"))},a.open(s.method,s.url,!0),"include"===s.credentials?a.withCredentials=!0:"omit"===s.credentials&&(a.withCredentials=!1),"responseType"in a&&v.blob&&(a.responseType="blob"),s.headers.forEach(function(t,e){a.setRequestHeader(e,t)}),s.signal&&(s.signal.addEventListener("abort",i),a.onreadystatechange=function(){4===a.readyState&&s.signal.removeEventListener("abort",i)}),a.send("undefined"==typeof s._bodyInit?null:s._bodyInit)})}var v={searchParams:"URLSearchParams"in self,iterable:"Symbol"in self&&"iterator"in Symbol,blob:"FileReader"in self&&"Blob"in self&&function(){try{return new Blob,!0}catch(t){return!1}}(),formData:"FormData"in self,arrayBuffer:"ArrayBuffer"in self};if(v.arrayBuffer)var E=["[object Int8Array]","[object Uint8Array]","[object Uint8ClampedArray]","[object Int16Array]","[object Uint16Array]","[object Int32Array]","[object Uint32Array]","[object Float32Array]","[object Float64Array]"],A=ArrayBuffer.isView||function(t){return t&&E.indexOf(Object.prototype.toString.call(t))>-1};i.prototype.append=function(t,e){t=r(t),e=o(e);var n=this.map[t];this.map[t]=n?n+", "+e:e},i.prototype["delete"]=function(t){delete this.map[r(t)]},i.prototype.get=function(t){return t=r(t),this.has(t)?this.map[t]:null},i.prototype.has=function(t){return this.map.hasOwnProperty(r(t))},i.prototype.set=function(t,e){this.map[r(t)]=o(e)},i.prototype.forEach=function(t,e){for(var r in this.map)this.map.hasOwnProperty(r)&&t.call(e,this.map[r],r,this)},i.prototype.keys=function(){var t=[];return this.forEach(function(e,r){t.push(r)}),n(t)},i.prototype.values=function(){var t=[];return this.forEach(function(e){t.push(e)}),n(t)},i.prototype.entries=function(){var t=[];return this.forEach(function(e,r){t.push([r,e])}),n(t)},v.iterable&&(i.prototype[Symbol.iterator]=i.prototype.entries);var _=["DELETE","GET","HEAD","OPTIONS","POST","PUT"];p.prototype.clone=function(){return new p(this,{body:this._bodyInit})},c.call(p.prototype),c.call(m.prototype),m.prototype.clone=function(){return new m(this._bodyInit,{status:this.status,statusText:this.statusText,headers:new i(this.headers),url:this.url})},m.error=function(){var t=new m(null,{status:0,statusText:""});return t.type="error",t};var x=[301,302,303,307,308];m.redirect=function(t,e){if(-1===x.indexOf(e))throw new RangeError("Invalid status code");return new m(null,{status:e,headers:{location:t}})},t.DOMException=self.DOMException;try{new t.DOMException}catch(g){t.DOMException=function(t,e){this.message=t,this.name=e;var r=Error(t);this.stack=r.stack},t.DOMException.prototype=Object.create(Error.prototype),t.DOMException.prototype.constructor=t.DOMException}w.polyfill=!0,self.fetch=w,self.Headers=i,self.Request=p,self.Response=m,t.Headers=i,t.Request=p,t.Response=m,t.fetch=w,Object.defineProperty(t,"__esModule",{value:!0})});!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):(e=e||self,t(e.AbortControllerShim={}))}(this,function(e){"use strict";function t(e){return(t="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(e){return typeof e}:function(e){return e&&"function"==typeof Symbol&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e})(e)}function n(e,t){if(!(e instanceof t))throw new TypeError("Cannot call a class as a function")}function o(e,t){for(var n,o=0;o<t.length;o++)n=t[o],n.enumerable=n.enumerable||!1,n.configurable=!0,"value"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}function r(e,t,n){return t&&o(e.prototype,t),n&&o(e,n),e}function i(e,t){if("function"!=typeof t&&null!==t)throw new TypeError("Super expression must either be null or a function");e.prototype=Object.create(t&&t.prototype,{constructor:{value:e,writable:!0,configurable:!0}}),t&&c(e,t)}function u(e){return(u=Object.setPrototypeOf?Object.getPrototypeOf:function(e){return e.__proto__||Object.getPrototypeOf(e)})(e)}function c(e,t){return(c=Object.setPrototypeOf||function(e,t){return e.__proto__=t,e})(e,t)}function l(e){if(void 0===e)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return e}function f(e,t){return!t||"object"!=typeof t&&"function"!=typeof t?l(e):t}function a(e){var t=C.get(e);return console.assert(null!=t,"'this' is expected an Event object, but got",e),t}function p(e){return null==e.passiveListener?void(!e.event.cancelable||(e.canceled=!0,"function"==typeof e.event.preventDefault&&e.event.preventDefault())):void("undefined"!=typeof console&&"function"==typeof console.error&&console.error("Unable to preventDefault inside passive event listener invocation.",e.passiveListener))}function s(e,t){C.set(this,{eventTarget:e,event:t,eventPhase:2,currentTarget:e,canceled:!1,stopped:!1,immediateStopped:!1,passiveListener:null,timeStamp:t.timeStamp||Date.now()}),Object.defineProperty(this,"isTrusted",{value:!1,enumerable:!0});for(var n,o=Object.keys(t),r=0;r<o.length;++r)(n=o[r])in this||Object.defineProperty(this,n,b(n))}function b(e){return{get:function(){return a(this).event[e]},set:function(t){a(this).event[e]=t},configurable:!0,enumerable:!0}}function y(e){return{value:function(){var t=a(this).event;return t[e].apply(t,arguments)},configurable:!0,enumerable:!0}}function v(e,t){function n(t,n){e.call(this,t,n)}var o=Object.keys(t);if(0===o.length)return e;n.prototype=Object.create(e.prototype,{constructor:{value:n,configurable:!0,writable:!0}});for(var r,i=0;i<o.length;++i)if(!((r=o[i])in e.prototype)){var u=Object.getOwnPropertyDescriptor(t,r),c="function"==typeof u.value;Object.defineProperty(n.prototype,r,c?y(r):b(r))}return n}function d(e){if(null==e||e===Object.prototype)return s;var t=M.get(e);return null==t&&(t=v(d(Object.getPrototypeOf(e)),e),M.set(e,t)),t}function g(e,t){return new(d(Object.getPrototypeOf(t)))(e,t)}function h(e){return a(e).immediateStopped}function j(e,t){a(e).eventPhase=t}function O(e,t){a(e).currentTarget=t}function m(e,t){a(e).passiveListener=t}function w(e){return null!==e&&"object"===t(e)}function P(e){var t=D.get(e);if(null==t)throw new TypeError("'this' is expected an EventTarget object, but got another value.");return t}function T(e){return{get:function(){for(var t=P(this),n=t.get(e);null!=n;){if(3===n.listenerType)return n.listener;n=n.next}return null},set:function(t){"function"==typeof t||w(t)||(t=null);for(var n=P(this),o=null,r=n.get(e);null!=r;)3===r.listenerType?null===o?null===r.next?n["delete"](e):n.set(e,r.next):o.next=r.next:o=r,r=r.next;if(null!==t){var i={listener:t,listenerType:3,passive:!1,once:!1,next:null};null===o?n.set(e,i):o.next=i}},configurable:!0,enumerable:!0}}function x(e,t){Object.defineProperty(e,"on".concat(t),T(t))}function S(e){function t(){E.call(this)}t.prototype=Object.create(E.prototype,{constructor:{value:t,configurable:!0,writable:!0}});for(var n=0;n<e.length;++n)x(t.prototype,e[n]);return t}function E(){if(this instanceof E)return void D.set(this,new Map);if(1===arguments.length&&Array.isArray(arguments[0]))return S(arguments[0]);if(0<arguments.length){for(var e=Array(arguments.length),t=0;t<arguments.length;++t)e[t]=arguments[t];return S(e)}throw new TypeError("Cannot call a class as a function")}function A(){var e=Object.create(L.prototype);return E.call(e),W.set(e,!1),e}function k(e){!1!==W.get(e)||(W.set(e,!0),e.dispatchEvent({type:"abort"}))}function _(e){var n=B.get(e);if(null==n)throw new TypeError("Expected 'this' to be an 'AbortController' object, but got ".concat(null===e?"null":t(e)));return n}var C=new WeakMap,M=new WeakMap;s.prototype={get type(){return a(this).event.type},get target(){return a(this).eventTarget},get currentTarget(){return a(this).currentTarget},composedPath:function(){var e=a(this).currentTarget;return null==e?[]:[e]},get NONE(){return 0},get CAPTURING_PHASE(){return 1},get AT_TARGET(){return 2},get BUBBLING_PHASE(){return 3},get eventPhase(){return a(this).eventPhase},stopPropagation:function(){var e=a(this);e.stopped=!0,"function"==typeof e.event.stopPropagation&&e.event.stopPropagation()},stopImmediatePropagation:function(){var e=a(this);e.stopped=!0,e.immediateStopped=!0,"function"==typeof e.event.stopImmediatePropagation&&e.event.stopImmediatePropagation()},get bubbles(){return!!a(this).event.bubbles},get cancelable(){return!!a(this).event.cancelable},preventDefault:function(){p(a(this))},get defaultPrevented(){return a(this).canceled},get composed(){return!!a(this).event.composed},get timeStamp(){return a(this).timeStamp},get srcElement(){return a(this).eventTarget},get cancelBubble(){return a(this).stopped},set cancelBubble(e){if(e){var t=a(this);t.stopped=!0,"boolean"==typeof t.event.cancelBubble&&(t.event.cancelBubble=!0)}},get returnValue(){return!a(this).canceled},set returnValue(e){e||p(a(this))},initEvent:function(){}},Object.defineProperty(s.prototype,"constructor",{value:s,configurable:!0,writable:!0}),"undefined"!=typeof window&&"undefined"!=typeof window.Event&&(Object.setPrototypeOf(s.prototype,window.Event.prototype),M.set(window.Event.prototype,s));var D=new WeakMap;E.prototype={addEventListener:function(e,t,n){if(null!=t){if("function"!=typeof t&&!w(t))throw new TypeError("'listener' should be a function or an object.");var o=P(this),r=w(n),i=r?!!n.capture:!!n,u=i?1:2,c={listener:t,listenerType:u,passive:r&&!!n.passive,once:r&&!!n.once,next:null},l=o.get(e);if(void 0===l)return void o.set(e,c);for(var f=null;null!=l;){if(l.listener===t&&l.listenerType===u)return;f=l,l=l.next}f.next=c}},removeEventListener:function(e,t,n){if(null!=t)for(var o=P(this),r=w(n)?!!n.capture:!!n,i=r?1:2,u=null,c=o.get(e);null!=c;){if(c.listener===t&&c.listenerType===i)return void(null===u?null===c.next?o["delete"](e):o.set(e,c.next):u.next=c.next);u=c,c=c.next}},dispatchEvent:function(e){if(null==e||"string"!=typeof e.type)throw new TypeError('"event.type" should be a string.');var t=P(this),n=e.type,o=t.get(n);if(null==o)return!0;for(var r=g(this,e),i=null;null!=o;){if(o.once?null===i?null===o.next?t["delete"](n):t.set(n,o.next):i.next=o.next:i=o,m(r,o.passive?o.listener:null),"function"==typeof o.listener)try{o.listener.call(this,r)}catch(e){"undefined"!=typeof console&&"function"==typeof console.error&&console.error(e)}else 3!==o.listenerType&&"function"==typeof o.listener.handleEvent&&o.listener.handleEvent(r);if(h(r))break;o=o.next}return m(r,null),j(r,0),O(r,null),!r.defaultPrevented}},Object.defineProperty(E.prototype,"constructor",{value:E,configurable:!0,writable:!0}),"undefined"!=typeof window&&"undefined"!=typeof window.EventTarget&&Object.setPrototypeOf(E.prototype,window.EventTarget.prototype);var L=function(e){function o(){throw n(this,o),f(this,u(o).call(this)),new TypeError("AbortSignal cannot be constructed directly")}return i(o,e),r(o,[{key:"aborted",get:function(){var e=W.get(this);if("boolean"!=typeof e)throw new TypeError("Expected 'this' to be an 'AbortSignal' object, but got ".concat(null===this?"null":t(this)));return e}}]),o}(E);x(L.prototype,"abort");var W=new WeakMap;Object.defineProperties(L.prototype,{aborted:{enumerable:!0}}),"function"==typeof Symbol&&"symbol"===t(Symbol.toStringTag)&&Object.defineProperty(L.prototype,Symbol.toStringTag,{configurable:!0,value:"AbortSignal"});var I=function(){function e(){n(this,e),B.set(this,A())}return r(e,[{key:"abort",value:function(){k(_(this))}},{key:"signal",get:function(){return _(this)}}]),e}(),B=new WeakMap;if(Object.defineProperties(I.prototype,{signal:{enumerable:!0},abort:{enumerable:!0}}),"function"==typeof Symbol&&"symbol"===t(Symbol.toStringTag)&&Object.defineProperty(I.prototype,Symbol.toStringTag,{configurable:!0,value:"AbortController"}),e.AbortController=I,e.AbortSignal=L,e["default"]=I,Object.defineProperty(e,"__esModule",{value:!0}),"undefined"==typeof module&&"undefined"==typeof define){var F=Function("return this")();"undefined"==typeof F.AbortController&&(F.AbortController=I,F.AbortSignal=L)}});})('object' === typeof window && window || 'object' === typeof self && self || 'object' === typeof global && global || {});

lib/OrbitControls.js

@@ -0,0 +1,1102 @@
+( function () {
+
+	// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+	//
+	//    Orbit - left mouse / touch: one-finger move
+	//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+	//    Pan - right mouse, or left mouse + ctrl/meta/shiftKey, or arrow keys / touch: two-finger move
+
+	const _changeEvent = {
+		type: 'change'
+	};
+	const _startEvent = {
+		type: 'start'
+	};
+	const _endEvent = {
+		type: 'end'
+	};
+
+	class OrbitControls extends THREE.EventDispatcher {
+
+		constructor( object, domElement ) {
+
+			super();
+			if ( domElement === undefined ) console.warn( 'THREE.OrbitControls: The second parameter "domElement" is now mandatory.' );
+			if ( domElement === document ) console.error( 'THREE.OrbitControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.' );
+			this.object = object;
+			this.domElement = domElement;
+			this.domElement.style.touchAction = 'none'; // disable touch scroll
+			// Set to false to disable this control
+
+			this.enabled = true; // "target" sets the location of focus, where the object orbits around
+
+			this.target = new THREE.Vector3(); // How far you can dolly in and out ( PerspectiveCamera only )
+
+			this.minDistance = 0;
+			this.maxDistance = Infinity; // How far you can zoom in and out ( OrthographicCamera only )
+
+			this.minZoom = 0;
+			this.maxZoom = Infinity; // How far you can orbit vertically, upper and lower limits.
+			// Range is 0 to Math.PI radians.
+
+			this.minPolarAngle = 0; // radians
+
+			this.maxPolarAngle = Math.PI; // radians
+			// How far you can orbit horizontally, upper and lower limits.
+			// If set, the interval [ min, max ] must be a sub-interval of [ - 2 PI, 2 PI ], with ( max - min < 2 PI )
+
+			this.minAzimuthAngle = - Infinity; // radians
+
+			this.maxAzimuthAngle = Infinity; // radians
+			// Set to true to enable damping (inertia)
+			// If damping is enabled, you must call controls.update() in your animation loop
+
+			this.enableDamping = false;
+			this.dampingFactor = 0.05; // This option actually enables dollying in and out; left as "zoom" for backwards compatibility.
+			// Set to false to disable zooming
+
+			this.enableZoom = true;
+			this.zoomSpeed = 1.0; // Set to false to disable rotating
+
+			this.enableRotate = true;
+			this.rotateSpeed = 1.0; // Set to false to disable panning
+
+			this.enablePan = true;
+			this.panSpeed = 1.0;
+			this.screenSpacePanning = true; // if false, pan orthogonal to world-space direction camera.up
+
+			this.keyPanSpeed = 7.0; // pixels moved per arrow key push
+			// Set to true to automatically rotate around the target
+			// If auto-rotate is enabled, you must call controls.update() in your animation loop
+
+			this.autoRotate = false;
+			this.autoRotateSpeed = 2.0; // 30 seconds per orbit when fps is 60
+			// The four arrow keys
+
+			this.keys = {
+				LEFT: 'ArrowLeft',
+				UP: 'ArrowUp',
+				RIGHT: 'ArrowRight',
+				BOTTOM: 'ArrowDown'
+			}; // Mouse buttons
+
+			this.mouseButtons = {
+				LEFT: THREE.MOUSE.ROTATE,
+				MIDDLE: THREE.MOUSE.DOLLY,
+				RIGHT: THREE.MOUSE.PAN
+			}; // Touch fingers
+
+			this.touches = {
+				ONE: THREE.TOUCH.ROTATE,
+				TWO: THREE.TOUCH.DOLLY_PAN
+			}; // for reset
+
+			this.target0 = this.target.clone();
+			this.position0 = this.object.position.clone();
+			this.zoom0 = this.object.zoom; // the target DOM element for key events
+
+			this._domElementKeyEvents = null; //
+			// public methods
+			//
+
+			this.getPolarAngle = function () {
+
+				return spherical.phi;
+
+			};
+
+			this.getAzimuthalAngle = function () {
+
+				return spherical.theta;
+
+			};
+
+			this.listenToKeyEvents = function ( domElement ) {
+
+				domElement.addEventListener( 'keydown', onKeyDown );
+				this._domElementKeyEvents = domElement;
+
+			};
+
+			this.saveState = function () {
+
+				scope.target0.copy( scope.target );
+				scope.position0.copy( scope.object.position );
+				scope.zoom0 = scope.object.zoom;
+
+			};
+
+			this.reset = function () {
+
+				scope.target.copy( scope.target0 );
+				scope.object.position.copy( scope.position0 );
+				scope.object.zoom = scope.zoom0;
+				scope.object.updateProjectionMatrix();
+				scope.dispatchEvent( _changeEvent );
+				scope.update();
+				state = STATE.NONE;
+
+			}; // this method is exposed, but perhaps it would be better if we can make it private...
+
+
+			this.update = function () {
+
+				const offset = new THREE.Vector3(); // so camera.up is the orbit axis
+
+				const quat = new THREE.Quaternion().setFromUnitVectors( object.up, new THREE.Vector3( 0, 1, 0 ) );
+				const quatInverse = quat.clone().invert();
+				const lastPosition = new THREE.Vector3();
+				const lastQuaternion = new THREE.Quaternion();
+				const twoPI = 2 * Math.PI;
+				return function update() {
+
+					const position = scope.object.position;
+					offset.copy( position ).sub( scope.target ); // rotate offset to "y-axis-is-up" space
+
+					offset.applyQuaternion( quat ); // angle from z-axis around y-axis
+
+					spherical.setFromVector3( offset );
+
+					if ( scope.autoRotate && state === STATE.NONE ) {
+
+						rotateLeft( getAutoRotationAngle() );
+
+					}
+
+					if ( scope.enableDamping ) {
+
+						spherical.theta += sphericalDelta.theta * scope.dampingFactor;
+						spherical.phi += sphericalDelta.phi * scope.dampingFactor;
+
+					} else {
+
+						spherical.theta += sphericalDelta.theta;
+						spherical.phi += sphericalDelta.phi;
+
+					} // restrict theta to be between desired limits
+
+
+					let min = scope.minAzimuthAngle;
+					let max = scope.maxAzimuthAngle;
+
+					if ( isFinite( min ) && isFinite( max ) ) {
+
+						if ( min < - Math.PI ) min += twoPI; else if ( min > Math.PI ) min -= twoPI;
+						if ( max < - Math.PI ) max += twoPI; else if ( max > Math.PI ) max -= twoPI;
+
+						if ( min <= max ) {
+
+							spherical.theta = Math.max( min, Math.min( max, spherical.theta ) );
+
+						} else {
+
+							spherical.theta = spherical.theta > ( min + max ) / 2 ? Math.max( min, spherical.theta ) : Math.min( max, spherical.theta );
+
+						}
+
+					} // restrict phi to be between desired limits
+
+
+					spherical.phi = Math.max( scope.minPolarAngle, Math.min( scope.maxPolarAngle, spherical.phi ) );
+					spherical.makeSafe();
+					spherical.radius *= scale; // restrict radius to be between desired limits
+
+					spherical.radius = Math.max( scope.minDistance, Math.min( scope.maxDistance, spherical.radius ) ); // move target to panned location
+
+					if ( scope.enableDamping === true ) {
+
+						scope.target.addScaledVector( panOffset, scope.dampingFactor );
+
+					} else {
+
+						scope.target.add( panOffset );
+
+					}
+
+					offset.setFromSpherical( spherical ); // rotate offset back to "camera-up-vector-is-up" space
+
+					offset.applyQuaternion( quatInverse );
+					position.copy( scope.target ).add( offset );
+					scope.object.lookAt( scope.target );
+
+					if ( scope.enableDamping === true ) {
+
+						sphericalDelta.theta *= 1 - scope.dampingFactor;
+						sphericalDelta.phi *= 1 - scope.dampingFactor;
+						panOffset.multiplyScalar( 1 - scope.dampingFactor );
+
+					} else {
+
+						sphericalDelta.set( 0, 0, 0 );
+						panOffset.set( 0, 0, 0 );
+
+					}
+
+					scale = 1; // update condition is:
+					// min(camera displacement, camera rotation in radians)^2 > EPS
+					// using small-angle approximation cos(x/2) = 1 - x^2 / 8
+
+					if ( zoomChanged || lastPosition.distanceToSquared( scope.object.position ) > EPS || 8 * ( 1 - lastQuaternion.dot( scope.object.quaternion ) ) > EPS ) {
+
+						scope.dispatchEvent( _changeEvent );
+						lastPosition.copy( scope.object.position );
+						lastQuaternion.copy( scope.object.quaternion );
+						zoomChanged = false;
+						return true;
+
+					}
+
+					return false;
+
+				};
+
+			}();
+
+			this.dispose = function () {
+
+				scope.domElement.removeEventListener( 'contextmenu', onContextMenu );
+				scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
+				scope.domElement.removeEventListener( 'pointercancel', onPointerCancel );
+				scope.domElement.removeEventListener( 'wheel', onMouseWheel );
+				scope.domElement.ownerDocument.removeEventListener( 'pointermove', onPointerMove );
+				scope.domElement.ownerDocument.removeEventListener( 'pointerup', onPointerUp );
+
+				if ( scope._domElementKeyEvents !== null ) {
+
+					scope._domElementKeyEvents.removeEventListener( 'keydown', onKeyDown );
+
+				} //scope.dispatchEvent( { type: 'dispose' } ); // should this be added here?
+
+			}; //
+			// internals
+			//
+
+
+			const scope = this;
+			const STATE = {
+				NONE: - 1,
+				ROTATE: 0,
+				DOLLY: 1,
+				PAN: 2,
+				TOUCH_ROTATE: 3,
+				TOUCH_PAN: 4,
+				TOUCH_DOLLY_PAN: 5,
+				TOUCH_DOLLY_ROTATE: 6
+			};
+			let state = STATE.NONE;
+			const EPS = 0.000001; // current position in spherical coordinates
+
+			const spherical = new THREE.Spherical();
+			const sphericalDelta = new THREE.Spherical();
+			let scale = 1;
+			const panOffset = new THREE.Vector3();
+			let zoomChanged = false;
+			const rotateStart = new THREE.Vector2();
+			const rotateEnd = new THREE.Vector2();
+			const rotateDelta = new THREE.Vector2();
+			const panStart = new THREE.Vector2();
+			const panEnd = new THREE.Vector2();
+			const panDelta = new THREE.Vector2();
+			const dollyStart = new THREE.Vector2();
+			const dollyEnd = new THREE.Vector2();
+			const dollyDelta = new THREE.Vector2();
+			const pointers = [];
+			const pointerPositions = {};
+
+			function getAutoRotationAngle() {
+
+				return 2 * Math.PI / 60 / 60 * scope.autoRotateSpeed;
+
+			}
+
+			function getZoomScale() {
+
+				return Math.pow( 0.95, scope.zoomSpeed );
+
+			}
+
+			function rotateLeft( angle ) {
+
+				sphericalDelta.theta -= angle;
+
+			}
+
+			function rotateUp( angle ) {
+
+				sphericalDelta.phi -= angle;
+
+			}
+
+			const panLeft = function () {
+
+				const v = new THREE.Vector3();
+				return function panLeft( distance, objectMatrix ) {
+
+					v.setFromMatrixColumn( objectMatrix, 0 ); // get X column of objectMatrix
+
+					v.multiplyScalar( - distance );
+					panOffset.add( v );
+
+				};
+
+			}();
+
+			const panUp = function () {
+
+				const v = new THREE.Vector3();
+				return function panUp( distance, objectMatrix ) {
+
+					if ( scope.screenSpacePanning === true ) {
+
+						v.setFromMatrixColumn( objectMatrix, 1 );
+
+					} else {
+
+						v.setFromMatrixColumn( objectMatrix, 0 );
+						v.crossVectors( scope.object.up, v );
+
+					}
+
+					v.multiplyScalar( distance );
+					panOffset.add( v );
+
+				};
+
+			}(); // deltaX and deltaY are in pixels; right and down are positive
+
+
+			const pan = function () {
+
+				const offset = new THREE.Vector3();
+				return function pan( deltaX, deltaY ) {
+
+					const element = scope.domElement;
+
+					if ( scope.object.isPerspectiveCamera ) {
+
+						// perspective
+						const position = scope.object.position;
+						offset.copy( position ).sub( scope.target );
+						let targetDistance = offset.length(); // half of the fov is center to top of screen
+
+						targetDistance *= Math.tan( scope.object.fov / 2 * Math.PI / 180.0 ); // we use only clientHeight here so aspect ratio does not distort speed
+
+						panLeft( 2 * deltaX * targetDistance / element.clientHeight, scope.object.matrix );
+						panUp( 2 * deltaY * targetDistance / element.clientHeight, scope.object.matrix );
+
+					} else if ( scope.object.isOrthographicCamera ) {
+
+						// orthographic
+						panLeft( deltaX * ( scope.object.right - scope.object.left ) / scope.object.zoom / element.clientWidth, scope.object.matrix );
+						panUp( deltaY * ( scope.object.top - scope.object.bottom ) / scope.object.zoom / element.clientHeight, scope.object.matrix );
+
+					} else {
+
+						// camera neither orthographic nor perspective
+						console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - pan disabled.' );
+						scope.enablePan = false;
+
+					}
+
+				};
+
+			}();
+
+			function dollyOut( dollyScale ) {
+
+				if ( scope.object.isPerspectiveCamera ) {
+
+					scale /= dollyScale;
+
+				} else if ( scope.object.isOrthographicCamera ) {
+
+					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom * dollyScale ) );
+					scope.object.updateProjectionMatrix();
+					zoomChanged = true;
+
+				} else {
+
+					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+					scope.enableZoom = false;
+
+				}
+
+			}
+
+			function dollyIn( dollyScale ) {
+
+				if ( scope.object.isPerspectiveCamera ) {
+
+					scale *= dollyScale;
+
+				} else if ( scope.object.isOrthographicCamera ) {
+
+					scope.object.zoom = Math.max( scope.minZoom, Math.min( scope.maxZoom, scope.object.zoom / dollyScale ) );
+					scope.object.updateProjectionMatrix();
+					zoomChanged = true;
+
+				} else {
+
+					console.warn( 'WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled.' );
+					scope.enableZoom = false;
+
+				}
+
+			} //
+			// event callbacks - update the object state
+			//
+
+
+			function handleMouseDownRotate( event ) {
+
+				rotateStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseDownDolly( event ) {
+
+				dollyStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseDownPan( event ) {
+
+				panStart.set( event.clientX, event.clientY );
+
+			}
+
+			function handleMouseMoveRotate( event ) {
+
+				rotateEnd.set( event.clientX, event.clientY );
+				rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+				const element = scope.domElement;
+				rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+
+				rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+				rotateStart.copy( rotateEnd );
+				scope.update();
+
+			}
+
+			function handleMouseMoveDolly( event ) {
+
+				dollyEnd.set( event.clientX, event.clientY );
+				dollyDelta.subVectors( dollyEnd, dollyStart );
+
+				if ( dollyDelta.y > 0 ) {
+
+					dollyOut( getZoomScale() );
+
+				} else if ( dollyDelta.y < 0 ) {
+
+					dollyIn( getZoomScale() );
+
+				}
+
+				dollyStart.copy( dollyEnd );
+				scope.update();
+
+			}
+
+			function handleMouseMovePan( event ) {
+
+				panEnd.set( event.clientX, event.clientY );
+				panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+				pan( panDelta.x, panDelta.y );
+				panStart.copy( panEnd );
+				scope.update();
+
+			}
+
+			function handleMouseUp( ) { // no-op
+			}
+
+			function handleMouseWheel( event ) {
+
+				if ( event.deltaY < 0 ) {
+
+					dollyIn( getZoomScale() );
+
+				} else if ( event.deltaY > 0 ) {
+
+					dollyOut( getZoomScale() );
+
+				}
+
+				scope.update();
+
+			}
+
+			function handleKeyDown( event ) {
+
+				let needsUpdate = false;
+
+				switch ( event.code ) {
+
+					case scope.keys.UP:
+						pan( 0, scope.keyPanSpeed );
+						needsUpdate = true;
+						break;
+
+					case scope.keys.BOTTOM:
+						pan( 0, - scope.keyPanSpeed );
+						needsUpdate = true;
+						break;
+
+					case scope.keys.LEFT:
+						pan( scope.keyPanSpeed, 0 );
+						needsUpdate = true;
+						break;
+
+					case scope.keys.RIGHT:
+						pan( - scope.keyPanSpeed, 0 );
+						needsUpdate = true;
+						break;
+
+				}
+
+				if ( needsUpdate ) {
+
+					// prevent the browser from scrolling on cursor keys
+					event.preventDefault();
+					scope.update();
+
+				}
+
+			}
+
+			function handleTouchStartRotate() {
+
+				if ( pointers.length === 1 ) {
+
+					rotateStart.set( pointers[ 0 ].pageX, pointers[ 0 ].pageY );
+
+				} else {
+
+					const x = 0.5 * ( pointers[ 0 ].pageX + pointers[ 1 ].pageX );
+					const y = 0.5 * ( pointers[ 0 ].pageY + pointers[ 1 ].pageY );
+					rotateStart.set( x, y );
+
+				}
+
+			}
+
+			function handleTouchStartPan() {
+
+				if ( pointers.length === 1 ) {
+
+					panStart.set( pointers[ 0 ].pageX, pointers[ 0 ].pageY );
+
+				} else {
+
+					const x = 0.5 * ( pointers[ 0 ].pageX + pointers[ 1 ].pageX );
+					const y = 0.5 * ( pointers[ 0 ].pageY + pointers[ 1 ].pageY );
+					panStart.set( x, y );
+
+				}
+
+			}
+
+			function handleTouchStartDolly() {
+
+				const dx = pointers[ 0 ].pageX - pointers[ 1 ].pageX;
+				const dy = pointers[ 0 ].pageY - pointers[ 1 ].pageY;
+				const distance = Math.sqrt( dx * dx + dy * dy );
+				dollyStart.set( 0, distance );
+
+			}
+
+			function handleTouchStartDollyPan() {
+
+				if ( scope.enableZoom ) handleTouchStartDolly();
+				if ( scope.enablePan ) handleTouchStartPan();
+
+			}
+
+			function handleTouchStartDollyRotate() {
+
+				if ( scope.enableZoom ) handleTouchStartDolly();
+				if ( scope.enableRotate ) handleTouchStartRotate();
+
+			}
+
+			function handleTouchMoveRotate( event ) {
+
+				if ( pointers.length == 1 ) {
+
+					rotateEnd.set( event.pageX, event.pageY );
+
+				} else {
+
+					const position = getSecondPointerPosition( event );
+					const x = 0.5 * ( event.pageX + position.x );
+					const y = 0.5 * ( event.pageY + position.y );
+					rotateEnd.set( x, y );
+
+				}
+
+				rotateDelta.subVectors( rotateEnd, rotateStart ).multiplyScalar( scope.rotateSpeed );
+				const element = scope.domElement;
+				rotateLeft( 2 * Math.PI * rotateDelta.x / element.clientHeight ); // yes, height
+
+				rotateUp( 2 * Math.PI * rotateDelta.y / element.clientHeight );
+				rotateStart.copy( rotateEnd );
+
+			}
+
+			function handleTouchMovePan( event ) {
+
+				if ( pointers.length === 1 ) {
+
+					panEnd.set( event.pageX, event.pageY );
+
+				} else {
+
+					const position = getSecondPointerPosition( event );
+					const x = 0.5 * ( event.pageX + position.x );
+					const y = 0.5 * ( event.pageY + position.y );
+					panEnd.set( x, y );
+
+				}
+
+				panDelta.subVectors( panEnd, panStart ).multiplyScalar( scope.panSpeed );
+				pan( panDelta.x, panDelta.y );
+				panStart.copy( panEnd );
+
+			}
+
+			function handleTouchMoveDolly( event ) {
+
+				const position = getSecondPointerPosition( event );
+				const dx = event.pageX - position.x;
+				const dy = event.pageY - position.y;
+				const distance = Math.sqrt( dx * dx + dy * dy );
+				dollyEnd.set( 0, distance );
+				dollyDelta.set( 0, Math.pow( dollyEnd.y / dollyStart.y, scope.zoomSpeed ) );
+				dollyOut( dollyDelta.y );
+				dollyStart.copy( dollyEnd );
+
+			}
+
+			function handleTouchMoveDollyPan( event ) {
+
+				if ( scope.enableZoom ) handleTouchMoveDolly( event );
+				if ( scope.enablePan ) handleTouchMovePan( event );
+
+			}
+
+			function handleTouchMoveDollyRotate( event ) {
+
+				if ( scope.enableZoom ) handleTouchMoveDolly( event );
+				if ( scope.enableRotate ) handleTouchMoveRotate( event );
+
+			}
+
+			function handleTouchEnd( ) { // no-op
+			} //
+			// event handlers - FSM: listen for events and reset state
+			//
+
+
+			function onPointerDown( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( pointers.length === 0 ) {
+
+					scope.domElement.ownerDocument.addEventListener( 'pointermove', onPointerMove );
+					scope.domElement.ownerDocument.addEventListener( 'pointerup', onPointerUp );
+
+				} //
+
+
+				addPointer( event );
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchStart( event );
+
+				} else {
+
+					onMouseDown( event );
+
+				}
+
+			}
+
+			function onPointerMove( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchMove( event );
+
+				} else {
+
+					onMouseMove( event );
+
+				}
+
+			}
+
+			function onPointerUp( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchEnd();
+
+				} else {
+
+					onMouseUp( event );
+
+				}
+
+				removePointer( event ); //
+
+				if ( pointers.length === 0 ) {
+
+					scope.domElement.ownerDocument.removeEventListener( 'pointermove', onPointerMove );
+					scope.domElement.ownerDocument.removeEventListener( 'pointerup', onPointerUp );
+
+				}
+
+			}
+
+			function onPointerCancel( event ) {
+
+				removePointer( event );
+
+			}
+
+			function onMouseDown( event ) {
+
+				let mouseAction;
+
+				switch ( event.button ) {
+
+					case 0:
+						mouseAction = scope.mouseButtons.LEFT;
+						break;
+
+					case 1:
+						mouseAction = scope.mouseButtons.MIDDLE;
+						break;
+
+					case 2:
+						mouseAction = scope.mouseButtons.RIGHT;
+						break;
+
+					default:
+						mouseAction = - 1;
+
+				}
+
+				switch ( mouseAction ) {
+
+					case THREE.MOUSE.DOLLY:
+						if ( scope.enableZoom === false ) return;
+						handleMouseDownDolly( event );
+						state = STATE.DOLLY;
+						break;
+
+					case THREE.MOUSE.ROTATE:
+						if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+							if ( scope.enablePan === false ) return;
+							handleMouseDownPan( event );
+							state = STATE.PAN;
+
+						} else {
+
+							if ( scope.enableRotate === false ) return;
+							handleMouseDownRotate( event );
+							state = STATE.ROTATE;
+
+						}
+
+						break;
+
+					case THREE.MOUSE.PAN:
+						if ( event.ctrlKey || event.metaKey || event.shiftKey ) {
+
+							if ( scope.enableRotate === false ) return;
+							handleMouseDownRotate( event );
+							state = STATE.ROTATE;
+
+						} else {
+
+							if ( scope.enablePan === false ) return;
+							handleMouseDownPan( event );
+							state = STATE.PAN;
+
+						}
+
+						break;
+
+					default:
+						state = STATE.NONE;
+
+				}
+
+				if ( state !== STATE.NONE ) {
+
+					scope.dispatchEvent( _startEvent );
+
+				}
+
+			}
+
+			function onMouseMove( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				switch ( state ) {
+
+					case STATE.ROTATE:
+						if ( scope.enableRotate === false ) return;
+						handleMouseMoveRotate( event );
+						break;
+
+					case STATE.DOLLY:
+						if ( scope.enableZoom === false ) return;
+						handleMouseMoveDolly( event );
+						break;
+
+					case STATE.PAN:
+						if ( scope.enablePan === false ) return;
+						handleMouseMovePan( event );
+						break;
+
+				}
+
+			}
+
+			function onMouseUp( event ) {
+
+				handleMouseUp( event );
+				scope.dispatchEvent( _endEvent );
+				state = STATE.NONE;
+
+			}
+
+			function onMouseWheel( event ) {
+
+				if ( scope.enabled === false || scope.enableZoom === false || state !== STATE.NONE && state !== STATE.ROTATE ) return;
+				event.preventDefault();
+				scope.dispatchEvent( _startEvent );
+				handleMouseWheel( event );
+				scope.dispatchEvent( _endEvent );
+
+			}
+
+			function onKeyDown( event ) {
+
+				if ( scope.enabled === false || scope.enablePan === false ) return;
+				handleKeyDown( event );
+
+			}
+
+			function onTouchStart( event ) {
+
+				trackPointer( event );
+
+				switch ( pointers.length ) {
+
+					case 1:
+						switch ( scope.touches.ONE ) {
+
+							case THREE.TOUCH.ROTATE:
+								if ( scope.enableRotate === false ) return;
+								handleTouchStartRotate();
+								state = STATE.TOUCH_ROTATE;
+								break;
+
+							case THREE.TOUCH.PAN:
+								if ( scope.enablePan === false ) return;
+								handleTouchStartPan();
+								state = STATE.TOUCH_PAN;
+								break;
+
+							default:
+								state = STATE.NONE;
+
+						}
+
+						break;
+
+					case 2:
+						switch ( scope.touches.TWO ) {
+
+							case THREE.TOUCH.DOLLY_PAN:
+								if ( scope.enableZoom === false && scope.enablePan === false ) return;
+								handleTouchStartDollyPan();
+								state = STATE.TOUCH_DOLLY_PAN;
+								break;
+
+							case THREE.TOUCH.DOLLY_ROTATE:
+								if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+								handleTouchStartDollyRotate();
+								state = STATE.TOUCH_DOLLY_ROTATE;
+								break;
+
+							default:
+								state = STATE.NONE;
+
+						}
+
+						break;
+
+					default:
+						state = STATE.NONE;
+
+				}
+
+				if ( state !== STATE.NONE ) {
+
+					scope.dispatchEvent( _startEvent );
+
+				}
+
+			}
+
+			function onTouchMove( event ) {
+
+				trackPointer( event );
+
+				switch ( state ) {
+
+					case STATE.TOUCH_ROTATE:
+						if ( scope.enableRotate === false ) return;
+						handleTouchMoveRotate( event );
+						scope.update();
+						break;
+
+					case STATE.TOUCH_PAN:
+						if ( scope.enablePan === false ) return;
+						handleTouchMovePan( event );
+						scope.update();
+						break;
+
+					case STATE.TOUCH_DOLLY_PAN:
+						if ( scope.enableZoom === false && scope.enablePan === false ) return;
+						handleTouchMoveDollyPan( event );
+						scope.update();
+						break;
+
+					case STATE.TOUCH_DOLLY_ROTATE:
+						if ( scope.enableZoom === false && scope.enableRotate === false ) return;
+						handleTouchMoveDollyRotate( event );
+						scope.update();
+						break;
+
+					default:
+						state = STATE.NONE;
+
+				}
+
+			}
+
+			function onTouchEnd( event ) {
+
+				handleTouchEnd( event );
+				scope.dispatchEvent( _endEvent );
+				state = STATE.NONE;
+
+			}
+
+			function onContextMenu( event ) {
+
+				if ( scope.enabled === false ) return;
+				event.preventDefault();
+
+			}
+
+			function addPointer( event ) {
+
+				pointers.push( event );
+
+			}
+
+			function removePointer( event ) {
+
+				delete pointerPositions[ event.pointerId ];
+
+				for ( let i = 0; i < pointers.length; i ++ ) {
+
+					if ( pointers[ i ].pointerId == event.pointerId ) {
+
+						pointers.splice( i, 1 );
+						return;
+
+					}
+
+				}
+
+			}
+
+			function trackPointer( event ) {
+
+				let position = pointerPositions[ event.pointerId ];
+
+				if ( position === undefined ) {
+
+					position = new THREE.Vector2();
+					pointerPositions[ event.pointerId ] = position;
+
+				}
+
+				position.set( event.pageX, event.pageY );
+
+			}
+
+			function getSecondPointerPosition( event ) {
+
+				const pointer = event.pointerId === pointers[ 0 ].pointerId ? pointers[ 1 ] : pointers[ 0 ];
+				return pointerPositions[ pointer.pointerId ];
+
+			} //
+
+
+			scope.domElement.addEventListener( 'contextmenu', onContextMenu );
+			scope.domElement.addEventListener( 'pointerdown', onPointerDown );
+			scope.domElement.addEventListener( 'pointercancel', onPointerCancel );
+			scope.domElement.addEventListener( 'wheel', onMouseWheel, {
+				passive: false
+			} ); // force an update at start
+
+			this.update();
+
+		}
+
+	} // This set of controls performs orbiting, dollying (zooming), and panning.
+	// Unlike TrackballControls, it maintains the "up" direction object.up (+Y by default).
+	// This is very similar to OrbitControls, another set of touch behavior
+	//
+	//    Orbit - right mouse, or left mouse + ctrl/meta/shiftKey / touch: two-finger rotate
+	//    Zoom - middle mouse, or mousewheel / touch: two-finger spread or squish
+	//    Pan - left mouse, or arrow keys / touch: one-finger move
+
+
+	class MapControls extends OrbitControls {
+
+		constructor( object, domElement ) {
+
+			super( object, domElement );
+			this.screenSpacePanning = false; // pan orthogonal to world-space direction camera.up
+
+			this.mouseButtons.LEFT = THREE.MOUSE.PAN;
+			this.mouseButtons.RIGHT = THREE.MOUSE.ROTATE;
+			this.touches.ONE = THREE.TOUCH.PAN;
+			this.touches.TWO = THREE.TOUCH.DOLLY_ROTATE;
+
+		}
+
+	}
+
+	THREE.MapControls = MapControls;
+	THREE.OrbitControls = OrbitControls;
+
+} )();

lib/Three.sprite.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t(require("three"),require("@seregpie/three.text-texture")):"function"==typeof define&&define.amd?define(["three","@seregpie/three.text-texture"],t):((e="undefined"!=typeof globalThis?globalThis:e||self).THREE=e.THREE||{},e.THREE.TextSprite=t(e.THREE,e.THREE.TextTexture))}(this,(function(e,t){"use strict";function i(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var r=i(t);let o=class extends e.Sprite{constructor({fontSize:t=1,...i}={},o=new e.SpriteMaterial({depthWrite:!1})){super(o);let a=new r.default({fontSize:t,...i});this.material.map=a}onBeforeRender(e,t,i){let{material:r}=this,{map:o}=r;if(o.checkFontFace()){let{scale:t}=this,{height:r,width:a}=o;a&&r?(t.setX(a).setY(r),o.setOptimalPixelRatio(this,e,i),o.redraw()):t.setScalar(1)}else o.loadFontFace()}dispose(){let{material:e}=this,{map:t}=e;t.dispose(),e.dispose()}};return["alignment","backgroundColor","color","fontFamily","fontSize","fontStyle","fontVariant","fontWeight","lineGap","padding","strokeColor","strokeWidth","text"].forEach((e=>{Object.defineProperty(o.prototype,e,{get(){return this.material.map[e]},set(t){this.material.map[e]=t}})})),o.prototype.isTextSprite=!0,o}));

lib/Three.texture.js

@@ -0,0 +1,213 @@
+! function(t, e) {
+    "object" == typeof exports && "undefined" != typeof module ? module.exports = e(require("three")) : "function" == typeof define && define.amd ? define(["three"], e) : ((t = "undefined" != typeof globalThis ? globalThis : t || self).THREE = t.THREE || {}, t.THREE.TextTexture = e(t.THREE))
+}(this, (function(t) {
+    "use strict";
+    let e = class extends t.Texture {
+        constructor() {
+            super(document.createElement("canvas"));
+            let e = null,
+                i = () => e || (e = this.createDrawable()),
+                n = () => i().width,
+                o = () => i().height,
+                r = !0,
+                l = 1,
+                a = () => t.MathUtils.ceilPowerOfTwo(n() * l),
+                s = () => t.MathUtils.ceilPowerOfTwo(o() * l),
+                h = t => {
+                    if (l !== t) {
+                        let e = a(),
+                            i = s();
+                        l = t;
+                        let n = a(),
+                            o = s();
+                        n === e && o === i || (r = !0)
+                    }
+                },
+                c = (() => {
+                    let e = new t.Vector3,
+                        i = new t.Vector2,
+                        r = new t.Vector3,
+                        l = new t.Vector3,
+                        a = new t.Vector2;
+                    return (s, h, c) => {
+                        if (a.set(n(), o()), a.x && a.y) {
+                            s.getWorldPosition(r), c.getWorldPosition(e);
+                            let n = r.distanceTo(e);
+                            if (c.isPerspectiveCamera && (n *= 2 * Math.tan(t.MathUtils.degToRad(c.fov) / 2)), (c.isPerspectiveCamera || c.isOrthographicCamera) && (n /= c.zoom), n) {
+                                var f, d;
+                                s.getWorldScale(l);
+                                let t = null !== (f = null === (d = h.capabilities) || void 0 === d ? void 0 : d.maxTextureSize) && void 0 !== f ? f : 1 / 0;
+                                return h.getDrawingBufferSize(i), Math.min(Math.max(l.x / n * (i.x / a.x), l.y / n * (i.y / a.y)), t / a.x, t / a.y)
+                            }
+                        }
+                        return 0
+                    }
+                })();
+            Object.defineProperties(this, {
+                width: {
+                    get: n
+                },
+                height: {
+                    get: o
+                },
+                pixelRatio: {
+                    get: () => l,
+                    set: h
+                },
+                needsRedraw: {
+                    set(t) {
+                        t && (r = !0, e = null)
+                    }
+                }
+            }), Object.assign(this, {
+                redraw() {
+                    if (r) {
+                        let t = this.image,
+                            e = t.getContext("2d");
+                        e.clearRect(0, 0, t.width, t.height), t.width = a(), t.height = s(), t.width && t.height ? (e.save(), e.scale(t.width / n(), t.height / o()), ((...t) => {
+                            i().draw(...t)
+                        })(e), e.restore()) : t.width = t.height = 1, r = !1, this.needsUpdate = !0
+                    }
+                },
+                setOptimalPixelRatio(...t) {
+                    h(c(...t))
+                }
+            })
+        }
+    };
+    e.prototype.isDynamicTexture = !0;
+    let i = class extends e {
+        constructor({
+            alignment: t = "center",
+            backgroundColor: e = "rgba(0,0,0,0)",
+            color: i = "#fff",
+            fontFamily: n = "sans-serif",
+            fontSize: o = 16,
+            fontStyle: r = "normal",
+            fontVariant: l = "normal",
+            fontWeight: a = "normal",
+            lineGap: s = 1 / 4,
+            padding: h = .5,
+            strokeColor: c = "#fff",
+            strokeWidth: f = 0,
+            text: d = ""
+        } = {}) {
+            super(), Object.entries({
+                alignment: t,
+                backgroundColor: e,
+                color: i,
+                fontFamily: n,
+                fontSize: o,
+                fontStyle: r,
+                fontVariant: l,
+                fontWeight: a,
+                lineGap: s,
+                padding: h,
+                strokeColor: c,
+                strokeWidth: f,
+                text: d
+            }).forEach((([t, e]) => {
+                Object.defineProperty(this, t, {
+                    get: () => e,
+                    set(t) {
+                        e !== t && (e = t, this.needsRedraw = !0)
+                    }
+                })
+            }))
+        }
+        get lines() {
+            let {
+                text: t
+            } = this;
+            return t ? t.split("\n") : []
+        }
+        get font() {
+            return function(t, e, i, n, o) {
+                let r = document.createElement("span");
+                return r.style.font = "1px serif", r.style.fontFamily = t, r.style.fontSize = "".concat(e, "px"), r.style.fontStyle = i, r.style.fontVariant = n, r.style.fontWeight = o, r.style.font
+            }(this.fontFamily, this.fontSize, this.fontStyle, this.fontVariant, this.fontWeight)
+        }
+        checkFontFace() {
+            try {
+                let {
+                    font: t
+                } = this;
+                return document.fonts.check(t)
+            } catch (e) {}
+            return !0
+        }
+        async loadFontFace() {
+            try {
+                let {
+                    font: t
+                } = this;
+                await document.fonts.load(t)
+            } catch (e) {}
+        }
+        createDrawable() {
+            let {
+                alignment: t,
+                backgroundColor: e,
+                color: i,
+                font: n,
+                fontSize: o,
+                lineGap: r,
+                lines: l,
+                padding: a,
+                strokeColor: s,
+                strokeWidth: h
+            } = this;
+            a *= o, r *= o, h *= o;
+            let c = l.length,
+                f = o + r,
+                d = c ? (() => {
+                    let t = document.createElement("canvas").getContext("2d");
+                    return t.font = n, Math.max(...l.map((e => t.measureText(e).width)))
+                })() : 0,
+                g = a + h / 2,
+                u = d + 2 * g;
+            return {
+                width: u,
+                height: (c ? o + f * (c - 1) : 0) + 2 * g,
+                draw(r) {
+                    let a;
+                    r.fillStyle = e, r.fillRect(0, 0, r.canvas.width, r.canvas.height);
+                    let c = g + o / 2;
+                    Object.assign(r, {
+                        fillStyle: i,
+                        font: n,
+                        lineWidth: h,
+                        miterLimit: 1,
+                        strokeStyle: s,
+                        textAlign: (() => {
+                            switch (t) {
+                                case "left":
+                                    return a = g, "left";
+                                case "right":
+                                    return a = u - g, "right"
+                            }
+                            return a = u / 2, "center"
+                        })(),
+                        textBaseline: "middle"
+                    }), l.forEach((t => {
+
+                        // r.lineWidth=60
+                        // r.shadowColor="white"
+                        // r.shadowBlur=2
+                        // r.fillStyle = "white"
+                        // r.fillText(t, a, c);
+
+                        r.lineWidth=5
+                        r.shadowColor="black"
+                        r.shadowBlur=0
+                        r.fillStyle = "black"
+                        r.fillText(t, a, c);
+
+                        h && r.strokeText(t, a, c), c += f
+                    }))
+                }
+            }
+        }
+    };
+    return i.prototype.isTextTexture = !0, i
+}));

lib/TrackballControls.js

@@ -0,0 +1,778 @@
+( function () {
+
+	const _changeEvent = {
+		type: 'change'
+	};
+	const _startEvent = {
+		type: 'start'
+	};
+	const _endEvent = {
+		type: 'end'
+	};
+
+	class TrackballControls extends THREE.EventDispatcher {
+
+		constructor( object, domElement ) {
+
+			super();
+			if ( domElement === undefined ) console.warn( 'THREE.TrackballControls: The second parameter "domElement" is now mandatory.' );
+			if ( domElement === document ) console.error( 'THREE.TrackballControls: "document" should not be used as the target "domElement". Please use "renderer.domElement" instead.' );
+			const scope = this;
+			const STATE = {
+				NONE: - 1,
+				ROTATE: 0,
+				ZOOM: 1,
+				PAN: 2,
+				TOUCH_ROTATE: 3,
+				TOUCH_ZOOM_PAN: 4
+			};
+			this.object = object;
+			this.domElement = domElement;
+			this.domElement.style.touchAction = 'none'; // disable touch scroll
+			// API
+
+			this.enabled = true;
+			this.screen = {
+				left: 0,
+				top: 0,
+				width: 0,
+				height: 0
+			};
+			this.rotateSpeed = 1.0;
+			this.zoomSpeed = 1.2;
+			this.panSpeed = 0.3;
+			this.noRotate = false;
+			this.noZoom = false;
+			this.noPan = false;
+			this.staticMoving = false;
+			this.dynamicDampingFactor = 0.2;
+			this.minDistance = 0;
+			this.maxDistance = Infinity;
+			this.keys = [ 'KeyA',
+				/*A*/
+				'KeyS',
+				/*S*/
+				'KeyD'
+				/*D*/
+			];
+			this.mouseButtons = {
+				LEFT: THREE.MOUSE.ROTATE,
+				MIDDLE: THREE.MOUSE.DOLLY,
+				RIGHT: THREE.MOUSE.PAN
+			}; // internals
+
+			this.target = new THREE.Vector3();
+			const EPS = 0.000001;
+			const lastPosition = new THREE.Vector3();
+			let lastZoom = 1;
+			let _state = STATE.NONE,
+				_keyState = STATE.NONE,
+				_touchZoomDistanceStart = 0,
+				_touchZoomDistanceEnd = 0,
+				_lastAngle = 0;
+
+			const _eye = new THREE.Vector3(),
+				_movePrev = new THREE.Vector2(),
+				_moveCurr = new THREE.Vector2(),
+				_lastAxis = new THREE.Vector3(),
+				_zoomStart = new THREE.Vector2(),
+				_zoomEnd = new THREE.Vector2(),
+				_panStart = new THREE.Vector2(),
+				_panEnd = new THREE.Vector2(),
+				_pointers = [],
+				_pointerPositions = {}; // for reset
+
+
+			this.target0 = this.target.clone();
+			this.position0 = this.object.position.clone();
+			this.up0 = this.object.up.clone();
+			this.zoom0 = this.object.zoom; // methods
+
+			this.handleResize = function () {
+
+				const box = scope.domElement.getBoundingClientRect(); // adjustments come from similar code in the jquery offset() function
+
+				const d = scope.domElement.ownerDocument.documentElement;
+				scope.screen.left = box.left + window.pageXOffset - d.clientLeft;
+				scope.screen.top = box.top + window.pageYOffset - d.clientTop;
+				scope.screen.width = box.width;
+				scope.screen.height = box.height;
+
+			};
+
+			const getMouseOnScreen = function () {
+
+				const vector = new THREE.Vector2();
+				return function getMouseOnScreen( pageX, pageY ) {
+
+					vector.set( ( pageX - scope.screen.left ) / scope.screen.width, ( pageY - scope.screen.top ) / scope.screen.height );
+					return vector;
+
+				};
+
+			}();
+
+			const getMouseOnCircle = function () {
+
+				const vector = new THREE.Vector2();
+				return function getMouseOnCircle( pageX, pageY ) {
+
+					vector.set( ( pageX - scope.screen.width * 0.5 - scope.screen.left ) / ( scope.screen.width * 0.5 ), ( scope.screen.height + 2 * ( scope.screen.top - pageY ) ) / scope.screen.width // screen.width intentional
+					);
+					return vector;
+
+				};
+
+			}();
+
+			this.rotateCamera = function () {
+
+				const axis = new THREE.Vector3(),
+					quaternion = new THREE.Quaternion(),
+					eyeDirection = new THREE.Vector3(),
+					objectUpDirection = new THREE.Vector3(),
+					objectSidewaysDirection = new THREE.Vector3(),
+					moveDirection = new THREE.Vector3();
+				return function rotateCamera() {
+
+					moveDirection.set( _moveCurr.x - _movePrev.x, _moveCurr.y - _movePrev.y, 0 );
+					let angle = moveDirection.length();
+
+					if ( angle ) {
+
+						_eye.copy( scope.object.position ).sub( scope.target );
+
+						eyeDirection.copy( _eye ).normalize();
+						objectUpDirection.copy( scope.object.up ).normalize();
+						objectSidewaysDirection.crossVectors( objectUpDirection, eyeDirection ).normalize();
+						objectUpDirection.setLength( _moveCurr.y - _movePrev.y );
+						objectSidewaysDirection.setLength( _moveCurr.x - _movePrev.x );
+						moveDirection.copy( objectUpDirection.add( objectSidewaysDirection ) );
+						axis.crossVectors( moveDirection, _eye ).normalize();
+						angle *= scope.rotateSpeed;
+						quaternion.setFromAxisAngle( axis, angle );
+
+						_eye.applyQuaternion( quaternion );
+
+						scope.object.up.applyQuaternion( quaternion );
+
+						_lastAxis.copy( axis );
+
+						_lastAngle = angle;
+
+					} else if ( ! scope.staticMoving && _lastAngle ) {
+
+						_lastAngle *= Math.sqrt( 1.0 - scope.dynamicDampingFactor );
+
+						_eye.copy( scope.object.position ).sub( scope.target );
+
+						quaternion.setFromAxisAngle( _lastAxis, _lastAngle );
+
+						_eye.applyQuaternion( quaternion );
+
+						scope.object.up.applyQuaternion( quaternion );
+
+					}
+
+					_movePrev.copy( _moveCurr );
+
+				};
+
+			}();
+
+			this.zoomCamera = function () {
+
+				let factor;
+
+				if ( _state === STATE.TOUCH_ZOOM_PAN ) {
+
+					factor = _touchZoomDistanceStart / _touchZoomDistanceEnd;
+					_touchZoomDistanceStart = _touchZoomDistanceEnd;
+
+					if ( scope.object.isPerspectiveCamera ) {
+
+						_eye.multiplyScalar( factor );
+
+					} else if ( scope.object.isOrthographicCamera ) {
+
+						scope.object.zoom *= factor;
+						scope.object.updateProjectionMatrix();
+
+					} else {
+
+						console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+
+					}
+
+				} else {
+
+					factor = 1.0 + ( _zoomEnd.y - _zoomStart.y ) * scope.zoomSpeed;
+
+					if ( factor !== 1.0 && factor > 0.0 ) {
+
+						if ( scope.object.isPerspectiveCamera ) {
+
+							_eye.multiplyScalar( factor );
+
+						} else if ( scope.object.isOrthographicCamera ) {
+
+							scope.object.zoom /= factor;
+							scope.object.updateProjectionMatrix();
+
+						} else {
+
+							console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+
+						}
+
+					}
+
+					if ( scope.staticMoving ) {
+
+						_zoomStart.copy( _zoomEnd );
+
+					} else {
+
+						_zoomStart.y += ( _zoomEnd.y - _zoomStart.y ) * this.dynamicDampingFactor;
+
+					}
+
+				}
+
+			};
+
+			this.panCamera = function () {
+
+				const mouseChange = new THREE.Vector2(),
+					objectUp = new THREE.Vector3(),
+					pan = new THREE.Vector3();
+				return function panCamera() {
+
+					mouseChange.copy( _panEnd ).sub( _panStart );
+
+					if ( mouseChange.lengthSq() ) {
+
+						if ( scope.object.isOrthographicCamera ) {
+
+							const scale_x = ( scope.object.right - scope.object.left ) / scope.object.zoom / scope.domElement.clientWidth;
+							const scale_y = ( scope.object.top - scope.object.bottom ) / scope.object.zoom / scope.domElement.clientWidth;
+							mouseChange.x *= scale_x;
+							mouseChange.y *= scale_y;
+
+						}
+
+						mouseChange.multiplyScalar( _eye.length() * scope.panSpeed );
+						pan.copy( _eye ).cross( scope.object.up ).setLength( mouseChange.x );
+						pan.add( objectUp.copy( scope.object.up ).setLength( mouseChange.y ) );
+						scope.object.position.add( pan );
+						scope.target.add( pan );
+
+						if ( scope.staticMoving ) {
+
+							_panStart.copy( _panEnd );
+
+						} else {
+
+							_panStart.add( mouseChange.subVectors( _panEnd, _panStart ).multiplyScalar( scope.dynamicDampingFactor ) );
+
+						}
+
+					}
+
+				};
+
+			}();
+
+			this.checkDistances = function () {
+
+				if ( ! scope.noZoom || ! scope.noPan ) {
+
+					if ( _eye.lengthSq() > scope.maxDistance * scope.maxDistance ) {
+
+						scope.object.position.addVectors( scope.target, _eye.setLength( scope.maxDistance ) );
+
+						_zoomStart.copy( _zoomEnd );
+
+					}
+
+					if ( _eye.lengthSq() < scope.minDistance * scope.minDistance ) {
+
+						scope.object.position.addVectors( scope.target, _eye.setLength( scope.minDistance ) );
+
+						_zoomStart.copy( _zoomEnd );
+
+					}
+
+				}
+
+			};
+
+			this.update = function () {
+
+				_eye.subVectors( scope.object.position, scope.target );
+
+				if ( ! scope.noRotate ) {
+
+					scope.rotateCamera();
+
+				}
+
+				if ( ! scope.noZoom ) {
+
+					scope.zoomCamera();
+
+				}
+
+				if ( ! scope.noPan ) {
+
+					scope.panCamera();
+
+				}
+
+				scope.object.position.addVectors( scope.target, _eye );
+
+				if ( scope.object.isPerspectiveCamera ) {
+
+					scope.checkDistances();
+					scope.object.lookAt( scope.target );
+
+					if ( lastPosition.distanceToSquared( scope.object.position ) > EPS ) {
+
+						scope.dispatchEvent( _changeEvent );
+						lastPosition.copy( scope.object.position );
+
+					}
+
+				} else if ( scope.object.isOrthographicCamera ) {
+
+					scope.object.lookAt( scope.target );
+
+					if ( lastPosition.distanceToSquared( scope.object.position ) > EPS || lastZoom !== scope.object.zoom ) {
+
+						scope.dispatchEvent( _changeEvent );
+						lastPosition.copy( scope.object.position );
+						lastZoom = scope.object.zoom;
+
+					}
+
+				} else {
+
+					console.warn( 'THREE.TrackballControls: Unsupported camera type' );
+
+				}
+
+			};
+
+			this.reset = function () {
+
+				_state = STATE.NONE;
+				_keyState = STATE.NONE;
+				scope.target.copy( scope.target0 );
+				scope.object.position.copy( scope.position0 );
+				scope.object.up.copy( scope.up0 );
+				scope.object.zoom = scope.zoom0;
+				scope.object.updateProjectionMatrix();
+
+				_eye.subVectors( scope.object.position, scope.target );
+
+				scope.object.lookAt( scope.target );
+				scope.dispatchEvent( _changeEvent );
+				lastPosition.copy( scope.object.position );
+				lastZoom = scope.object.zoom;
+
+			}; // listeners
+
+
+			function onPointerDown( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( _pointers.length === 0 ) {
+
+					scope.domElement.ownerDocument.addEventListener( 'pointermove', onPointerMove );
+					scope.domElement.ownerDocument.addEventListener( 'pointerup', onPointerUp );
+
+				} //
+
+
+				addPointer( event );
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchStart( event );
+
+				} else {
+
+					onMouseDown( event );
+
+				}
+
+			}
+
+			function onPointerMove( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchMove( event );
+
+				} else {
+
+					onMouseMove( event );
+
+				}
+
+			}
+
+			function onPointerUp( event ) {
+
+				if ( scope.enabled === false ) return;
+
+				if ( event.pointerType === 'touch' ) {
+
+					onTouchEnd( event );
+
+				} else {
+
+					onMouseUp();
+
+				} //
+
+
+				removePointer( event );
+
+				if ( _pointers.length === 0 ) {
+
+					scope.domElement.ownerDocument.removeEventListener( 'pointermove', onPointerMove );
+					scope.domElement.ownerDocument.removeEventListener( 'pointerup', onPointerUp );
+
+				}
+
+			}
+
+			function onPointerCancel( event ) {
+
+				removePointer( event );
+
+			}
+
+			function keydown( event ) {
+
+				if ( scope.enabled === false ) return;
+				window.removeEventListener( 'keydown', keydown );
+
+				if ( _keyState !== STATE.NONE ) {
+
+					return;
+
+				} else if ( event.code === scope.keys[ STATE.ROTATE ] && ! scope.noRotate ) {
+
+					_keyState = STATE.ROTATE;
+
+				} else if ( event.code === scope.keys[ STATE.ZOOM ] && ! scope.noZoom ) {
+
+					_keyState = STATE.ZOOM;
+
+				} else if ( event.code === scope.keys[ STATE.PAN ] && ! scope.noPan ) {
+
+					_keyState = STATE.PAN;
+
+				}
+
+			}
+
+			function keyup() {
+
+				if ( scope.enabled === false ) return;
+				_keyState = STATE.NONE;
+				window.addEventListener( 'keydown', keydown );
+
+			}
+
+			function onMouseDown( event ) {
+
+				if ( _state === STATE.NONE ) {
+
+					switch ( event.button ) {
+
+						case scope.mouseButtons.LEFT:
+							_state = STATE.ROTATE;
+							break;
+
+						case scope.mouseButtons.MIDDLE:
+							_state = STATE.ZOOM;
+							break;
+
+						case scope.mouseButtons.RIGHT:
+							_state = STATE.PAN;
+							break;
+
+						default:
+							_state = STATE.NONE;
+
+					}
+
+				}
+
+				const state = _keyState !== STATE.NONE ? _keyState : _state;
+
+				if ( state === STATE.ROTATE && ! scope.noRotate ) {
+
+					_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
+
+					_movePrev.copy( _moveCurr );
+
+				} else if ( state === STATE.ZOOM && ! scope.noZoom ) {
+
+					_zoomStart.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+
+					_zoomEnd.copy( _zoomStart );
+
+				} else if ( state === STATE.PAN && ! scope.noPan ) {
+
+					_panStart.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+
+					_panEnd.copy( _panStart );
+
+				}
+
+				scope.domElement.ownerDocument.addEventListener( 'pointermove', onPointerMove );
+				scope.domElement.ownerDocument.addEventListener( 'pointerup', onPointerUp );
+				scope.dispatchEvent( _startEvent );
+
+			}
+
+			function onMouseMove( event ) {
+
+				const state = _keyState !== STATE.NONE ? _keyState : _state;
+
+				if ( state === STATE.ROTATE && ! scope.noRotate ) {
+
+					_movePrev.copy( _moveCurr );
+
+					_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
+
+				} else if ( state === STATE.ZOOM && ! scope.noZoom ) {
+
+					_zoomEnd.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+
+				} else if ( state === STATE.PAN && ! scope.noPan ) {
+
+					_panEnd.copy( getMouseOnScreen( event.pageX, event.pageY ) );
+
+				}
+
+			}
+
+			function onMouseUp() {
+
+				_state = STATE.NONE;
+				scope.domElement.ownerDocument.removeEventListener( 'pointermove', onPointerMove );
+				scope.domElement.ownerDocument.removeEventListener( 'pointerup', onPointerUp );
+				scope.dispatchEvent( _endEvent );
+
+			}
+
+			function onMouseWheel( event ) {
+
+				if ( scope.enabled === false ) return;
+				if ( scope.noZoom === true ) return;
+				event.preventDefault();
+
+				switch ( event.deltaMode ) {
+
+					case 2:
+						// Zoom in pages
+						_zoomStart.y -= event.deltaY * 0.025;
+						break;
+
+					case 1:
+						// Zoom in lines
+						_zoomStart.y -= event.deltaY * 0.01;
+						break;
+
+					default:
+						// undefined, 0, assume pixels
+						_zoomStart.y -= event.deltaY * 0.00025;
+						break;
+
+				}
+
+				scope.dispatchEvent( _startEvent );
+				scope.dispatchEvent( _endEvent );
+
+			}
+
+			function onTouchStart( event ) {
+
+				trackPointer( event );
+
+				switch ( _pointers.length ) {
+
+					case 1:
+						_state = STATE.TOUCH_ROTATE;
+
+						_moveCurr.copy( getMouseOnCircle( _pointers[ 0 ].pageX, _pointers[ 0 ].pageY ) );
+
+						_movePrev.copy( _moveCurr );
+
+						break;
+
+					default:
+						// 2 or more
+						_state = STATE.TOUCH_ZOOM_PAN;
+						const dx = _pointers[ 0 ].pageX - _pointers[ 1 ].pageX;
+						const dy = _pointers[ 0 ].pageY - _pointers[ 1 ].pageY;
+						_touchZoomDistanceEnd = _touchZoomDistanceStart = Math.sqrt( dx * dx + dy * dy );
+						const x = ( _pointers[ 0 ].pageX + _pointers[ 1 ].pageX ) / 2;
+						const y = ( _pointers[ 0 ].pageY + _pointers[ 1 ].pageY ) / 2;
+
+						_panStart.copy( getMouseOnScreen( x, y ) );
+
+						_panEnd.copy( _panStart );
+
+						break;
+
+				}
+
+				scope.dispatchEvent( _startEvent );
+
+			}
+
+			function onTouchMove( event ) {
+
+				trackPointer( event );
+
+				switch ( _pointers.length ) {
+
+					case 1:
+						_movePrev.copy( _moveCurr );
+
+						_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
+
+						break;
+
+					default:
+						// 2 or more
+						const position = getSecondPointerPosition( event );
+						const dx = event.pageX - position.x;
+						const dy = event.pageY - position.y;
+						_touchZoomDistanceEnd = Math.sqrt( dx * dx + dy * dy );
+						const x = ( event.pageX + position.x ) / 2;
+						const y = ( event.pageY + position.y ) / 2;
+
+						_panEnd.copy( getMouseOnScreen( x, y ) );
+
+						break;
+
+				}
+
+			}
+
+			function onTouchEnd( event ) {
+
+				switch ( _pointers.length ) {
+
+					case 0:
+						_state = STATE.NONE;
+						break;
+
+					case 1:
+						_state = STATE.TOUCH_ROTATE;
+
+						_moveCurr.copy( getMouseOnCircle( event.pageX, event.pageY ) );
+
+						_movePrev.copy( _moveCurr );
+
+						break;
+
+				}
+
+				scope.dispatchEvent( _endEvent );
+
+			}
+
+			function contextmenu( event ) {
+
+				if ( scope.enabled === false ) return;
+				event.preventDefault();
+
+			}
+
+			function addPointer( event ) {
+
+				_pointers.push( event );
+
+			}
+
+			function removePointer( event ) {
+
+				delete _pointerPositions[ event.pointerId ];
+
+				for ( let i = 0; i < _pointers.length; i ++ ) {
+
+					if ( _pointers[ i ].pointerId == event.pointerId ) {
+
+						_pointers.splice( i, 1 );
+
+						return;
+
+					}
+
+				}
+
+			}
+
+			function trackPointer( event ) {
+
+				let position = _pointerPositions[ event.pointerId ];
+
+				if ( position === undefined ) {
+
+					position = new THREE.Vector2();
+					_pointerPositions[ event.pointerId ] = position;
+
+				}
+
+				position.set( event.pageX, event.pageY );
+
+			}
+
+			function getSecondPointerPosition( event ) {
+
+				const pointer = event.pointerId === _pointers[ 0 ].pointerId ? _pointers[ 1 ] : _pointers[ 0 ];
+				return _pointerPositions[ pointer.pointerId ];
+
+			}
+
+			this.dispose = function () {
+
+				scope.domElement.removeEventListener( 'contextmenu', contextmenu );
+				scope.domElement.removeEventListener( 'pointerdown', onPointerDown );
+				scope.domElement.removeEventListener( 'pointercancel', onPointerCancel );
+				scope.domElement.removeEventListener( 'wheel', onMouseWheel );
+				window.removeEventListener( 'keydown', keydown );
+				window.removeEventListener( 'keyup', keyup );
+
+			};
+
+			this.domElement.addEventListener( 'contextmenu', contextmenu );
+			this.domElement.addEventListener( 'pointerdown', onPointerDown );
+			this.domElement.addEventListener( 'pointercancel', onPointerCancel );
+			this.domElement.addEventListener( 'wheel', onMouseWheel, {
+				passive: false
+			} );
+			window.addEventListener( 'keydown', keydown );
+			window.addEventListener( 'keyup', keyup );
+			this.handleResize(); // force an update at start
+
+			this.update();
+
+		}
+
+	}
+
+	THREE.TrackballControls = TrackballControls;
+
+} )();

lib/ffmpeg_normalize/__init__.py

@@ -0,0 +1,5 @@
+from ._ffmpeg_normalize import FFmpegNormalize
+from ._media_file import MediaFile
+from ._version import __version__
+
+__all__ = ["FFmpegNormalize", "MediaFile", "__version__"]

lib/ffmpeg_normalize/__main__.py

@@ -0,0 +1,548 @@
+import argparse
+import textwrap
+import logging
+import os
+import shlex
+import json
+
+try:
+    from json.decoder import JSONDecodeError
+except ImportError:
+    JSONDecodeError = ValueError
+
+from ._version import __version__
+from ._ffmpeg_normalize import FFmpegNormalize, NORMALIZATION_TYPES
+from ._errors import FFmpegNormalizeError
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+
+def create_parser():
+    parser = argparse.ArgumentParser(
+        prog="ffmpeg-normalize",
+        description=textwrap.dedent(
+            """\
+            ffmpeg-normalize v{} -- command line tool for normalizing audio files
+            """.format(
+                __version__
+            )
+        ),
+        usage=textwrap.dedent(
+            """\
+            ffmpeg-normalize input [input ...]
+                [-h]
+                [-o OUTPUT [OUTPUT ...]] [-of OUTPUT_FOLDER]
+                [-f] [-d] [-v] [-q] [-n] [-pr]
+                [--version]
+                [-nt {ebu,rms,peak}] [-t TARGET_LEVEL] [-p]
+                [-lrt LOUDNESS_RANGE_TARGET] [-tp TRUE_PEAK] [--offset OFFSET] [--dual-mono]
+                [-c:a AUDIO_CODEC] [-b:a AUDIO_BITRATE] [-ar SAMPLE_RATE] [-koa]
+                [-prf PRE_FILTER] [-pof POST_FILTER]
+                [-vn] [-c:v VIDEO_CODEC]
+                [-sn] [-mn] [-cn]
+                [-ei EXTRA_INPUT_OPTIONS] [-e EXTRA_OUTPUT_OPTIONS]
+                [-ofmt OUTPUT_FORMAT]
+                [-ext EXTENSION]
+        """
+        ),
+        formatter_class=argparse.RawTextHelpFormatter,
+        epilog=textwrap.dedent(
+            """\
+            The program additionally respects environment variables:
+
+              - `TMP` / `TEMP` / `TMPDIR`
+                    Sets the path to the temporary directory in which files are
+                    stored before being moved to the final output directory.
+                    Note: You need to use full paths.
+
+              - `FFMPEG_PATH`
+                    Sets the full path to an `ffmpeg` executable other than
+                    the system default.
+
+
+            Author: Werner Robitza
+            License: MIT
+            Homepage / Issues: https://github.com/slhck/ffmpeg-normalize
+            """
+        ),
+    )
+
+    group_io = parser.add_argument_group("File Input/output")
+    group_io.add_argument("input", nargs="+", help="Input media file(s)")
+    group_io.add_argument(
+        "-o",
+        "--output",
+        nargs="+",
+        help=textwrap.dedent(
+            """\
+        Output file names. Will be applied per input file.
+
+        If no output file name is specified for an input file, the output files
+        will be written to the default output folder with the name `<input>.<ext>`,
+        where `<ext>` is the output extension (see `-ext` option).
+
+        Example: ffmpeg-normalize 1.wav 2.wav -o 1n.wav 2n.wav
+        """
+        ),
+    )
+    group_io.add_argument(
+        "-of",
+        "--output-folder",
+        type=str,
+        help=textwrap.dedent(
+            """\
+            Output folder (default: `normalized`)
+
+            This folder will be used for input files that have no explicit output
+            name specified.
+        """
+        ),
+        default="normalized",
+    )
+
+    group_general = parser.add_argument_group("General Options")
+    group_general.add_argument(
+        "-f", "--force", action="store_true", help="Force overwrite existing files"
+    )
+    group_general.add_argument(
+        "-d", "--debug", action="store_true", help="Print debugging output"
+    )
+    group_general.add_argument(
+        "-v", "--verbose", action="store_true", help="Print verbose output"
+    )
+    group_general.add_argument(
+        "-q", "--quiet", action="store_true", help="Only print errors in output"
+    )
+    group_general.add_argument(
+        "-n",
+        "--dry-run",
+        action="store_true",
+        help="Do not run normalization, only print what would be done",
+    )
+    group_general.add_argument(
+        "-pr",
+        "--progress",
+        action="store_true",
+        help="Show progress bar for files and streams",
+    )
+    group_general.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s v{__version__}",
+        help="Print version and exit",
+    )
+
+    group_normalization = parser.add_argument_group("Normalization")
+    group_normalization.add_argument(
+        "-nt",
+        "--normalization-type",
+        type=str,
+        choices=NORMALIZATION_TYPES,
+        help=textwrap.dedent(
+            """\
+        Normalization type (default: `ebu`).
+
+        EBU normalization performs two passes and normalizes according to EBU
+        R128.
+
+        RMS-based normalization brings the input file to the specified RMS
+        level.
+
+        Peak normalization brings the signal to the specified peak level.
+        """
+        ),
+        default="ebu",
+    )
+    group_normalization.add_argument(
+        "-t",
+        "--target-level",
+        type=float,
+        help=textwrap.dedent(
+            """\
+        Normalization target level in dB/LUFS (default: -23).
+
+        For EBU normalization, it corresponds to Integrated Loudness Target
+        in LUFS. The range is -70.0 - -5.0.
+
+        Otherwise, the range is -99 to 0.
+        """
+        ),
+        default=-23.0,
+    )
+    group_normalization.add_argument(
+        "-p",
+        "--print-stats",
+        action="store_true",
+        help="Print first pass loudness statistics formatted as JSON to stdout",
+    )
+
+    # group_normalization.add_argument(
+    #     '--threshold',
+    #     type=float,
+    #     help=textwrap.dedent("""\
+    #     Threshold below which normalization should not be run.
+
+    #     If the stream falls within the threshold, it will simply be copied.
+    #     """),
+    #     default=0.5
+    # )
+
+    group_ebu = parser.add_argument_group("EBU R128 Normalization")
+    group_ebu.add_argument(
+        "-lrt",
+        "--loudness-range-target",
+        type=float,
+        help=textwrap.dedent(
+            """\
+        EBU Loudness Range Target in LUFS (default: 7.0).
+        Range is 1.0 - 20.0.
+        """
+        ),
+        default=7.0,
+    )
+
+    group_ebu.add_argument(
+        "-tp",
+        "--true-peak",
+        type=float,
+        help=textwrap.dedent(
+            """\
+        EBU Maximum True Peak in dBTP (default: -2.0).
+        Range is -9.0 - +0.0.
+        """
+        ),
+        default=-2.0,
+    )
+
+    group_ebu.add_argument(
+        "--offset",
+        type=float,
+        help=textwrap.dedent(
+            """\
+        EBU Offset Gain (default: 0.0).
+        The gain is applied before the true-peak limiter in the first pass only.
+        The offset for the second pass will be automatically determined based on the first pass statistics.
+        Range is -99.0 - +99.0.
+        """
+        ),
+        default=0.0,
+    )
+
+    group_ebu.add_argument(
+        "--dual-mono",
+        action="store_true",
+        help=textwrap.dedent(
+            """\
+        Treat mono input files as "dual-mono".
+
+        If a mono file is intended for playback on a stereo system, its EBU R128
+        measurement will be perceptually incorrect. If set, this option will
+        compensate for this effect. Multi-channel input files are not affected
+        by this option.
+        """
+        ),
+    )
+
+    group_acodec = parser.add_argument_group("Audio Encoding")
+    group_acodec.add_argument(
+        "-c:a",
+        "--audio-codec",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Audio codec to use for output files.
+        See `ffmpeg -encoders` for a list.
+
+        Will use PCM audio with input stream bit depth by default.
+        """
+        ),
+    )
+    group_acodec.add_argument(
+        "-b:a",
+        "--audio-bitrate",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Audio bitrate in bits/s, or with K suffix.
+
+        If not specified, will use codec default.
+        """
+        ),
+    )
+    group_acodec.add_argument(
+        "-ar",
+        "--sample-rate",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Audio sample rate to use for output files in Hz.
+
+        Will use input sample rate by default, except for EBU normalization,
+        which will change the input sample rate to 192 kHz.
+        """
+        ),
+    )
+    group_acodec.add_argument(
+        "-koa",
+        "--keep-original-audio",
+        action="store_true",
+        help="Copy original, non-normalized audio streams to output file",
+    )
+    group_acodec.add_argument(
+        "-prf",
+        "--pre-filter",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Add an audio filter chain before applying normalization.
+        Multiple filters can be specified by comma-separating them.
+        """
+        ),
+    )
+    group_acodec.add_argument(
+        "-pof",
+        "--post-filter",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Add an audio filter chain after applying normalization.
+        Multiple filters can be specified by comma-separating them.
+
+        For EBU, the filter will be applied during the second pass.
+        """
+        ),
+    )
+
+    group_vcodec = parser.add_argument_group("Other Encoding Options")
+    group_vcodec.add_argument(
+        "-vn",
+        "--video-disable",
+        action="store_true",
+        help="Do not write video streams to output",
+    )
+    group_vcodec.add_argument(
+        "-c:v",
+        "--video-codec",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Video codec to use for output files (default: 'copy').
+        See `ffmpeg -encoders` for a list.
+
+        Will attempt to copy video codec by default.
+        """
+        ),
+        default="copy",
+    )
+    group_vcodec.add_argument(
+        "-sn",
+        "--subtitle-disable",
+        action="store_true",
+        help="Do not write subtitle streams to output",
+    )
+    group_vcodec.add_argument(
+        "-mn",
+        "--metadata-disable",
+        action="store_true",
+        help="Do not write metadata to output",
+    )
+    group_vcodec.add_argument(
+        "-cn",
+        "--chapters-disable",
+        action="store_true",
+        help="Do not write chapters to output",
+    )
+
+    group_format = parser.add_argument_group("Input/Output options")
+    group_format.add_argument(
+        "-ei",
+        "--extra-input-options",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Extra input options list.
+
+        A list of extra ffmpeg command line arguments valid for the input,
+        applied before ffmpeg's `-i`.
+
+        You can either use a JSON-formatted list (i.e., a list of
+        comma-separated, quoted elements within square brackets), or a simple
+        string of space-separated arguments.
+
+        If JSON is used, you need to wrap the whole argument in quotes to
+        prevent shell expansion and to preserve literal quotes inside the
+        string. If a simple string is used, you need to specify the argument
+        with `-e=`.
+
+        Examples: `-e '[ "-f", "mpegts" ]'` or `-e="-f mpegts"`
+        """
+        ),
+    )
+    group_format.add_argument(
+        "-e",
+        "--extra-output-options",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Extra output options list.
+
+        A list of extra ffmpeg command line arguments.
+
+        You can either use a JSON-formatted list (i.e., a list of
+        comma-separated, quoted elements within square brackets), or a simple
+        string of space-separated arguments.
+
+        If JSON is used, you need to wrap the whole argument in quotes to
+        prevent shell expansion and to preserve literal quotes inside the
+        string. If a simple string is used, you need to specify the argument
+        with `-e=`.
+
+        Examples: `-e '[ "-vbr", "3" ]'` or `-e="-vbr 3"`
+        """
+        ),
+    )
+    group_format.add_argument(
+        "-ofmt",
+        "--output-format",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Media format to use for output file(s).
+        See 'ffmpeg -formats' for a list.
+
+        If not specified, the format will be inferred by ffmpeg from the output
+        file name. If the output file name is not explicitly specified, the
+        extension will govern the format (see '--extension' option).
+        """
+        ),
+    )
+    group_format.add_argument(
+        "-ext",
+        "--extension",
+        type=str,
+        help=textwrap.dedent(
+            """\
+        Output file extension to use for output files that were not explicitly
+        specified. (Default: `mkv`)
+        """
+        ),
+        default="mkv",
+    )
+    return parser
+
+
+def _split_options(opts):
+    """
+    Parse extra options (input or output) into a list
+    """
+    if not opts:
+        return []
+    try:
+        if opts.startswith("["):
+            try:
+                ret = [str(s) for s in json.loads(opts)]
+            except JSONDecodeError:
+                ret = shlex.split(opts)
+        else:
+            ret = shlex.split(opts)
+    except Exception as e:
+        raise FFmpegNormalizeError(f"Could not parse extra_options: {e}")
+    return ret
+
+
+def main():
+    cli_args = create_parser().parse_args()
+
+    if cli_args.quiet:
+        logger.setLevel(logging.ERROR)
+    elif cli_args.debug:
+        logger.setLevel(logging.DEBUG)
+    elif cli_args.verbose:
+        logger.setLevel(logging.INFO)
+
+    # parse extra options
+    extra_input_options = _split_options(cli_args.extra_input_options)
+    extra_output_options = _split_options(cli_args.extra_output_options)
+
+    ffmpeg_normalize = FFmpegNormalize(
+        normalization_type=cli_args.normalization_type,
+        target_level=cli_args.target_level,
+        print_stats=cli_args.print_stats,
+        loudness_range_target=cli_args.loudness_range_target,
+        # threshold=cli_args.threshold,
+        true_peak=cli_args.true_peak,
+        offset=cli_args.offset,
+        dual_mono=cli_args.dual_mono,
+        audio_codec=cli_args.audio_codec,
+        audio_bitrate=cli_args.audio_bitrate,
+        sample_rate=cli_args.sample_rate,
+        keep_original_audio=cli_args.keep_original_audio,
+        pre_filter=cli_args.pre_filter,
+        post_filter=cli_args.post_filter,
+        video_codec=cli_args.video_codec,
+        video_disable=cli_args.video_disable,
+        subtitle_disable=cli_args.subtitle_disable,
+        metadata_disable=cli_args.metadata_disable,
+        chapters_disable=cli_args.chapters_disable,
+        extra_input_options=extra_input_options,
+        extra_output_options=extra_output_options,
+        output_format=cli_args.output_format,
+        dry_run=cli_args.dry_run,
+        progress=cli_args.progress,
+    )
+
+    if (
+        cli_args.output is not None
+        and len(cli_args.output) > 0
+        and len(cli_args.input) > len(cli_args.output)
+    ):
+        logger.warning(
+            "There are more input files than output file names given. "
+            "Please specify one output file name per input file using -o <output1> <output2> ... "
+            "Will apply default file naming for the remaining ones."
+        )
+
+    for index, input_file in enumerate(cli_args.input):
+        if cli_args.output is not None and index < len(cli_args.output):
+            if cli_args.output_folder and cli_args.output_folder != "normalized":
+                logger.warning(
+                    "Output folder {} is ignored for input file {}".format(
+                        cli_args.output_folder, input_file
+                    )
+                )
+            output_file = cli_args.output[index]
+            output_dir = os.path.dirname(output_file)
+            if output_dir != "" and not os.path.isdir(output_dir):
+                raise FFmpegNormalizeError(
+                    f"Output file path {output_dir} does not exist"
+                )
+        else:
+            output_file = os.path.join(
+                cli_args.output_folder,
+                os.path.splitext(os.path.basename(input_file))[0]
+                + "."
+                + cli_args.extension,
+            )
+            if not os.path.isdir(cli_args.output_folder) and not cli_args.dry_run:
+                logger.warning(
+                    "Output directory '{}' does not exist, will create".format(
+                        cli_args.output_folder
+                    )
+                )
+                os.makedirs(cli_args.output_folder)
+
+        if os.path.exists(output_file) and not cli_args.force:
+            logger.error(
+                "Output file {} already exists, skipping. Use -f to force overwriting.".format(
+                    output_file
+                )
+            )
+        else:
+            ffmpeg_normalize.add_media_file(input_file, output_file)
+
+    ffmpeg_normalize.run_normalization()
+
+
+if __name__ == "__main__":
+    main()

lib/ffmpeg_normalize/_cmd_utils.py

@@ -0,0 +1,177 @@
+from __future__ import division
+import os
+import sys
+import subprocess
+from platform import system as _current_os
+import re
+from ffmpeg_progress_yield import FfmpegProgress
+
+from ._errors import FFmpegNormalizeError
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+CUR_OS = _current_os()
+IS_WIN = CUR_OS in ["Windows", "cli"]
+IS_NIX = (not IS_WIN) and any(
+    CUR_OS.startswith(i)
+    for i in ["CYGWIN", "MSYS", "Linux", "Darwin", "SunOS", "FreeBSD", "NetBSD"]
+)
+NUL = "NUL" if IS_WIN else "/dev/null"
+DUR_REGEX = re.compile(
+    r"Duration: (?P<hour>\d{2}):(?P<min>\d{2}):(?P<sec>\d{2})\.(?P<ms>\d{2})"
+)
+
+
+# https://gist.github.com/Hellowlol/5f8545e999259b4371c91ac223409209
+def to_ms(s=None, des=None, **kwargs):
+    if s:
+        hour = int(s[0:2])
+        minute = int(s[3:5])
+        sec = int(s[6:8])
+        ms = int(s[10:11])
+    else:
+        hour = int(kwargs.get("hour", 0))
+        minute = int(kwargs.get("min", 0))
+        sec = int(kwargs.get("sec", 0))
+        ms = int(kwargs.get("ms"))
+
+    result = (hour * 60 * 60 * 1000) + (minute * 60 * 1000) + (sec * 1000) + ms
+    if des and isinstance(des, int):
+        return round(result, des)
+    return result
+
+
+class CommandRunner:
+    def __init__(self, cmd, dry=False):
+        self.cmd = cmd
+        self.dry = dry
+        self.output = None
+
+    def run_ffmpeg_command(self):
+        # wrapper for 'ffmpeg-progress-yield'
+        ff = FfmpegProgress(self.cmd, dry_run=self.dry)
+        for progress in ff.run_command_with_progress():
+            yield progress
+
+        self.output = ff.stderr
+
+    def run_command(self):
+        logger.debug(f"Running command: {self.cmd}")
+
+        if self.dry:
+            logger.debug("Dry mode specified, not actually running command")
+            return
+
+        p = subprocess.Popen(
+            self.cmd,
+            stdin=subprocess.PIPE,  # Apply stdin isolation by creating separate pipe.
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            universal_newlines=False,
+        )
+
+        # simple running of command
+        stdout, stderr = p.communicate()
+
+        stdout = stdout.decode("utf8", errors="replace")
+        stderr = stderr.decode("utf8", errors="replace")
+
+        if p.returncode == 0:
+            self.output = stdout + stderr
+        else:
+            raise RuntimeError(
+                f"Error running command {self.cmd}: {str(stderr)}"
+            )
+
+    def get_output(self):
+        return self.output
+
+
+def which(program):
+    """
+    Find a program in PATH and return path
+    From: http://stackoverflow.com/q/377017/
+    """
+
+    def is_exe(fpath):
+        found = os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+        if not found and sys.platform == "win32":
+            fpath = fpath + ".exe"
+            found = os.path.isfile(fpath) and os.access(fpath, os.X_OK)
+        return found
+
+    fpath, _ = os.path.split(program)
+    if fpath:
+        if is_exe(program):
+            logger.debug("found executable: " + str(program))
+            return program
+    else:
+        for path in os.environ["PATH"].split(os.pathsep):
+            path = os.path.expandvars(os.path.expanduser(path)).strip('"')
+            exe_file = os.path.join(path, program)
+            if is_exe(exe_file):
+                logger.debug("found executable in path: " + str(exe_file))
+                return exe_file
+
+    return None
+
+
+def dict_to_filter_opts(opts):
+    filter_opts = []
+    for k, v in opts.items():
+        filter_opts.append(f"{k}={v}")
+    return ":".join(filter_opts)
+
+
+# def get_ffmpeg_exe():
+#     """
+#     Return path to ffmpeg executable
+#     """
+#     ffmpeg_path = os.getenv("FFMPEG_PATH")
+#     if ffmpeg_path:
+#         if os.sep in ffmpeg_path:
+#             ffmpeg_exe = ffmpeg_path
+#             if not os.path.isfile(ffmpeg_exe):
+#                 raise FFmpegNormalizeError(f"No file exists at {ffmpeg_exe}")
+#         else:
+#             ffmpeg_exe = which(ffmpeg_path)
+#             if not ffmpeg_exe:
+#                 raise FFmpegNormalizeError(
+#                     f"Could not find '{ffmpeg_path}' in your $PATH."
+#                 )
+#     else:
+#         ffmpeg_exe = which("ffmpeg")
+
+#     if not ffmpeg_exe:
+#         if which("avconv"):
+#             raise FFmpegNormalizeError(
+#                 "avconv is not supported. "
+#                 "Please install ffmpeg from http://ffmpeg.org instead."
+#             )
+#         else:
+#             raise FFmpegNormalizeError(
+#                 "Could not find ffmpeg in your $PATH or $FFMPEG_PATH. "
+#                 "Please install ffmpeg from http://ffmpeg.org"
+#             )
+
+#     return ffmpeg_exe
+
+
+def ffmpeg_has_loudnorm(ffmpeg_path):
+    """
+    Run feature detection on ffmpeg, returns True if ffmpeg supports
+    the loudnorm filter
+    """
+    # cmd_runner = CommandRunner([get_ffmpeg_exe(), "-filters"])
+    cmd_runner = CommandRunner([ffmpeg_path, "-filters"])
+    cmd_runner.run_command()
+    output = cmd_runner.get_output()
+    if "loudnorm" in output:
+        return True
+    else:
+        logger.error(
+            "Your ffmpeg version does not support the 'loudnorm' filter. "
+            "Please make sure you are running ffmpeg v3.1 or above."
+        )
+        return False

lib/ffmpeg_normalize/_errors.py

@@ -0,0 +1,15 @@
+import sys
+import logging
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+
+class FFmpegNormalizeError(Exception):
+    def __init__(self, message):
+        super(FFmpegNormalizeError, self).__init__(message)
+        if logger.getEffectiveLevel() == logging.DEBUG:
+            logger.error(f"{self.__class__.__name__}: {message}")
+        else:
+            logger.error(message)
+            sys.exit(1)

lib/ffmpeg_normalize/_ffmpeg_normalize.py

@@ -0,0 +1,202 @@
+import os
+import json
+from numbers import Number
+from tqdm import tqdm
+
+from ._cmd_utils import ffmpeg_has_loudnorm # get_ffmpeg_exe
+from ._media_file import MediaFile
+from ._errors import FFmpegNormalizeError
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+NORMALIZATION_TYPES = ["ebu", "rms", "peak"]
+PCM_INCOMPATIBLE_FORMATS = ["mp4", "mp3", "ogg", "webm"]
+PCM_INCOMPATIBLE_EXTS = ["mp4", "m4a", "mp3", "ogg", "webm"]
+
+
+def check_range(number, min_r, max_r, name=""):
+    """
+    Check if a number is within a given range
+    """
+    try:
+        number = float(number)
+        if number < min_r or number > max_r:
+            raise FFmpegNormalizeError(
+                f"{name} must be within [{min_r},{max_r}]"
+            )
+        return number
+        pass
+    except Exception as e:
+        raise e
+
+
+class FFmpegNormalize:
+    """
+    ffmpeg-normalize class.
+    """
+
+    def __init__(
+        self,
+        normalization_type="ebu",
+        target_level=-23.0,
+        print_stats=False,
+        # threshold=0.5,
+        loudness_range_target=7.0,
+        true_peak=-2.0,
+        offset=0.0,
+        dual_mono=False,
+        audio_codec="pcm_s16le",
+        audio_bitrate=None,
+        sample_rate=None,
+        keep_original_audio=False,
+        pre_filter=None,
+        post_filter=None,
+        video_codec="copy",
+        video_disable=False,
+        subtitle_disable=False,
+        metadata_disable=False,
+        chapters_disable=False,
+        extra_input_options=None,
+        extra_output_options=None,
+        output_format=None,
+        dry_run=False,
+        debug=False,
+        progress=False,
+        ffmpeg_exe=None
+    ):
+        # self.ffmpeg_exe = get_ffmpeg_exe()
+        self.ffmpeg_exe = ffmpeg_exe
+        self.has_loudnorm_capabilities = ffmpeg_has_loudnorm(self.ffmpeg_exe)
+
+        self.normalization_type = normalization_type
+        if not self.has_loudnorm_capabilities and self.normalization_type == "ebu":
+            raise FFmpegNormalizeError(
+                "Your ffmpeg version does not support the 'loudnorm' EBU R128 filter. "
+                "Please install ffmpeg v3.1 or above, or choose another normalization type."
+            )
+
+        if self.normalization_type == "ebu":
+            self.target_level = check_range(target_level, -70, -5, name="target_level")
+        else:
+            self.target_level = check_range(target_level, -99, 0, name="target_level")
+
+        self.print_stats = print_stats
+
+        # self.threshold = float(threshold)
+
+        self.loudness_range_target = check_range(
+            loudness_range_target, 1, 20, name="loudness_range_target"
+        )
+        self.true_peak = check_range(true_peak, -9, 0, name="true_peak")
+        self.offset = check_range(offset, -99, 99, name="offset")
+
+        self.dual_mono = True if dual_mono in ["true", True] else False
+        self.audio_codec = audio_codec
+        self.audio_bitrate = audio_bitrate
+        self.sample_rate = int(sample_rate) if sample_rate is not None else None
+        self.keep_original_audio = keep_original_audio
+        self.video_codec = video_codec
+        self.video_disable = video_disable
+        self.subtitle_disable = subtitle_disable
+        self.metadata_disable = metadata_disable
+        self.chapters_disable = chapters_disable
+
+        self.extra_input_options = extra_input_options
+        self.extra_output_options = extra_output_options
+        self.pre_filter = pre_filter
+        self.post_filter = post_filter
+
+        self.output_format = output_format
+        self.dry_run = dry_run
+        self.debug = debug
+        self.progress = progress
+
+        self.stats = []
+
+        if (
+            self.output_format
+            and (self.audio_codec is None or "pcm" in self.audio_codec)
+            and self.output_format in PCM_INCOMPATIBLE_FORMATS
+        ):
+            raise FFmpegNormalizeError(
+                f"Output format {self.output_format} does not support PCM audio. "
+                + "Please choose a suitable audio codec with the -c:a option."
+            )
+
+        if normalization_type not in NORMALIZATION_TYPES:
+            raise FFmpegNormalizeError(
+                f"Normalization type must be one of {NORMALIZATION_TYPES}"
+            )
+
+        if self.target_level and not isinstance(self.target_level, Number):
+            raise FFmpegNormalizeError("target_level must be a number")
+
+        if self.loudness_range_target and not isinstance(
+            self.loudness_range_target, Number
+        ):
+            raise FFmpegNormalizeError("loudness_range_target must be a number")
+
+        if self.true_peak and not isinstance(self.true_peak, Number):
+            raise FFmpegNormalizeError("true_peak must be a number")
+
+        if float(target_level) > 0:
+            raise FFmpegNormalizeError("Target level must be below 0")
+
+        self.media_files = []
+        self.file_count = 0
+
+    def add_media_file(self, input_file, output_file):
+        """
+        Add a media file to normalize
+
+        Arguments:
+            input_file {str} -- Path to input file
+            output_file {str} -- Path to output file
+        """
+        if not os.path.exists(input_file):
+            raise FFmpegNormalizeError("file " + input_file + " does not exist")
+
+        ext = os.path.splitext(output_file)[1][1:]
+        if (
+            self.audio_codec is None or "pcm" in self.audio_codec
+        ) and ext in PCM_INCOMPATIBLE_EXTS:
+            raise FFmpegNormalizeError(
+                f"Output extension {ext} does not support PCM audio. " +
+                "Please choose a suitable audio codec with the -c:a option."
+            )
+
+        mf = MediaFile(self, input_file, output_file)
+        self.media_files.append(mf)
+
+        self.file_count += 1
+
+    def run_normalization(self):
+        """
+        Run the normalization procedures
+        """
+        for index, media_file in enumerate(
+            tqdm(self.media_files, desc="File", disable=not self.progress, position=0)
+        ):
+            logger.info(
+                f"Normalizing file {media_file} ({index + 1} of {self.file_count})"
+            )
+
+            try:
+                media_file.run_normalization()
+            except Exception as e:
+                if len(self.media_files) > 1:
+                    # simply warn and do not die
+                    logger.error(
+                        "Error processing input file {}, will continue batch-processing. Error was: {}".format(
+                            media_file, e
+                        )
+                    )
+                else:
+                    # raise the error so the program will exit
+                    raise e
+
+            logger.info(f"Normalized file written to {media_file.output_file}")
+
+        if self.print_stats and self.stats:
+            print(json.dumps(self.stats, indent=4))

lib/ffmpeg_normalize/_logger.py

@@ -0,0 +1,83 @@
+import logging
+from platform import system
+from tqdm import tqdm
+import sys
+
+loggers = {}
+
+
+# https://stackoverflow.com/questions/38543506/
+class TqdmLoggingHandler(logging.StreamHandler):
+    def __init__(self):
+        super().__init__(sys.stderr)
+
+    def emit(self, record):
+        try:
+            msg = self.format(record)
+            set_mp_lock()
+            tqdm.write(msg, file=sys.stderr)
+            self.flush()
+        except (KeyboardInterrupt, SystemExit):
+            raise
+        except Exception:
+            self.handleError(record)
+
+def set_mp_lock():
+    try:
+        from multiprocessing import Lock
+        tqdm.set_lock(Lock())
+    except (ImportError, OSError):
+        # Some python environments do not support multiprocessing
+        # See: https://github.com/slhck/ffmpeg-normalize/issues/156
+        pass
+
+def setup_custom_logger(name):
+    """
+    Create a logger with a certain name and level
+    """
+    global loggers
+
+    if loggers.get(name):
+        return loggers.get(name)
+
+    formatter = logging.Formatter(fmt="%(levelname)s: %(message)s")
+
+    # handler = logging.StreamHandler()
+    handler = TqdmLoggingHandler()
+    handler.setFormatter(formatter)
+
+    # \033[1;30m - black
+    # \033[1;31m - red
+    # \033[1;32m - green
+    # \033[1;33m - yellow
+    # \033[1;34m - blue
+    # \033[1;35m - magenta
+    # \033[1;36m - cyan
+    # \033[1;37m - white
+
+    if system() not in ["Windows", "cli"]:
+        logging.addLevelName(
+            logging.ERROR, f"{logging.getLevelName(logging.ERROR)}"
+        )
+        logging.addLevelName(
+            logging.WARNING,
+            f"{logging.getLevelName(logging.WARNING)}",
+        )
+        logging.addLevelName(
+            logging.INFO, f"{logging.getLevelName(logging.INFO)}"
+        )
+        logging.addLevelName(
+            logging.DEBUG, f"{logging.getLevelName(logging.DEBUG)}"
+        )
+
+    logger = logging.getLogger(name)
+    logger.setLevel(logging.WARNING)
+
+    # if (logger.hasHandlers()):
+    #     logger.handlers.clear()
+    if logger.handlers:
+        logger.handlers = []
+    logger.addHandler(handler)
+    loggers.update(dict(name=logger))
+
+    return logger

lib/ffmpeg_normalize/_media_file.py

@@ -0,0 +1,371 @@
+import os
+import re
+import tempfile
+import shutil
+from tqdm import tqdm
+import shlex
+
+from ._streams import AudioStream, VideoStream, SubtitleStream
+from ._errors import FFmpegNormalizeError
+from ._cmd_utils import NUL, CommandRunner, DUR_REGEX, to_ms
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+
+class MediaFile:
+    """
+    Class that holds a file, its streams and adjustments
+    """
+
+    def __init__(self, ffmpeg_normalize, input_file, output_file=None):
+        """
+        Initialize a media file for later normalization.
+
+        Arguments:
+            ffmpeg_normalize {FFmpegNormalize} -- reference to overall settings
+            input_file {str} -- Path to input file
+
+        Keyword Arguments:
+            output_file {str} -- Path to output file (default: {None})
+        """
+        self.ffmpeg_normalize = ffmpeg_normalize
+        self.skip = False
+        self.input_file = input_file
+        self.output_file = output_file
+        self.streams = {"audio": {}, "video": {}, "subtitle": {}}
+
+        self.parse_streams()
+
+    def _stream_ids(self):
+        return (
+            list(self.streams["audio"].keys())
+            + list(self.streams["video"].keys())
+            + list(self.streams["subtitle"].keys())
+        )
+
+    def __repr__(self):
+        return os.path.basename(self.input_file)
+
+    def parse_streams(self):
+        """
+        Try to parse all input streams from file
+        """
+        logger.debug(f"Parsing streams of {self.input_file}")
+
+        cmd = [
+            self.ffmpeg_normalize.ffmpeg_exe,
+            "-i",
+            self.input_file,
+            "-c",
+            "copy",
+            "-t",
+            "0",
+            "-map",
+            "0",
+            "-f",
+            "null",
+            NUL,
+        ]
+
+        cmd_runner = CommandRunner(cmd)
+        cmd_runner.run_command()
+        output = cmd_runner.get_output()
+
+        logger.debug("Stream parsing command output:")
+        logger.debug(output)
+
+        output_lines = [line.strip() for line in output.split("\n")]
+
+        duration = None
+        for line in output_lines:
+
+            if "Duration" in line:
+                duration_search = DUR_REGEX.search(line)
+                if not duration_search:
+                    logger.warning("Could not extract duration from input file!")
+                else:
+                    duration = duration_search.groupdict()
+                    duration = to_ms(**duration) / 1000
+                    logger.debug("Found duration: " + str(duration) + " s")
+
+            if not line.startswith("Stream"):
+                continue
+
+            stream_id_match = re.search(r"#0:([\d]+)", line)
+            if stream_id_match:
+                stream_id = int(stream_id_match.group(1))
+                if stream_id in self._stream_ids():
+                    continue
+            else:
+                continue
+
+            if "Audio" in line:
+                logger.debug(f"Found audio stream at index {stream_id}")
+                sample_rate_match = re.search(r"(\d+) Hz", line)
+                sample_rate = (
+                    int(sample_rate_match.group(1)) if sample_rate_match else None
+                )
+                bit_depth_match = re.search(r"s(\d+)p?,", line)
+                bit_depth = int(bit_depth_match.group(1)) if bit_depth_match else None
+                self.streams["audio"][stream_id] = AudioStream(
+                    self,
+                    self.ffmpeg_normalize,
+                    stream_id,
+                    sample_rate,
+                    bit_depth,
+                    duration,
+                )
+
+            elif "Video" in line:
+                logger.debug(f"Found video stream at index {stream_id}")
+                self.streams["video"][stream_id] = VideoStream(
+                    self, self.ffmpeg_normalize, stream_id
+                )
+
+            elif "Subtitle" in line:
+                logger.debug(f"Found subtitle stream at index {stream_id}")
+                self.streams["subtitle"][stream_id] = SubtitleStream(
+                    self, self.ffmpeg_normalize, stream_id
+                )
+
+        if not self.streams["audio"]:
+            raise FFmpegNormalizeError(
+                f"Input file {self.input_file} does not contain any audio streams"
+            )
+
+        if (
+            os.path.splitext(self.output_file)[1].lower() in [".wav", ".mp3", ".aac"]
+            and len(self.streams["audio"].values()) > 1
+        ):
+            logger.warning(
+                "Output file only supports one stream. "
+                "Keeping only first audio stream."
+            )
+            first_stream = list(self.streams["audio"].values())[0]
+            self.streams["audio"] = {first_stream.stream_id: first_stream}
+            self.streams["video"] = {}
+            self.streams["subtitle"] = {}
+
+    def run_normalization(self):
+        logger.debug(f"Running normalization for {self.input_file}")
+
+        # run the first pass to get loudness stats
+        self._first_pass()
+
+        # run the second pass as a whole
+        if self.ffmpeg_normalize.progress:
+            with tqdm(total=100, position=1, desc="Second Pass") as pbar:
+                for progress in self._second_pass():
+                    pbar.update(progress - pbar.n)
+        else:
+            for _ in self._second_pass():
+                pass
+
+    def _first_pass(self):
+        logger.debug(f"Parsing normalization info for {self.input_file}")
+
+        for index, audio_stream in enumerate(self.streams["audio"].values()):
+            if self.ffmpeg_normalize.normalization_type == "ebu":
+                fun = getattr(audio_stream, "parse_loudnorm_stats")
+            else:
+                fun = getattr(audio_stream, "parse_volumedetect_stats")
+
+            if self.ffmpeg_normalize.progress:
+                with tqdm(
+                    total=100,
+                    position=1,
+                    desc=f"Stream {index + 1}/{len(self.streams['audio'].values())}",
+                ) as pbar:
+                    for progress in fun():
+                        pbar.update(progress - pbar.n)
+            else:
+                for _ in fun():
+                    pass
+
+        if self.ffmpeg_normalize.print_stats:
+            stats = [
+                audio_stream.get_stats()
+                for audio_stream in self.streams["audio"].values()
+            ]
+            self.ffmpeg_normalize.stats.extend(stats)
+
+    def _get_audio_filter_cmd(self):
+        """
+        Return filter_complex command and output labels needed
+        """
+        filter_chains = []
+        output_labels = []
+
+        for audio_stream in self.streams["audio"].values():
+            if self.ffmpeg_normalize.normalization_type == "ebu":
+                normalization_filter = audio_stream.get_second_pass_opts_ebu()
+            else:
+                normalization_filter = audio_stream.get_second_pass_opts_peakrms()
+
+            input_label = f"[0:{audio_stream.stream_id}]"
+            output_label = f"[norm{audio_stream.stream_id}]"
+            output_labels.append(output_label)
+
+            filter_chain = []
+
+            if self.ffmpeg_normalize.pre_filter:
+                filter_chain.append(self.ffmpeg_normalize.pre_filter)
+
+            filter_chain.append(normalization_filter)
+
+            if self.ffmpeg_normalize.post_filter:
+                filter_chain.append(self.ffmpeg_normalize.post_filter)
+
+            filter_chains.append(input_label + ",".join(filter_chain) + output_label)
+
+        filter_complex_cmd = ";".join(filter_chains)
+
+        return filter_complex_cmd, output_labels
+
+    def _second_pass(self):
+        """
+        Construct the second pass command and run it
+
+        FIXME: make this method simpler
+        """
+        logger.info(f"Running second pass for {self.input_file}")
+
+        # get the target output stream types depending on the options
+        output_stream_types = ["audio"]
+        if not self.ffmpeg_normalize.video_disable:
+            output_stream_types.append("video")
+        if not self.ffmpeg_normalize.subtitle_disable:
+            output_stream_types.append("subtitle")
+
+        # base command, here we will add all other options
+        cmd = [self.ffmpeg_normalize.ffmpeg_exe, "-y", "-nostdin"]
+
+        # extra options (if any)
+        if self.ffmpeg_normalize.extra_input_options:
+            cmd.extend(self.ffmpeg_normalize.extra_input_options)
+
+        # get complex filter command
+        audio_filter_cmd, output_labels = self._get_audio_filter_cmd()
+
+        # add input file and basic filter
+        cmd.extend(["-i", self.input_file, "-filter_complex", audio_filter_cmd])
+
+        # map metadata, only if needed
+        if self.ffmpeg_normalize.metadata_disable:
+            cmd.extend(["-map_metadata", "-1"])
+        else:
+            # map global metadata
+            cmd.extend(["-map_metadata", "0"])
+            # map per-stream metadata (e.g. language tags)
+            for stream_type in output_stream_types:
+                stream_key = stream_type[0]
+                if stream_type not in self.streams:
+                    continue
+                for idx, _ in enumerate(self.streams[stream_type].items()):
+                    cmd.extend(
+                        [
+                            f"-map_metadata:s:{stream_key}:{idx}",
+                            f"0:s:{stream_key}:{idx}",
+                        ]
+                    )
+
+        # map chapters if needed
+        if self.ffmpeg_normalize.chapters_disable:
+            cmd.extend(["-map_chapters", "-1"])
+        else:
+            cmd.extend(["-map_chapters", "0"])
+
+        # collect all '-map' and codecs needed for output video based on input video
+        if not self.ffmpeg_normalize.video_disable:
+            for s in self.streams["video"].keys():
+                cmd.extend(["-map", f"0:{s}"])
+            # set codec (copy by default)
+            cmd.extend(["-c:v", self.ffmpeg_normalize.video_codec])
+
+        # ... and map the output of the normalization filters
+        for ol in output_labels:
+            cmd.extend(["-map", ol])
+
+        # set audio codec (never copy)
+        if self.ffmpeg_normalize.audio_codec:
+            cmd.extend(["-c:a", self.ffmpeg_normalize.audio_codec])
+        else:
+            for index, (_, audio_stream) in enumerate(self.streams["audio"].items()):
+                cmd.extend([f"-c:a:{index}", audio_stream.get_pcm_codec()])
+
+        # other audio options (if any)
+        if self.ffmpeg_normalize.audio_bitrate:
+            cmd.extend(["-b:a", str(self.ffmpeg_normalize.audio_bitrate)])
+        if self.ffmpeg_normalize.sample_rate:
+            cmd.extend(["-ar", str(self.ffmpeg_normalize.sample_rate)])
+        else:
+            if self.ffmpeg_normalize.normalization_type == "ebu":
+                logger.warn(
+                    "The sample rate will automatically be set to 192 kHz by the loudnorm filter. "
+                    "Specify -ar/--sample-rate to override it."
+                )
+
+        # ... and subtitles
+        if not self.ffmpeg_normalize.subtitle_disable:
+            for s in self.streams["subtitle"].keys():
+                cmd.extend(["-map", f"0:{s}"])
+            # copy subtitles
+            cmd.extend(["-c:s", "copy"])
+
+        if self.ffmpeg_normalize.keep_original_audio:
+            highest_index = len(self.streams["audio"])
+            for index, (_, s) in enumerate(self.streams["audio"].items()):
+                cmd.extend(["-map", f"0:a:{index}"])
+                cmd.extend([f"-c:a:{highest_index + index}", "copy"])
+
+        # extra options (if any)
+        if self.ffmpeg_normalize.extra_output_options:
+            cmd.extend(self.ffmpeg_normalize.extra_output_options)
+
+        # output format (if any)
+        if self.ffmpeg_normalize.output_format:
+            cmd.extend(["-f", self.ffmpeg_normalize.output_format])
+
+        # if dry run, only show sample command
+        if self.ffmpeg_normalize.dry_run:
+            cmd.append(self.output_file)
+            cmd_runner = CommandRunner(cmd, dry=True)
+            cmd_runner.run_command()
+            yield 100
+            return
+
+        # create a temporary output file name
+        temp_dir = tempfile.gettempdir()
+        output_file_suffix = os.path.splitext(self.output_file)[1]
+        temp_file_name = os.path.join(
+            temp_dir, next(tempfile._get_candidate_names()) + output_file_suffix
+        )
+        cmd.append(temp_file_name)
+
+        # run the actual command
+        try:
+            cmd_runner = CommandRunner(cmd)
+            try:
+                for progress in cmd_runner.run_ffmpeg_command():
+                    yield progress
+            except Exception as e:
+                logger.error(
+                    "Error while running command {}! Error: {}".format(
+                        " ".join([shlex.quote(c) for c in cmd]), e
+                    )
+                )
+                raise e
+            else:
+                # move file from TMP to output file
+                logger.debug(
+                    f"Moving temporary file from {temp_file_name} to {self.output_file}"
+                )
+                shutil.move(temp_file_name, self.output_file)
+        except Exception as e:
+            # remove dangling temporary file
+            if os.path.isfile(temp_file_name):
+                os.remove(temp_file_name)
+            raise e
+
+        logger.debug("Normalization finished")

lib/ffmpeg_normalize/_streams.py

@@ -0,0 +1,344 @@
+import os
+import re
+import json
+import math
+
+from ._errors import FFmpegNormalizeError
+from ._cmd_utils import NUL, CommandRunner, dict_to_filter_opts
+from ._logger import setup_custom_logger
+
+logger = setup_custom_logger("ffmpeg_normalize")
+
+
+class MediaStream(object):
+    def __init__(self, ffmpeg_normalize, media_file, stream_type, stream_id):
+        """
+        Arguments:
+            media_file {MediaFile} -- parent media file
+            stream_type {str} -- stream type
+            stream_id {int} -- Audio stream id
+        """
+        self.ffmpeg_normalize = ffmpeg_normalize
+        self.media_file = media_file
+        self.stream_type = stream_type
+        self.stream_id = stream_id
+
+    def __repr__(self):
+        return "<{}, {} stream {}>".format(
+            os.path.basename(self.media_file.input_file),
+            self.stream_type,
+            self.stream_id,
+        )
+
+
+class VideoStream(MediaStream):
+    def __init__(self, ffmpeg_normalize, media_file, stream_id):
+        super(VideoStream, self).__init__(
+            media_file, ffmpeg_normalize, "video", stream_id
+        )
+
+
+class SubtitleStream(MediaStream):
+    def __init__(self, ffmpeg_normalize, media_file, stream_id):
+        super(SubtitleStream, self).__init__(
+            media_file, ffmpeg_normalize, "subtitle", stream_id
+        )
+
+
+class AudioStream(MediaStream):
+    def __init__(
+        self,
+        ffmpeg_normalize,
+        media_file,
+        stream_id,
+        sample_rate=None,
+        bit_depth=None,
+        duration=None,
+    ):
+        """
+        Arguments:
+            sample_rate {int} -- in Hz
+            bit_depth {int}
+            duration {int} -- duration in seconds
+        """
+        super(AudioStream, self).__init__(
+            media_file, ffmpeg_normalize, "audio", stream_id
+        )
+
+        self.loudness_statistics = {"ebu": None, "mean": None, "max": None}
+
+        self.sample_rate = sample_rate
+        self.bit_depth = bit_depth
+        self.duration = duration
+
+        if (
+            self.ffmpeg_normalize.normalization_type == "ebu"
+            and self.duration
+            and self.duration <= 3
+        ):
+            logger.warn(
+                "Audio stream has a duration of less than 3 seconds. "
+                "Normalization may not work. "
+                "See https://github.com/slhck/ffmpeg-normalize/issues/87 for more info."
+            )
+
+    def __repr__(self):
+        return "<{}, audio stream {}>".format(
+            os.path.basename(self.media_file.input_file), self.stream_id
+        )
+
+    def get_stats(self):
+        """
+        Return statistics
+        """
+        stats = {
+            "input_file": self.media_file.input_file,
+            "output_file": self.media_file.output_file,
+            "stream_id": self.stream_id,
+        }
+        stats.update(self.loudness_statistics)
+        return stats
+
+    def get_pcm_codec(self):
+        if not self.bit_depth:
+            return "pcm_s16le"
+        elif self.bit_depth <= 8:
+            return "pcm_s8"
+        elif self.bit_depth in [16, 24, 32, 64]:
+            return f"pcm_s{self.bit_depth}le"
+        else:
+            logger.warning(
+                f"Unsupported bit depth {self.bit_depth}, falling back to pcm_s16le"
+            )
+            return "pcm_s16le"
+
+    def _get_filter_str_with_pre_filter(self, current_filter):
+        """
+        Get a filter string for current_filter, with the pre-filter
+        added before. Applies the input label before.
+        """
+        input_label = f"[0:{self.stream_id}]"
+        filter_chain = []
+        if self.media_file.ffmpeg_normalize.pre_filter:
+            filter_chain.append(self.media_file.ffmpeg_normalize.pre_filter)
+        filter_chain.append(current_filter)
+        filter_str = input_label + ",".join(filter_chain)
+        return filter_str
+
+    def parse_volumedetect_stats(self):
+        """
+        Use ffmpeg with volumedetect filter to get the mean volume of the input file.
+        """
+        logger.info(
+            f"Running first pass volumedetect filter for stream {self.stream_id}"
+        )
+
+        filter_str = self._get_filter_str_with_pre_filter("volumedetect")
+
+        cmd = [
+            self.media_file.ffmpeg_normalize.ffmpeg_exe,
+            "-nostdin",
+            "-y",
+            "-i",
+            self.media_file.input_file,
+            "-filter_complex",
+            filter_str,
+            "-vn",
+            "-sn",
+            "-f",
+            "null",
+            NUL,
+        ]
+
+        cmd_runner = CommandRunner(cmd)
+        for progress in cmd_runner.run_ffmpeg_command():
+            yield progress
+        output = cmd_runner.get_output()
+
+        logger.debug("Volumedetect command output:")
+        logger.debug(output)
+
+        mean_volume_matches = re.findall(r"mean_volume: ([\-\d\.]+) dB", output)
+        if mean_volume_matches:
+            self.loudness_statistics["mean"] = float(mean_volume_matches[0])
+        else:
+            raise FFmpegNormalizeError(
+                f"Could not get mean volume for {self.media_file.input_file}"
+            )
+
+        max_volume_matches = re.findall(r"max_volume: ([\-\d\.]+) dB", output)
+        if max_volume_matches:
+            self.loudness_statistics["max"] = float(max_volume_matches[0])
+        else:
+            raise FFmpegNormalizeError(
+                f"Could not get max volume for {self.media_file.input_file}"
+            )
+
+    def parse_loudnorm_stats(self):
+        """
+        Run a first pass loudnorm filter to get measured data.
+        """
+        logger.info(f"Running first pass loudnorm filter for stream {self.stream_id}")
+
+        opts = {
+            "i": self.media_file.ffmpeg_normalize.target_level,
+            "lra": self.media_file.ffmpeg_normalize.loudness_range_target,
+            "tp": self.media_file.ffmpeg_normalize.true_peak,
+            "offset": self.media_file.ffmpeg_normalize.offset,
+            "print_format": "json",
+        }
+
+        if self.media_file.ffmpeg_normalize.dual_mono:
+            opts["dual_mono"] = "true"
+
+        filter_str = self._get_filter_str_with_pre_filter(
+            "loudnorm=" + dict_to_filter_opts(opts)
+        )
+
+        cmd = [
+            self.media_file.ffmpeg_normalize.ffmpeg_exe,
+            "-nostdin",
+            "-y",
+            "-i",
+            self.media_file.input_file,
+            "-filter_complex",
+            filter_str,
+            "-vn",
+            "-sn",
+            "-f",
+            "null",
+            NUL,
+        ]
+
+        cmd_runner = CommandRunner(cmd)
+        for progress in cmd_runner.run_ffmpeg_command():
+            yield progress
+        output = cmd_runner.get_output()
+
+        logger.debug("Loudnorm first pass command output:")
+        logger.debug(output)
+
+        output_lines = [line.strip() for line in output.split("\n")]
+
+        self.loudness_statistics["ebu"] = AudioStream._parse_loudnorm_output(
+            output_lines
+        )
+
+    @staticmethod
+    def _parse_loudnorm_output(output_lines):
+        loudnorm_start = False
+        loudnorm_end = False
+        for index, line in enumerate(output_lines):
+            if line.startswith("[Parsed_loudnorm"):
+                loudnorm_start = index + 1
+                continue
+            if loudnorm_start and line.startswith("}"):
+                loudnorm_end = index + 1
+                break
+
+        if not (loudnorm_start and loudnorm_end):
+            raise FFmpegNormalizeError(
+                "Could not parse loudnorm stats; no loudnorm-related output found"
+            )
+
+        try:
+            loudnorm_stats = json.loads(
+                "\n".join(output_lines[loudnorm_start:loudnorm_end])
+            )
+
+            logger.debug(f"Loudnorm stats parsed: {json.dumps(loudnorm_stats)}")
+
+            for key in [
+                "input_i",
+                "input_tp",
+                "input_lra",
+                "input_thresh",
+                "output_i",
+                "output_tp",
+                "output_lra",
+                "output_thresh",
+                "target_offset",
+            ]:
+                # handle infinite values
+                if float(loudnorm_stats[key]) == -float("inf"):
+                    loudnorm_stats[key] = -99
+                elif float(loudnorm_stats[key]) == float("inf"):
+                    loudnorm_stats[key] = 0
+                else:
+                    # convert to floats
+                    loudnorm_stats[key] = float(loudnorm_stats[key])
+
+            return loudnorm_stats
+        except Exception as e:
+            raise FFmpegNormalizeError(
+                f"Could not parse loudnorm stats; wrong JSON format in string: {e}"
+            )
+
+    def get_second_pass_opts_ebu(self):
+        """
+        Return second pass loudnorm filter options string for ffmpeg
+        """
+
+        if not self.loudness_statistics["ebu"]:
+            raise FFmpegNormalizeError(
+                "First pass not run, you must call parse_loudnorm_stats first"
+            )
+
+        input_i = float(self.loudness_statistics["ebu"]["input_i"])
+        if input_i > 0:
+            logger.warn(
+                "Input file had measured input loudness greater than zero ({}), capping at 0".format(
+                    "input_i"
+                )
+            )
+            self.loudness_statistics["ebu"]["input_i"] = 0
+
+        opts = {
+            "i": self.media_file.ffmpeg_normalize.target_level,
+            "lra": self.media_file.ffmpeg_normalize.loudness_range_target,
+            "tp": self.media_file.ffmpeg_normalize.true_peak,
+            "offset": float(self.loudness_statistics["ebu"]["target_offset"]),
+            "measured_i": float(self.loudness_statistics["ebu"]["input_i"]),
+            "measured_lra": float(self.loudness_statistics["ebu"]["input_lra"]),
+            "measured_tp": float(self.loudness_statistics["ebu"]["input_tp"]),
+            "measured_thresh": float(self.loudness_statistics["ebu"]["input_thresh"]),
+            "linear": "true",
+            "print_format": "json",
+        }
+
+        if self.media_file.ffmpeg_normalize.dual_mono:
+            opts["dual_mono"] = "true"
+
+        return "loudnorm=" + dict_to_filter_opts(opts)
+
+    def get_second_pass_opts_peakrms(self):
+        """
+        Set the adjustment gain based on chosen option and mean/max volume,
+        return the matching ffmpeg volume filter.
+        """
+        normalization_type = self.media_file.ffmpeg_normalize.normalization_type
+        target_level = self.media_file.ffmpeg_normalize.target_level
+
+        if normalization_type == "peak":
+            adjustment = 0 + target_level - self.loudness_statistics["max"]
+        elif normalization_type == "rms":
+            adjustment = target_level - self.loudness_statistics["mean"]
+        else:
+            raise FFmpegNormalizeError(
+                "Can only set adjustment for peak and RMS normalization"
+            )
+
+        logger.info(
+            "Adjusting stream {} by {} dB to reach {}".format(
+                self.stream_id, adjustment, target_level
+            )
+        )
+
+        if self.loudness_statistics["max"] + adjustment > 0:
+            logger.warning(
+                "Adjusting will lead to clipping of {} dB".format(
+                    self.loudness_statistics["max"] + adjustment
+                )
+            )
+
+        return f"volume={adjustment}dB"

lib/ffmpeg_normalize/_version.py

@@ -0,0 +1 @@
+__version__ = "1.22.4"

lib/osutils.js

@@ -0,0 +1,213 @@
+var _os = require('os');
+
+window.platform = function(){
+    return process.platform;
+}
+
+window.cpuCount = function(){
+    return _os.cpus().length;
+}
+
+window.sysUptime = function(){
+    //seconds
+    return _os.uptime();
+}
+
+window.processUptime = function(){
+    //seconds
+    return process.uptime();
+}
+
+
+
+// Memory
+window.freemem = function(){
+    return _os.freemem() / ( 1024 * 1024 );
+}
+
+window.totalmem = function(){
+
+    return _os.totalmem() / ( 1024 * 1024 );
+}
+
+window.freememPercentage = function(){
+    return _os.freemem() / _os.totalmem();
+}
+
+window.freeCommand = function(callback){
+
+    // Only Linux
+    require('child_process').exec('free -m', function(error, stdout, stderr) {
+
+       var lines = stdout.split("\n");
+
+
+       var str_mem_info = lines[1].replace( /[\s\n\r]+/g,' ');
+
+       var mem_info = str_mem_info.split(' ')
+
+       total_mem    = parseFloat(mem_info[1])
+       free_mem     = parseFloat(mem_info[3])
+       buffers_mem  = parseFloat(mem_info[5])
+       cached_mem   = parseFloat(mem_info[6])
+
+       used_mem = total_mem - (free_mem + buffers_mem + cached_mem)
+
+       callback(used_mem -2);
+    });
+}
+
+
+// Hard Disk Drive
+window.harddrive = function(callback){
+
+    require('child_process').exec('df -k', function(error, stdout, stderr) {
+
+        var total = 0;
+        var used = 0;
+        var free = 0;
+
+        var lines = stdout.split("\n");
+
+        var str_disk_info = lines[1].replace( /[\s\n\r]+/g,' ');
+
+        var disk_info = str_disk_info.split(' ');
+
+        total = Math.ceil((disk_info[1] * 1024)/ Math.pow(1024,2));
+        used = Math.ceil(disk_info[2] * 1024 / Math.pow(1024,2)) ;
+        free = Math.ceil(disk_info[3] * 1024 / Math.pow(1024,2)) ;
+
+        callback(total, free, used);
+    });
+}
+
+
+
+// Return process running current
+window.getProcesses = function(nProcess, callback){
+
+    // if nprocess is undefined then is function
+    if(typeof nProcess === 'function'){
+
+        callback =nProcess;
+        nProcess = 0
+    }
+
+    command = 'ps -eo pcpu,pmem,time,args | sort -k 1 -r | head -n'+10
+    //command = 'ps aux | head -n '+ 11
+    //command = 'ps aux | head -n '+ (nProcess + 1)
+    if (nProcess > 0)
+        command = 'ps -eo pcpu,pmem,time,args | sort -k 1 -r | head -n'+(nProcess + 1)
+
+    require('child_process').exec(command, function(error, stdout, stderr) {
+
+        var that = this
+
+        var lines = stdout.split("\n");
+        lines.shift()
+        lines.pop()
+
+        var result = ''
+
+
+        lines.forEach(function(_item,_i){
+
+            var _str = _item.replace( /[\s\n\r]+/g,' ');
+
+            _str = _str.split(' ')
+
+            // result += _str[10]+" "+_str[9]+" "+_str[2]+" "+_str[3]+"\n";  // process
+            result += _str[1]+" "+_str[2]+" "+_str[3]+" "+_str[4].substring((_str[4].length - 25))+"\n";  // process
+
+        });
+
+        callback(result);
+    });
+}
+
+
+
+/*
+* Returns All the load average usage for 1, 5 or 15 minutes.
+*/
+window.allLoadavg = function(){
+
+    var loads = _os.loadavg();
+
+    return loads[0].toFixed(4)+','+loads[1].toFixed(4)+','+loads[2].toFixed(4);
+}
+
+/*
+* Returns the load average usage for 1, 5 or 15 minutes.
+*/
+window.loadavg = function(_time){
+
+    if(_time === undefined || (_time !== 5 && _time !== 15) ) _time = 1;
+
+    var loads = _os.loadavg();
+    var v = 0;
+    if(_time == 1) v = loads[0];
+    if(_time == 5) v = loads[1];
+    if(_time == 15) v = loads[2];
+
+    return v;
+}
+
+
+window.cpuFree = function(callback){
+    getCPUUsage(callback, true);
+}
+
+window.cpuUsage = function(callback){
+    getCPUUsage(callback, false);
+}
+
+function getCPUUsage(callback, free){
+
+    var stats1 = getCPUInfo();
+    var startIdle = stats1.idle;
+    var startTotal = stats1.total;
+
+    setTimeout(function() {
+        var stats2 = getCPUInfo();
+        var endIdle = stats2.idle;
+        var endTotal = stats2.total;
+
+        var idle 	= endIdle - startIdle;
+        var total 	= endTotal - startTotal;
+        var perc	= idle / total;
+
+        if(free === true)
+            callback( perc );
+        else
+            callback( (1 - perc) );
+
+    }, 1000 );
+}
+
+function getCPUInfo(callback){
+    var cpus = _os.cpus();
+
+    var user = 0;
+    var nice = 0;
+    var sys = 0;
+    var idle = 0;
+    var irq = 0;
+    var total = 0;
+
+    for(var cpu in cpus){
+        if (!cpus.hasOwnProperty(cpu)) continue;
+        user += cpus[cpu].times.user;
+        nice += cpus[cpu].times.nice;
+        sys += cpus[cpu].times.sys;
+        irq += cpus[cpu].times.irq;
+        idle += cpus[cpu].times.idle;
+    }
+
+    var total = user + nice + sys + idle + irq;
+
+    return {
+        'idle': idle,
+        'total': total
+    };
+}

main.js

@@ -0,0 +1,140 @@
+
+const PRODUCTION = process.mainModule.filename.includes("resources")
+const path = PRODUCTION ? "resources/app" : "."
+
+const remoteMain = require("@electron/remote/main")
+remoteMain.initialize()
+
+const fs = require("fs")
+const {shell, app, BrowserWindow, ipcMain, Menu} = require("electron")
+const {spawn} = require("child_process")
+
+let pythonProcess
+
+if (PRODUCTION) {
+    // pythonProcess = spawn(`${path}/cpython/server.exe`, {stdio: "ignore"})
+} else {
+    pythonProcess = spawn("python", [`${path}/server.py`], {stdio: "ignore"})
+}
+
+let mainWindow
+let discordClient
+let discordClientStart = Date.now()
+
+const createWindow = () => {
+    mainWindow = new BrowserWindow({
+        width: 1200,
+        height: 1000,
+        minHeight: 800,
+        minWidth: 1300,
+        frame: false,
+        webPreferences: {
+            nodeIntegration: true,
+            enableRemoteModule: true,
+            contextIsolation: false
+        },
+        icon: `${__dirname}/assets/x-icon.png`,
+        // show: false,
+    })
+    remoteMain.enable(mainWindow.webContents)
+
+    app.on('browser-window-created', (_, window) => {
+        require("@electron/remote/main").enable(mainWindow.webContents)
+    })
+
+    mainWindow.loadFile("index.html")
+    mainWindow.shell = shell
+
+    mainWindow.on("ready-to-show", () => {
+        mainWindow.show()
+    })
+
+    mainWindow.on("closed", () => mainWindow = null)
+}
+
+ipcMain.on("resize", (event, arg) => {
+    mainWindow.setSize(arg.width, arg.height)
+})
+ipcMain.on("updatePosition", (event, arg) => {
+    const bounds = mainWindow.getBounds()
+    bounds.x = parseInt(arg.details[0])
+    bounds.y = parseInt(arg.details[1])
+    mainWindow.setBounds(bounds)
+})
+ipcMain.on("updateDiscord", (event, arg) => {
+
+    // Disconnect if turned off
+    if (!Object.keys(arg).includes("details")) {
+        if (discordClient) {
+            try {
+                discordClient.disconnect()
+            } catch (e) {}
+        }
+        discordClient = undefined
+        return
+    }
+
+    if (!discordClient) {
+        discordClient = require('discord-rich-presence')('885096702648938546')
+    }
+
+    discordClient.updatePresence({
+        state: 'Generating AI voice acting',
+        details: arg.details,
+        startTimestamp: discordClientStart,
+        largeImageKey: 'xvasynth_512_512',
+        largeImageText: "xVASynth",
+        smallImageKey: 'xvasynth_512_512',
+        smallImageText: "xVASynth",
+        instance: true,
+    })
+})
+ipcMain.on("show-context-menu-editor", (event) => {
+    const template = [
+        {
+            label: 'Copy ARPAbet [v3]',
+            click: () => { event.sender.send('context-menu-command', 'context-copy-editor') }
+        },
+    ]
+    const menu = Menu.buildFromTemplate(template)
+    menu.popup(BrowserWindow.fromWebContents(event.sender))
+})
+
+ipcMain.on("show-context-menu", (event) => {
+    const template = [
+        {
+            label: 'Copy',
+            click: () => { event.sender.send('context-menu-command', 'context-copy') }
+        },
+        {
+            label: 'Paste',
+            click: () => { event.sender.send('context-menu-command', 'context-paste') }
+        },
+        // { type: 'separator' },
+    ]
+    const menu = Menu.buildFromTemplate(template)
+    menu.popup(BrowserWindow.fromWebContents(event.sender))
+})
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.on("ready", createWindow)
+
+
+// Quit when all windows are closed.
+app.on("window-all-closed", () => {
+    // On OS X it is common for applications and their menu bar
+    // to stay active until the user quits explicitly with Cmd + Q
+    if (process.platform !== "darwin") {
+        app.quit()
+    }
+})
+
+app.on("activate", () => {
+// On OS X it"s common to re-create a window in the app when the
+// dock icon is clicked and there are no other windows open.
+    if (mainWindow === null) {
+        createWindow()
+    }
+})

package.json

@@ -0,0 +1,27 @@
+{
+  "name": "xVASynth",
+  "version": "1.0.0",
+  "description": "Speech synthesis in the style of voice actors.",
+  "productName": "xVASynth",
+  "main": "main.js",
+  "scripts": {
+    "start": "electron .",
+    "package-windows": "electron-packager ./ --overwrite --prune=true --icon=assets/icon.ico --out=release-builds",
+    "package-linux": "electron-packager ./ --platform=linux --overwrite --prune=true --icon=assets/icon.ico --out=release-builds"
+  },
+  "repository": "https://github.com/DanRuta/xVA-Synth",
+  "author": "DanRuta",
+  "devDependencies": {
+    "electron": "19.0.0",
+    "electron-packager": "^17.1.2"
+  },
+  "dependencies": {
+    "@electron/remote": "^2.0.9",
+    "discord-rich-presence": "0.0.8",
+    "fs-extra": "^9.1.0",
+    "node-fetch": "^2.1.2",
+    "node-nvidia-smi": "^1.0.0",
+    "unzipper": "^0.10.11",
+    "zip-dir": "^2.0.0"
+  }
+}

patreon.txt

@@ -0,0 +1 @@
+D0lphin, flyingvelociraptor, Caden Black, Max Loef, LadyVaudry, Thuggysmurf, radbeetle, TomahawkJackson, Solstice_, Bungles, midori95, eldayualien, John Detwiler, Cecell, Wandering Youth, ellia, Retlaw83, Trixie, CHASE MCKELVY, Leif, ionite, Joshua Jones, Jaktt1337, David Keith vun Kannon, Netherworks (Jo-Jo), neci, Rachel Wiles, Imogen, Deer, Linthar, sadfer, Danielle, Hector Medima, Sh1tMagnet, ReaperStoleMyStyle, AshbeeGaming, TCG, Lady Steel, Mikkel Jensen, CookieGalaxy, GrumpyBen, Adrilz, ReyVenom, dog, bourbonicRecluse, ShiningEdge, Dozen9292, manlethamlet, smokeandash, Elias V, EnculerDeTaMere, SKiLLsSoLoN, J, finalfrog, Hound740, Buck, Yael van Dok, ChrisTheStranger, Isabel, Fuzzy Lonesome, Drake, Beto, AceAvenger, bobbigmac, Alexandra Whitton, yic17, Joebobslim, ThatGuyWithaFace, Sergey Trifonov, Zensho, AgitoRivers, beccatoria, valo999, Ne0nFLaSH, Caro Tuts, Jack in the Hinter, Hammerhead96 ., Bewitched, Para, Wht??? Why??, Shadowtigers, PConD, Lulzar, Ryan W, Wyntilda, Gorim, Krazon, Tako-kun, Walt, Katsuki, Ember2528, RetconReality, Hazel Louise Steele, Laura Almeida, Althecow, PatronGuy, squirecrow, cramonty, crash blue, Syrr, David, Hawkbar, John S., Autumn, pimphat, FeralByrd, Comical, Dogmeat114, Dezmar-Sama, Michael Gill, Jacob Garbe, NerfViking, Dinonugget, RedneckJP007, stormalize, Golem, Luckystroker, Hapax, Vahzah Vulom, Tempuc, CAW CAW, stljeffbb, bart, MrJoy, Zoenna, Calvin, Aosana Bluewing, Dan Brookes, CDante, HunterAP, Kadisra, candied_skull, hairahcaz, nairaiwu, Mar, Paraffine, Nawen_Syaka, Amy Parker, Loseron, katiefraggle, Freon, deepbluefrog, myles.app, hanbonzan, Scientist Salari-Ren, Roman Tinkov, zackc1play, An abstract kind of horror, L, Mihu123, Trisket, Aelarr, Flipdark95, Timo Steiner, humocs, Optimist Vamscenes, Patrick VanDusen, praxis22, Rui Orey, Craig Fedynich, FrenchToast, Dorpz, cesm23, BoB, Cutup, Botty Butler, tjn2222, Matthew Warren, Tom Green, Passionate Lobster, Precipitation, Veks, Baki Balcioglu, Fenris, Patrik K., Oddbrother, E.M.A, DrogerKerchva, Camurai, hthek, iggyzee, Moppy, Stee_Muttlet, asbestos my beloved, TrueBlue, something106, woah00z, Sam Darling, JoshuaJSlone, vvvpppmmm, OvrTheTopMan, munchyfly, DarkNemphis, Justin McGough, Billyro, DIY_Rene, kevmasters, Stu, Sasquatch Bill, Inconsistent, Gothic 3 The Age of War, www48, Slothman, mavrodya petrov, ronaldomoon, Kostin Oleksandr Anatoliiovych, Ryan Lippen, Edward Hyde, Echoes, Vape Gwagwa, Kelg Celcs, Kneelers, Meryl Coker, Alan Gonzalez, PTC001, Hector Medima, CinnaMewRoll, Grant Spielbusch, Sean Lyons, Charles Hufnagel, Kirill Akimov, Mister Lyosea, Anthony Crane, Sh1tMagnet

plugins/eg_custom_event/frontendPlugin.js

@@ -0,0 +1,33 @@
+"use strict"
+
+
+const postStartFn = (window, data) => {
+    window.appLogger.log("postStartFn")
+
+    const button = document.createElement("button")
+    button.innerHTML = "Custom event"
+    // Style the button with the current game's colour
+    button.style.background = `#${window.currentGame[1]}`
+
+    adv_opts.children[1].appendChild(button)
+
+    button.addEventListener("click", () => {
+
+        fetch(`http://localhost:8008/customEvent`, {
+            method: "Post",
+            body: JSON.stringify({
+                pluginId: "eg_custom_event",
+                data1: "some data",
+                data2: "some more data",
+                // ....
+            })
+        }).then(r=>r.text()).then(() => {
+            window.appLogger.log("custom event finished")
+            console.log("custom event finished")
+        })
+    })
+
+}
+
+
+exports.postStartFn = postStartFn

plugins/eg_custom_event/main.py

@@ -0,0 +1,10 @@
+logger = setupData["logger"]
+
+import time
+
+def custom_event_fn(data=None):
+    global logger, time
+    print(f'custom_event_fn: {data}')
+    logger.log(f'custom_event_fn: {data}')
+    time.sleep(2)
+

plugins/eg_custom_event/plugin.json

@@ -0,0 +1,28 @@
+{
+    "plugin-name": "Custom events example",
+    "author": "DanRuta",
+    "nexus-link": null,
+    "plugin-version": "1.0",
+    "plugin-short-description": "A demo plugin to show how custom python events work",
+    "min-app-version": "1.0.0",
+    "max-app-version": "1.4.0",
+    "install-requires-restart": false,
+    "uninstall-requires-restart": true,
+
+    "front-end-style-files": [],
+
+    "front-end-hooks": {
+        "start": {
+            "post": {
+                "file": "frontendPlugin.js",
+                "function": "postStartFn"
+            }
+        }
+    },
+    "back-end-hooks": {
+        "custom-event": {
+            "file": "main.py",
+            "function": "custom_event_fn"
+        }
+    }
+}

plugins/test_plugin/custom_event.py

@@ -0,0 +1,5 @@
+logger = setupData["logger"]
+
+def custom_event_fn(data=None):
+    global logger
+    logger.log(f'custom_event_fn: {data}')