Initial commit (squashed)

.gitattributes

@@ -0,0 +1,3 @@
+CMakeModules/* linguist-vendored
+web/js/*.min.js linguist-vendored
+web/css/*.min.css linguist-vendored

.gitignore

@@ -0,0 +1,15 @@
+.idea
+thumbs
+test
+*.cbp
+CMakeCache.txt
+CMakeFiles
+cmake-build-debug
+cmake_install.cmake
+Makefile
+*.out
+LOG
+sist2*
+index.sist2/
+bundle.css
+bundle.js

.gitmodules

@@ -0,0 +1,18 @@
+[submodule "argparse"]
+	path = argparse
+	url = https://github.com/cofyc/argparse
+[submodule "cJSON"]
+	path = cJSON
+	url = https://github.com/DaveGamble/cJSON
+[submodule "lib/mupdf"]
+	path = lib/mupdf
+	url = git://git.ghostscript.com/mupdf.git
+[submodule "lib/onion"]
+	path = lib/onion
+	url = https://github.com/davidmoreno/onion
+[submodule "lib/ffmpeg"]
+	path = lib/ffmpeg
+	url = https://git.ffmpeg.org/ffmpeg.git
+[submodule "lmdb"]
+	path = lmdb
+	url = https://github.com/LMDB/lmdb

CMakeLists.txt

@@ -0,0 +1,125 @@
+cmake_minimum_required(VERSION 3.7)
+set(CMAKE_C_STANDARD 11)
+
+project(sist2 C)
+list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/CMakeModules")
+
+add_executable(
+        sist2
+        src/main.c
+        src/sist.h
+        src/io/walk.h src/io/walk.c
+        src/parsing/media.h src/parsing/media.c
+        src/parsing/pdf.h src/parsing/pdf.c
+        src/io/store.h src/io/store.c
+        src/tpool.h src/tpool.c
+        src/parsing/parse.h src/parsing/parse.c
+        src/io/serialize.h src/io/serialize.c
+        src/parsing/mime.h src/parsing/mime.c src/parsing/mime_generated.c
+        src/parsing/text.h src/parsing/text.c
+        src/index/web.c src/index/web.h
+        src/web/serve.c src/web/serve.h
+        src/index/elastic.c src/index/elastic.h
+        src/util.c src/util.h
+        src/ctx.h src/types.h src/parsing/font.c src/parsing/font.h
+
+        # argparse
+        argparse/argparse.h argparse/argparse.c
+
+        # cJSON
+        cJSON/cJSON.h cJSON/cJSON.c
+
+        # LMDB
+        lmdb/libraries/liblmdb/lmdb.h lmdb/libraries/liblmdb/mdb.c
+        lmdb/libraries/liblmdb/midl.h lmdb/libraries/liblmdb/midl.c
+)
+
+find_package(PkgConfig REQUIRED)
+set(ENV{PKG_CONFIG_PATH} "$ENV{PKG_CONFIG_PATH}:/usr/local/lib/pkgconfig/")
+
+find_package(LibMagic REQUIRED)
+find_package(FFmpeg REQUIRED)
+find_package(OpenSSL REQUIRED)
+find_package(Freetype REQUIRED)
+
+pkg_check_modules(GLIB REQUIRED glib-2.0)
+pkg_check_modules(GOBJECT REQUIRED gobject-2.0)
+pkg_check_modules(UUID REQUIRED uuid)
+
+include_directories(${LIBMAGIC_INCLUDE_DIRS})
+link_directories(${LIBMAGIC_LIBRARY_DIRS})
+add_definitions(${LIBMAGIC_CFLAGS_OTHER})
+
+link_directories(${UUID_LIBRARY_DIRS})
+include_directories(${UUID_INCLUDE_DIRS})
+add_definitions(${UUID_CFLAGS_OTHER})
+
+include_directories(${GLIB_INCLUDE_DIRS})
+link_directories(${GLIB_LIBRARY_DIRS})
+add_definitions(${GLIB_CFLAGS_OTHER})
+
+include_directories(${GOBJECT_INCLUDE_DIRS})
+link_directories(${GOBJECT_LIBRARY_DIRS})
+add_definitions(${GOBJECT_CFLAGS_OTHER})
+
+link_directories(${FFMPEG_LIBRARY_DIRS})
+include_directories(${FFMPEG_INCLUDE_DIRS})
+
+include_directories(${OPENSSL_INCLUDE_DIR})
+link_directories(${OPENSSL_CRYPTO_LIBRARY})
+
+list(REMOVE_ITEM GLIB_LIBRARIES pcre)
+list(REMOVE_ITEM GOBJECT_LIBRARIES pcre)
+list(REMOVE_ITEM UUID_LIBRARIES pcre)
+
+include_directories(${FREETYPE_INCLUDE_DIRS})
+add_definitions(${FREETYPE_CFLAGS_OTHER})
+
+include_directories(
+        ${PROJECT_SOURCE_DIR}/
+        ${PROJECT_SOURCE_DIR}/lmdb/libraries/liblmdb/
+        ${PROJECT_SOURCE_DIR}/lib/onion/src/
+        ${PROJECT_SOURCE_DIR}/lib/mupdf/include/
+)
+
+target_compile_options(sist2
+        PRIVATE
+        -Ofast
+#        -march=native
+        -fno-stack-protector
+        -fomit-frame-pointer
+        )
+
+TARGET_LINK_LIBRARIES(
+        sist2
+
+        ${GOBJECT_LIBRARIES}
+        ${UUID_LIBRARIES}
+        ${GLIB_LIBRARIES}
+
+        # ffmpeg
+        ${PROJECT_SOURCE_DIR}/lib/libavcodec.a
+        ${PROJECT_SOURCE_DIR}/lib/libavformat.a
+        ${PROJECT_SOURCE_DIR}/lib/libavutil.a
+        ${PROJECT_SOURCE_DIR}/lib/libswscale.a
+        ${PROJECT_SOURCE_DIR}/lib/libswresample.a
+
+        # mupdf
+        ${PROJECT_SOURCE_DIR}/lib/libmupdf.a
+        ${PROJECT_SOURCE_DIR}/lib/libmupdf-third.a
+
+        # onion
+        ${PROJECT_SOURCE_DIR}/lib/libonion_static.a
+
+        pthread
+        curl
+        m
+        bz2
+        magic
+)
+
+add_custom_target(
+        before_sist2
+        COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/scripts/before_build.sh
+)
+add_dependencies(sist2 before_sist2)

LICENSE

@@ -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

@@ -0,0 +1,89 @@
+![GitHub](https://img.shields.io/github/license/simon987/sist2.svg)
+[![CodeFactor](https://www.codefactor.io/repository/github/simon987/sist2/badge?s=05daa325188aac4eae32c786f3d9cf4e0593f822)](https://www.codefactor.io/repository/github/simon987/sist2)
+
+# sist2
+
+sist2 (Simple incremental search tool)
+
+## Features
+
+
+
+## Example usage
+
+```bash
+sist2 scan [OPTION]... PATH
+
+# Examples
+sist2 scan ~/Documents -o ./orig_idx/
+sist2 scan --threads 4 --content-size 16384 /mnt/Pictures
+sist2 scan -i ./orig_idx/ -o ./updated_idx/ ~/Documents
+```
+
+```bash
+sist2 index [OPTION]... INDEX
+
+# Examples
+sist2 index --force-reset ./my_idx
+sist2 index --print ./my_idx > raw_documents.ndjson
+```
+
+```bash
+sist2 web [OPTION]... INDEX...
+
+# Examples
+sist2 web --bind 0.0.0.0 --port 4321 ./my_idx1 ./my_idx2 ./my_idx3
+```
+
+## Format support
+
+File type | Library | Content | Thumbnail | Metadata
+:---|:---|:---|:---|:---
+pdf,xps,cbz,cbr,fb2,epub | MuPDF | yes | yes, `png` | *planned* |
+`audio/*` | libav | - | yes, `jpeg` | ID3 tags |
+`video/*` | libav | - | yes, `jpeg` | *planned* |
+`image/*` | libav | - | yes, `jpeg` | *planned* |
+ttf,ttc,cff,woff,fnt,otf | Freetype2 | - | yes, `bmp` | Name & style |
+`text/plain` | *(none)* | yes | no | - |
+docx, xlsx, pptx |  | *planned* | no | *planned* |
+
+
+
+
+## Installation
+
+1. Download runtime dependencies
+
+    `apt install curl bzip2`
+    
+1. Download binary
+    
+    Get [the latest release](https://github.com/simon987/sist2/releases) from GitHub
+
+1. (Optional) Add to search path
+    
+   `mv sist2 /usr/bin/`
+
+## Build from source
+
+1. Install compile-time dependencies
+
+    *(Debian)*
+    ```bash
+    apt install git cmake pkg-config libglib2.0-dev\
+        libssl-dev uuid-dev libavformat-dev libswscale-dev \
+        python3 libmagic-dev libfreetype6-dev libcurl-dev \
+        libbz2-dev yasm
+    ```
+    *(Archlinux)*
+    ```bash
+    pacman -S git ffmpeg pkg-config cmake openssl curl \
+        bzip2 yasm libutil-linux
+    ```
+2. Build
+    ```bash
+    git clone --recurse-submodules https://github.com/simon987/sist2
+    ./scripts/get_static_libs.sh
+    cmake .
+    make
+    ```

argparse

@@ -0,0 +1 @@
+Subproject commit fafc503d23d077bda40c29e8a20ea74707452721

cJSON

@@ -0,0 +1 @@
+Subproject commit 2de7d04aaf67598e23d06573dcb4e370ebbad410

lib/ffmpeg

@@ -0,0 +1 @@
+Subproject commit 0481a1f6e5b8737c4fbc67794fd3a24cfcf34594

lib/mupdf

@@ -0,0 +1 @@
+Subproject commit 91782a434877d84b828fdeef20c569d4c3b4071b

lib/onion

@@ -0,0 +1 @@
+Subproject commit d8d4cc9290982e1fdd254377ff62d8175f9c6059

lmdb

@@ -0,0 +1 @@
+Subproject commit 5c012bbe033f9bbb273078b07dded59f080d348d

mime.csv

@@ -0,0 +1,355 @@
+application/arj, arj
+application/base64, mme
+application/binhex, hqx
+application/book, boo|book
+application/CDFV2, sdv
+application/clariscad, ccad
+application/commonground, dp
+application/drafting, drw
+application/freeloader, frl
+application/futuresplash, spl
+application/groupwise, vew
+application/gzip, gz
+application/hta, hta
+application/i-deas, unv
+application/iges, iges|igs
+application/inf, inf
+application/java-archive, jar
+application/java, class
+application/javascript,
+application/x-archive, a
+application/json, json
+application/marc, mrc
+application/mbedlet, mbd
+application/mime, aps
+application/mspowerpoint, ppz
+application/msword, doc|dot|w6w|wiz|word
+application/netmc, mcp
+application/octet-stream, bin|dump|gpg
+application/oda, oda
+application/pdf, pdf
+application/pgp-signature, pgp
+application/pkcs7-signature, p7s
+application/pkix-cert, cer|crt
+application/postscript, ai|ps
+application/pro_eng, part|prt
+application/ringing-tones, rng
+application/smil, smi|smil
+application/solids, sol
+application/sounder, sdr
+application/step, step|stp
+application/streamingmedia, ssm
+application/vda, vda
+application/vnd.fdf, fdf
+application/vnd.font-fontforge-sfd, sfd
+application/vnd.hp-hpgl, hgl|hpg|hpgl
+application/vnd.ms-excel, xlb|xlc|xll|xlm|xls|xlw
+application/vnd.ms-fontobject, eot
+application/vnd.ms-opentype, otf
+application/vnd.ms-pki.certstore, sst
+application/vnd.ms-pki.pko, pko
+application/vnd.ms-pki.seccat, cat
+application/vnd.ms-powerpoint, pot|ppa|pps|ppt|pwz
+application/vnd.ms-project, mpp
+application/vnd.oasis.opendocument.base, odb
+application/vnd.oasis.opendocument.formula, odf
+application/vnd.oasis.opendocument.graphics, odg
+application/vnd.oasis.opendocument.text, odt
+application/vnd.wap.wmlc, wmlc
+application/vnd.wap.wmlscriptc, wmlsc
+application/vnd.xara, web
+application/vocaltec-media-desc, vmd
+application/vocaltec-media-file, vmf
+application/wordperfect6.0, w60
+application/wordperfect6.1, w61
+application/wordperfect, wp|wp5|wp6|wpd
+application/x-123, wk1
+application/x-aim, aim
+application/x-authorware-bin, aab
+application/x-authorware-map, aam
+application/x-authorware-seg, aas
+application/x-bcpio, bcpio
+application/x-bittorrent, torrent
+application/x-bsh, bsh
+application/x-bytecode.python, pyc
+application/x-bzip2, boz|bz2
+application/x-bzip, bz
+application/x-cdlink, vcd
+application/x-chat, cha|chat
+application/x-cocoa, cco
+application/x-conference, nsc
+application/x-cpio, cpio
+application/x-dbf, dbf
+application/x-dbt,
+application/x-deepv, deepv
+application/x-director, dcr|dir|dxr
+application/x-dosexec, dll
+application/x-dvi, dvi
+application/x-elc, elc
+application/x-envoy, env|evy
+application/x-esrehber, es
+application/x-excel, xla|xld|xlk|xlt|xlv
+application/x-executable, exe
+application/x-font-sfn,
+application/x-font-ttf, ttf
+application/x-freelance, pre
+application/x-git,
+application/x-gsp, gsp
+application/x-gss, gss
+application/x-gtar, gtar
+application/x-gzip, gzip
+application/x-hdf, hdf
+application/x-helpfile, help
+application/x-httpd-imap, imap
+application/x-ima, ima
+application/x-internett-signup, ins
+application/x-inventor, iv
+application/x-ip2, ip
+application/x-java-applet,
+application/x-java-commerce, jcm
+application/x-java-image,
+application/x-java-keystore,
+application/x-koan, skd|skm|skp|skt
+application/x-latex, latex|ltx
+application/x-livescreen, ivy
+application/x-lotus, wq1
+application/x-lzh, lzh
+application/x-lzx, lzx
+application/x-mach-binary, jnilib|dylib
+application/x-mach-executable,
+application/x-magic-cap-package-1.0, mc$
+application/x-mathcad, mcd
+application/x-meme, mm
+application/x-midi, midi
+application/x-mif, mif
+application/x-mix-transfer, nix
+application/xml, opf
+application/x-ms-pdb, pdb
+application/x-navi-animation, ani
+application/x-navidoc, nvd
+application/x-navimap, map
+application/x-navistyle, stl
+application/x-netcdf, cdf|nc
+application/x-newton-compatible-pkg, pkg
+application/x-object, o
+application/x-omcdatamaker, omcd
+application/x-omc, omc
+application/x-omcregerator, omcr
+application/x-pagemaker, pm4|pm5
+application/x-pcl, pcl
+application/x-pixclscript, plx
+application/x-pkcs7-certreqresp, p7r
+application/x-pkcs7-signature, p7a
+application/x-project, mpc|mpt|mpv|mpx
+application/x-qpro, wb1
+application/x-sdp, sdp
+application/x-sea, sea
+application/x-seelogo, sl
+application/x-setupscript,
+application/x-sharedlib, so
+application/x-shar, shar
+application/x-shockwave-flash, swf
+application/x-sprite, spr|sprite
+application/x-sqlite3,
+application/x-sv4cpio, sv4cpio
+application/x-sv4crc, sv4crc
+application/x-tar, tar
+application/x-tbook, sbk|tbk
+application/x-texinfo, texi|texinfo
+application/x-tex-tfm, tfm
+application/x-ustar, ustar
+application/x-visio, vsd|vst|vsw
+application/x-vnd.audioexplosion.mzz, mzz
+application/x-vnd.ls-xpix, xpix
+application/x-vrml, vrml
+application/x-wais-source, src|wsrc
+application/x-wintalk, wtk
+application/x-world, svr
+application/x-wri, wri
+application/x-x509-ca-cert, der
+application/x-xz, xz
+application/zip, zip
+audio/it, it
+audio/make, funk|my|pfunk
+audio/midi, kar
+audio/mid, rmi
+audio/mpeg, m2a|mpa
+audio/ogg, ogg
+audio/s3m, s3m
+audio/tsp-audio, tsi
+audio/tsplayer, tsp
+audio/vnd.qcelp, qcp
+audio/voxware, vox
+audio/x-gsm, gsd|gsm
+audio/x-jam, jam
+audio/x-liveaudio, lam
+audio/x-m4a, m4a
+audio/x-midi, mid
+audio/x-mod,
+audio/x-mp4a-latm,
+audio/x-mpeg-3, mp3
+audio/x-mpequrl,
+audio/xm, xm
+audio/x-nspaudio, lma
+audio/x-pn-realaudio, ram|rm|rmm|rmp
+audio/x-psid, sid
+audio/x-realaudio, ra
+audio/x-twinvq-plugin, vqe|vql
+audio/x-twinvq, vqf
+audio/x-voc, voc
+audio/x-wav, wav
+font/otf,
+font/sfnt,
+image/cmu-raster, rast
+image/fif, fif
+image/florian, flo|turbot
+image/g3fax, g3
+image/gif, gif
+image/ief, ief|iefs
+image/jpeg, jfif|jfif-tbnl|jpe|jpeg|jpg
+image/jutvision, jut
+image/naplps, nap|naplps
+image/pict, pic|pict
+image/png, png|x-png
+!image/svg, svg
+!image/svg+xml,
+image/vnd.fpx, fpx
+image/vnd.microsoft.icon,
+image/vnd.rn-realflash, rf
+image/vnd.rn-realpix, rp
+image/vnd.wap.wbmp, wbmp
+image/vnd.xiff, xif
+image/webp, webp
+image/x-cmu-raster, ras
+image/x-dwg, dwg|dxf|svf
+image/x-eps,
+image/x-icns,
+!image/x-icon, ico
+image/x-jg, art
+image/x-jps, jps
+image/x-ms-bmp, bm|bmp
+image/x-niff, nif|niff
+image/x-pcx, pcx
+image/x-pict, pct
+image/x-portable-bitmap, pbm
+image/x-portable-graymap, pgm
+image/x-portable-pixmap, ppm
+image/x-quicktime, qif|qti|qtif
+image/x-rgb, rgb
+image/x-tiff, tif|tiff
+image/tiff,
+!image/x-xcf, xcf
+!image/x-xpixmap, xpm
+message/rfc822, mht|mhtml|mime
+model/vnd.dwf, dwf
+model/vrml, wrz
+model/x-pov, pov
+text/asp, asp
+text/css, css
+text/x-sass, sass
+text/x-scss, scss
+text/html, acgi|htm|html|htmls|htx|shtml
+text/javascript, js
+text/mcf, mcf
+text/pascal, pas
+text/plain, com|cmd|conf|def|g|idc|list|lst|mar|sdml|text|txt|md|groovy|license|properties|desktop|ini|rst|cmake|ipynb|readme|less|lo|go|yml|d|cs|hpp|srt
+text/richtext, rt|rtf|rtx
+text/scriplet, wsc
+text/x-awk, awk
+!video/x-jng, jng
+video/x-mng, mng
+image/x-cur, tga
+image/x-xwindowdump, xwd
+!image/vnd.adobe.photoshop, psd
+text/tab-separated-values, tsv
+text/troff, man|me|ms|roff|t|tr
+text/uri-list, uni|unis|uri|uris
+text/vnd.abc, abc
+text/vnd.fmi.flexstor, flx
+text/vnd.wap.wmlscript, wmls
+text/vnd.wap.wml, wml
+text/webviewhtml, htt
+text/x-Algol68,
+text/x-asm, asm|s
+text/x-audiosoft-intra, aip
+text/x-bcpl,
+text/x-c, c|cc|h
+text/x-c++, cpp|cxx|c++
+text/x-component, htc
+text/x-diff,
+text/x-fortran, f|f77|f90|for
+text/x-java, jav|java
+text/x-la-asf, lsx
+text/x-lisp, el
+text/x-m4, m4|ac
+text/x-makefile, am|mak
+text/xml, xml|pom|iml|plist
+text/x-m, m
+text/x-msdos-batch, bat
+text/x-pascal, p
+text/x-perl, pl
+text/x-php, php
+text/x-python, py
+text/x-ruby, rb
+text/x-server-parsed-html, ssi
+text/x-setext, etx
+text/x-sgml, sgm|sgml
+text/x-shellscript, sh
+text/x-speech, talk
+text/x-tex, tex
+text/x-uil, uil
+text/x-uuencode, uue
+text/x-vcalendar, vcs
+video/animaflex, afl
+video/avi, avi
+video/avs-video, avs
+video/mp4, mp4
+video/mpeg, m1v|m2v|mpe|mpeg|mpg
+video/quicktime, moov|mov|qt
+video/vdo, vdo
+video/vivo, viv|vivo
+video/vnd.rn-realvideo, rv
+video/vosaic, vos
+video/webm, webm
+video/x-amt-demorun, xdr
+video/x-amt-showrun, xsr
+video/x-atomic3d-feature, fmf
+video/x-dl, dl
+video/x-dv, dif|dv
+video/x-fli, fli
+video/x-isvideo, isu
+video/x-motion-jpeg, mjpg
+video/x-ms-asf, asf|asx
+video/x-qtc, qtc
+video/x-sgi-movie, movie|mv
+application/x-7z-compressed, 7z
+application/vnd.openxmlformats-officedocument.wordprocessingml.document, docx
+text/x-po, po
+application/x-rpm, rpm
+application/x-debian-package, deb
+application/vnd.iccprofile, icm
+application/dicom, dcm
+image/x-exr, exr
+application/vnd.iccprofile, icm
+video/x-matroska, mkv
+application/x-empty,
+model/vnd.gdl, gdl
+model/vnd.gs.gdl, gdsl
+font/woff, woff
+font/woff2, woff2
+application/epub+zip, epub
+application/x-mobipocket-ebook, mobi
+audio/x-flac, flac
+application/x-rar, rar
+video/x-msvideo, divx
+video/x-flv, flv
+application/x-kdelnk,
+text/x-tcl,
+application/ogg, ogv
+application/vnd.openxmlformats-officedocument.spreadsheetml.sheet, xlsx
+application/vnd.ms-cab-compressed, cab
+audio/mp4, m4b
+!image/vnd.djvu, djvu
+application/x-ms-reader, lit
+application/CDFV2-corrupt,
+text/x-vcard, vcf

schema/mappings.json

@@ -0,0 +1,85 @@
+{
+  "properties": {
+    "path": {
+      "type": "text",
+      "analyzer": "path_analyzer",
+      "copy_to": "suggest-path"
+    },
+    "suggest-path": {
+      "type": "completion",
+      "analyzer": "keyword"
+    },
+    "mime": {
+      "type": "keyword"
+    },
+    "videoc": {
+      "type": "keyword"
+    },
+    "audioc": {
+      "type": "keyword"
+    },
+    "duration": {
+      "type": "float"
+    },
+    "width": {
+      "type": "integer"
+    },
+    "height": {
+      "type": "integer"
+    },
+    "mtime": {
+      "type": "integer"
+    },
+    "size": {
+      "type": "long"
+    },
+    "index": {
+      "type": "keyword"
+    },
+    "name": {
+      "analyzer": "content_analyzer",
+      "type": "text",
+      "fields": {
+        "nGram": {
+          "type": "text",
+          "analyzer": "my_nGram"
+        }
+      }
+    },
+    "font_name": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "album": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "artist": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "title": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "genre": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "album_artist": {
+      "analyzer": "my_nGram",
+      "type": "text"
+    },
+    "content": {
+      "analyzer": "content_analyzer",
+      "type": "text",
+      "index_options": "offsets",
+      "fields": {
+        "nGram": {
+          "type": "text",
+          "analyzer": "my_nGram"
+        }
+      }
+    }
+  }
+}

schema/settings.json

@@ -0,0 +1,38 @@
+{
+  "index": {
+    "refresh_interval": "-1",
+    "codec": "best_compression"
+  },
+  "analysis": {
+    "tokenizer": {
+      "path_tokenizer": {
+        "type": "path_hierarchy"
+      },
+      "my_nGram_tokenizer": {
+        "type": "nGram",
+        "min_gram": 3,
+        "max_gram": 3
+      }
+    },
+    "analyzer": {
+      "path_analyzer": {
+        "tokenizer": "path_tokenizer",
+        "filter": [
+          "lowercase"
+        ]
+      },
+      "my_nGram": {
+        "tokenizer": "my_nGram_tokenizer",
+        "filter": [
+          "lowercase"
+        ]
+      },
+      "content_analyzer": {
+        "tokenizer": "standard",
+        "filter": [
+          "lowercase"
+        ]
+      }
+    }
+  }
+}

scripts/before_build.sh

@@ -0,0 +1,13 @@
+#!/bin/bash
+
+rm web/js/bundle.js 2> /dev/null
+cat `ls -v web/js/*.min.js` > web/js/bundle.js
+cat web/js/{util,dom,search}.js >> web/js/bundle.js
+
+rm web/css/bundle.css 2> /dev/null
+cat web/css/*.min.css > web/css/bundle.css
+cat web/css/main.css >> web/css/bundle.css
+
+python3 scripts/mime.py > src/parsing/mime_generated.c
+python3 scripts/serve_static.py > src/web/static_generated.c
+python3 scripts/index_static.py > src/index/static_generated.c

scripts/get_static_libs.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+cd lib
+
+cd mupdf
+HAVE_X11=no HAVE_GLUT=no make -j 4
+cd ..
+
+mv mupdf/build/release/libmupdf.a .
+mv mupdf/build/release/libmupdf-third.a .
+
+# libpcre
+cd libpcre
+./autogen.sh
+./configure --disable-shared
+make -j 4
+cd ..
+
+mv libpcre/.libs/libpcre.a .
+
+# ffmpeg
+cd ffmpeg
+./configure --disable-shared --enable-static --disable-ffmpeg --disable-ffplay \
+ --disable-ffprobe --disable-doc\
+ --disable-manpages --disable-postproc --disable-avfilter \
+ --disable-alsa --disable-lzma --disable-xlib --disable-debug\
+ --disable-vdpau --disable-vaapi --disable-sdl2 --disable-network
+make -j 4
+cd ..
+
+mv ffmpeg/libavcodec/libavcodec.a .
+mv ffmpeg/libavformat/libavformat.a .
+mv ffmpeg/libavutil/libavutil.a .
+mv ffmpeg/libswresample/libswresample.a .
+mv ffmpeg/libswscale/libswscale.a .
+
+# onion
+cd onion
+mkdir build 2> /dev/null
+cd build
+cmake -DONION_USE_SSL=false -DONION_USE_PAM=false -DONION_USE_PNG=false -DONION_USE_JPEG=false \
+-DONION_USE_JPEG=false -DONION_USE_XML2=false -DONION_USE_SYSTEMD=false -DONION_USE_SQLITE3=false \
+-DONION_USE_REDIS=false -DONION_USE_GC=false -DONION_USE_TESTS=false -DONION_EXAMPLES=false \
+-DONION_USE_BINDINGS_CPP=false ..
+make -j 4
+cd ../..
+
+mv onion/build/src/onion/libonion_static.a .
+cd ..

scripts/index_static.py

@@ -0,0 +1,14 @@
+files = [
+    "schema/mappings.json",
+    "schema/settings.json",
+]
+
+
+def clean(filepath):
+    return filepath.split("/")[-1].replace(".", "_").replace("-", "_")
+
+
+for file in files:
+    with open(file, "rb") as f:
+        data = f.read()
+    print("char %s[%d] = {%s};" % (clean(file), len(data), ",".join(str(int(b)) for b in data)))

scripts/mime.py

@@ -0,0 +1,102 @@
+mimes = {}
+noparse = set()
+ext_in_hash = set()
+
+major_mime = {
+    "model": 1,
+    "example": 2,
+    "message": 3,
+    "multipart": 4,
+    "font": 5,
+    "video": 6,
+    "audio": 7,
+    "image": 8,
+    "text": 9,
+    "application": 10
+}
+
+pdf = (
+    "application/pdf",
+    "application/x-cbr",
+    "application/x-cbz",
+    "application/vnd.ms-xpsdocument",
+)
+
+font = (
+    "application/vnd.ms-opentype",
+    "application/x-font-sfn",
+    "application/x-font-ttf",
+    "font/otf",
+    "font/sfnt",
+    "font/woff",
+    "font/woff2"
+)
+
+cnt = 1
+
+
+def mime_id(mime):
+    global cnt
+    major = mime.split("/")[0]
+    mime_id = str((major_mime[major] << 16) + cnt)
+    cnt += 1
+    if mime in noparse:
+        mime_id += " | 0x80000000"
+    elif mime in pdf:
+        mime_id += " | 0x40000000"
+    elif mime in font:
+        mime_id += " | 0x20000000"
+    elif mime == "application/x-empty":
+        return "1"
+    return mime_id
+
+
+def clean(t):
+    return t.replace("/", "_").replace(".", "_").replace("+", "_").replace("-", "_")
+
+
+with open("mime.csv") as f:
+    for l in f:
+        mime, ext_list = l.split(",")
+        if l.startswith("!"):
+            mime = mime[1:]
+            noparse.add(mime)
+        ext = [x.strip() for x in ext_list.split("|")]
+        mimes[mime] = ext
+
+    print("// **Generated by mime.py**")
+    print("#ifndef MIME_GENERATED_C")
+    print("#define MIME_GENERATED_C")
+    print("#include <glib-2.0/glib.h>\n")
+    print("#include <stdlib.h>\n")
+    # Enum
+    print("enum mime {")
+    for mime, ext in mimes.items():
+        print("    " + clean(mime) + "=" + mime_id(mime) + ",")
+    print("};")
+
+    # Enum -> string
+    print("char *mime_get_mime_text(unsigned int mime_id) {"
+          "switch (mime_id) {")
+    for mime, ext in mimes.items():
+        print("case " + clean(mime) + ": return \"" + mime + "\";")
+    print("default: return NULL;}}")
+
+    # Ext -> Enum
+    print("GHashTable *mime_get_ext_table() {"
+          "GHashTable *ext_table = g_hash_table_new(g_str_hash, g_str_equal);")
+    for mime, ext in mimes.items():
+        for e in [e for e in ext if e]:
+            print("g_hash_table_insert(ext_table, \"" + e + "\", (gpointer)" + clean(mime) + ");")
+            if e in ext_in_hash:
+                raise Exception("extension already in hash: " + e)
+            ext_in_hash.add(e)
+    print("return ext_table;}")
+
+    # string -> Enum
+    print("GHashTable *mime_get_mime_table() {"
+          "GHashTable *mime_table = g_hash_table_new(g_str_hash, g_str_equal);")
+    for mime, ext in mimes.items():
+        print("g_hash_table_insert(mime_table, \"" + mime + "\", (gpointer)" + clean(mime) + ");")
+    print("return mime_table;}")
+    print("#endif")

scripts/serve_static.py

@@ -0,0 +1,17 @@
+files = [
+    "web/css/bundle.css",
+    "web/js/bundle.js",
+    "web/img/bg-bars.png",
+    "web/img/sprite-skin-flat.png",
+    "web/search.html",
+]
+
+
+def clean(filepath):
+    return filepath.split("/")[-1].replace(".", "_").replace("-", "_")
+
+
+for file in files:
+    with open(file, "rb") as f:
+        data = f.read()
+    print("char %s[%d] = {%s};" % (clean(file), len(data), ",".join(str(int(b)) for b in data)))

src/ctx.h

@@ -0,0 +1,39 @@
+#ifndef SIST2_CTX_H
+#define SIST2_CTX_H
+
+#include "sist.h"
+
+struct {
+    struct index_t index;
+
+    GHashTable *mime_table;
+    GHashTable *ext_table;
+
+    tpool_t *pool;
+
+    int tn_size;
+    int threads;
+    int content_size;
+    float tn_qscale;
+
+    int stat_tn_size;
+    int stat_index_size;
+
+    GHashTable *original_table;
+    GHashTable *copy_table;
+} ScanCtx;
+
+
+struct {
+    char *es_url;
+} IndexCtx;
+
+struct {
+    char *es_url;
+    int index_count;
+    struct index_t indices[16];
+} WebCtx;
+
+
+
+#endif

src/index/elastic.c

@@ -0,0 +1,208 @@
+#include "elastic.h"
+#include "src/ctx.h"
+
+#include <stdlib.h>
+#include "web.h"
+#include <stdio.h>
+#include <string.h>
+#include <cJSON/cJSON.h>
+#include <src/ctx.h>
+
+#include "static_generated.c"
+
+#define BULK_INDEX_SIZE 100
+
+typedef struct es_indexer {
+    int queued;
+    char *es_url;
+    es_bulk_line_t *line_head;
+    es_bulk_line_t *line_tail;
+} es_indexer_t;
+
+
+static es_indexer_t *Indexer;
+
+void print_json(cJSON *document, const char uuid_str[UUID_STR_LEN]) {
+
+    cJSON *line = cJSON_CreateObject();
+
+    cJSON_AddStringToObject(line, "_id", uuid_str);
+    cJSON_AddStringToObject(line, "_index", "sist2");
+    cJSON_AddStringToObject(line, "_type", "_doc");
+    cJSON_AddItemToObject(line, "_source", document);
+
+    char *json = cJSON_PrintUnformatted(line);
+
+    printf("%s\n", json);
+
+    cJSON_free(line);
+}
+
+void index_json(cJSON *document, const char uuid_str[UUID_STR_LEN]) {
+
+    char *json = cJSON_PrintUnformatted(document);
+
+    size_t json_len = strlen(json);
+    es_bulk_line_t *bulk_line = malloc(sizeof(es_bulk_line_t) + json_len + 2);
+    memcpy(bulk_line->line, json, json_len);
+    memcpy(bulk_line->uuid_str, uuid_str, UUID_STR_LEN);
+    *(bulk_line->line + json_len) = '\n';
+    *(bulk_line->line + json_len + 1) = '\0';
+    bulk_line->next = NULL;
+
+    cJSON_free(json);
+    elastic_index_line(bulk_line);
+}
+
+void elastic_flush() {
+
+    if (Indexer == NULL) {
+        Indexer = create_indexer(IndexCtx.es_url);
+    }
+
+    es_bulk_line_t *line = Indexer->line_head;
+
+    int count = 0;
+
+    size_t buf_size = 0;
+    size_t buf_cur = 0;
+    char *buf = malloc(1);
+
+    while (line != NULL) {
+        char action_str[512];
+        snprintf(action_str, 512, "{\"index\":{\"_id\": \"%s\"}}\n", line->uuid_str);
+        size_t action_str_len = strlen(action_str);
+
+        size_t line_len = strlen(line->line);
+        buf = realloc(buf, buf_size + line_len + action_str_len);
+        buf_size += line_len + action_str_len;
+
+        memcpy(buf + buf_cur, action_str, action_str_len);
+        buf_cur += action_str_len;
+        memcpy(buf + buf_cur, line->line, line_len);
+        buf_cur += line_len;
+
+        es_bulk_line_t *tmp = line;
+        line = line->next;
+        free(tmp);
+        count++;
+    }
+    buf = realloc(buf, buf_size + 1);
+    *(buf+buf_cur) = '\0';
+
+    Indexer->line_head = NULL;
+    Indexer->line_tail = NULL;
+    Indexer->queued = 0;
+
+    char bulk_url[4096];
+    snprintf(bulk_url, 4096, "%s/sist2/_bulk", Indexer->es_url);
+    response_t *r = web_post(bulk_url, buf, "Content-Type: application/x-ndjson");
+    printf("Indexed %3d documents (%zukB) <%d>\n", count, buf_cur / 1024, r->status_code);
+    free_response(r);
+}
+
+void elastic_index_line(es_bulk_line_t *line) {
+
+    if (Indexer == NULL) {
+        Indexer = create_indexer(IndexCtx.es_url);
+    }
+
+    if (Indexer->line_head == NULL) {
+        Indexer->line_head = line;
+        Indexer->line_tail = Indexer->line_head;
+    } else {
+        Indexer->line_tail->next = line;
+        Indexer->line_tail = line;
+    }
+
+    Indexer->queued += 1;
+
+    if (Indexer->queued >= BULK_INDEX_SIZE) {
+        elastic_flush();
+    }
+}
+
+es_indexer_t *create_indexer(const char *url) {
+
+    size_t url_len = strlen(url);
+    char *es_url = malloc(url_len);
+    strcpy(es_url, url);
+
+    es_indexer_t *indexer = malloc(sizeof(es_indexer_t));
+
+    indexer->es_url = es_url;
+    indexer->queued = 0;
+    indexer->line_head = NULL;
+    indexer->line_tail = NULL;
+
+    return indexer;
+}
+
+void destroy_indexer() {
+
+    char url[4096];
+
+    snprintf(url, sizeof(url), "%s/sist2/_refresh", IndexCtx.es_url);
+    response_t *r = web_post(url, "", NULL);
+    printf("Refresh index <%d>\n", r->status_code);
+    free_response(r);
+
+    snprintf(url, sizeof(url), "%s/sist2/_forcemerge", IndexCtx.es_url);
+    r = web_post(url, "", NULL);
+    printf("Merge index <%d>\n", r->status_code);
+    free_response(r);
+
+    if (Indexer != NULL) {
+        free(Indexer->es_url);
+        free(Indexer);
+    }
+}
+
+void elastic_init(int force_reset) {
+
+    // Check if index exists
+    char url[4096];
+    snprintf(url, 4096, "%s/sist2", IndexCtx.es_url);
+    response_t *r = web_get(url);
+    int index_exists = r->status_code == 200;
+    free_response(r);
+
+    if (!index_exists || force_reset) {
+        r = web_delete(url);
+        printf("Delete index <%d>\n", r->status_code);
+        free_response(r);
+
+        snprintf(url, 4096, "%s/sist2", IndexCtx.es_url);
+        r = web_put(url, "", NULL);
+        printf("Create index <%d>\n", r->status_code);
+        free_response(r);
+
+        snprintf(url, 4096, "%s/sist2/_close", IndexCtx.es_url);
+        r = web_post(url, "", NULL);
+        printf("Close index <%d>\n", r->status_code);
+        free_response(r);
+
+        snprintf(url, 4096, "%s/sist2/_settings", IndexCtx.es_url);
+        r = web_put(url, settings_json, "Content-Type: application/json");
+        printf("Update settings <%d>\n", r->status_code);
+        free_response(r);
+
+        snprintf(url, 4096, "%s/sist2/_mappings", IndexCtx.es_url);
+        r = web_put(url, mappings_json, "Content-Type: application/json");
+        printf("Update mappings <%d>\n", r->status_code);
+        free_response(r);
+
+        snprintf(url, 4096, "%s/sist2/_open", IndexCtx.es_url);
+        r = web_post(url, "", NULL);
+        printf("Open index <%d>\n", r->status_code);
+        free_response(r);
+    }
+}
+
+cJSON *elastic_get_document(const char *uuid_str) {
+    char url[4096];
+    snprintf(url, 4096, "%s/sist2/_source/%s", WebCtx.es_url, uuid_str);
+
+    response_t *r = web_get(url);
+    return cJSON_Parse(r->body);
+}

src/index/elastic.h

@@ -0,0 +1,33 @@
+#ifndef SIST2_ELASTIC_H
+#define SIST2_ELASTIC_H
+
+#include "src/sist.h"
+
+typedef struct es_bulk_line {
+    struct es_bulk_line *next;
+    char uuid_str[UUID_STR_LEN];
+    char line[0];
+} es_bulk_line_t;
+
+/**
+ * Note: indexer is *not* thread safe
+ */
+typedef struct es_indexer es_indexer_t;
+
+void elastic_index_line(es_bulk_line_t *line);
+
+void elastic_flush();
+
+void print_json(cJSON *document, const char uuid_str[UUID_STR_LEN]);
+
+void index_json(cJSON *document, const char uuid_str[UUID_STR_LEN]);
+
+es_indexer_t *create_indexer(const char* es_url);
+
+void destroy_indexer();
+
+void elastic_init(int force_reset);
+
+cJSON *elastic_get_document(const char *uuid_str);
+
+#endif

src/index/web.c

@@ -0,0 +1,130 @@
+#include "web.h"
+
+size_t write_cb(char *ptr, size_t size, size_t nmemb, void *user_data) {
+
+    size_t real_size = size * nmemb;
+    dyn_buffer_t *buf = user_data;
+    dyn_buffer_write(buf, ptr, real_size);
+    return real_size;
+}
+
+void free_response(response_t *resp) {
+    free(resp->body);
+    free(resp);
+}
+
+response_t *web_get(const char *url) {
+    response_t *resp = malloc(sizeof(response_t));
+
+    CURL *curl;
+    dyn_buffer_t buffer = dyn_buffer_create();
+
+    curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) (&buffer));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "sist2");
+
+    curl_easy_perform(curl);
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &resp->status_code);
+
+    curl_easy_cleanup(curl);
+
+    resp->body = buffer.buf;
+    resp->size = buffer.cur;
+    return resp;
+}
+
+response_t *web_post(const char *url, const char *data, const char *header) {
+
+    response_t *resp = malloc(sizeof(response_t));
+
+    CURL *curl;
+    dyn_buffer_t buffer = dyn_buffer_create();
+
+    curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) (&buffer));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+    curl_easy_setopt(curl, CURLOPT_POST, 1);
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "sist2");
+
+    if (header != NULL) {
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(headers, header);
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    }
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
+
+    int r1 = curl_easy_perform(curl);
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &resp->status_code);
+
+    curl_easy_cleanup(curl);
+
+    resp->body = buffer.buf;
+    resp->size = buffer.cur;
+
+    return resp;
+}
+
+
+response_t *web_put(const char *url, const char *data, const char *header) {
+
+    response_t *resp = malloc(sizeof(response_t));
+
+    CURL *curl;
+    dyn_buffer_t buffer = dyn_buffer_create();
+
+    curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) (&buffer));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "PUT");
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "sist2");
+    curl_easy_setopt(curl, CURLOPT_DNS_USE_GLOBAL_CACHE, 0);
+    curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURLOPT_DNS_LOCAL_IP4 );
+
+    if (header != NULL) {
+        struct curl_slist *headers = NULL;
+        headers = curl_slist_append(headers, header);
+        curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
+    }
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, data);
+
+    curl_easy_perform(curl);
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &resp->status_code);
+
+    curl_easy_cleanup(curl);
+
+    resp->body = buffer.buf;
+    resp->size = buffer.cur;
+    return resp;
+}
+
+response_t *web_delete(const char *url) {
+
+    response_t *resp = malloc(sizeof(response_t));
+
+    CURL *curl;
+    dyn_buffer_t buffer = dyn_buffer_create();
+
+    curl = curl_easy_init();
+    curl_easy_setopt(curl, CURLOPT_URL, url);
+    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) (&buffer));
+    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_cb);
+    curl_easy_setopt(curl, CURLOPT_CUSTOMREQUEST, "DELETE");
+    curl_easy_setopt(curl, CURLOPT_USERAGENT, "sist2");
+
+    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, "");
+
+    curl_easy_perform(curl);
+    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &resp->status_code);
+
+    curl_easy_cleanup(curl);
+
+    resp->body = buffer.buf;
+    resp->size = buffer.cur;
+    return resp;
+}

src/index/web.h

@@ -0,0 +1,19 @@
+#ifndef SIST2_WEB_H
+#define SIST2_WEB_H
+
+#include "src/sist.h"
+
+typedef struct response {
+    char *body;
+    size_t size;
+    int status_code;
+} response_t;
+
+response_t *web_get(const char *url);
+response_t *web_post(const char * url, const char * data, const char* header);
+response_t *web_put(const char *url, const char *data, const char *header);
+response_t *web_delete(const char *url);
+
+void free_response(response_t *resp);
+
+#endif

src/io/serialize.c

@@ -0,0 +1,327 @@
+#include "src/ctx.h"
+#include "serialize.h"
+
+static __thread int IndexFd = -1;
+
+typedef struct {
+    unsigned char uuid[16];
+    unsigned long ino;
+    unsigned long size;
+    unsigned int mime;
+    int mtime;
+    short base;
+    short ext;
+} line_t;
+
+void skip_meta(FILE *file) {
+    enum metakey key = getc(file);
+    while (key != '\n') {
+        if (IS_META_INT(key)) {
+            fseek(file, sizeof(int), SEEK_CUR);
+        } else if (IS_META_LONG(key)) {
+            fseek(file, sizeof(long), SEEK_CUR);
+        } else {
+            while ((getc(file))) {}
+        }
+
+        key = getc(file);
+    }
+}
+
+void write_index_descriptor(char *path, index_descriptor_t *desc) {
+    cJSON *json = cJSON_CreateObject();
+    cJSON_AddStringToObject(json, "uuid", desc->uuid);
+    cJSON_AddStringToObject(json, "version", desc->version);
+    cJSON_AddStringToObject(json, "root", desc->root);
+    cJSON_AddStringToObject(json, "name", desc->name);
+    cJSON_AddStringToObject(json, "rewrite_url", desc->rewrite_url);
+    cJSON_AddNumberToObject(json, "timestamp", (double) desc->timestamp);
+
+    int fd = open(path, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
+    if (fd == -1) {
+        perror(path);
+    }
+    char *str = cJSON_Print(json);
+    write(fd, str, strlen(str));
+    free(str);
+    close(fd);
+
+    cJSON_Delete(json);
+}
+
+index_descriptor_t read_index_descriptor(char *path) {
+
+    struct stat info;
+    stat(path, &info);
+    int fd = open(path, O_RDONLY);
+    char *buf = malloc(info.st_size + 1);
+    read(fd, buf, info.st_size);
+    *(buf + info.st_size) = '\0';
+    close(fd);
+
+    cJSON *json = cJSON_Parse(buf);
+
+    index_descriptor_t descriptor;
+    descriptor.timestamp = (long) cJSON_GetObjectItem(json, "timestamp")->valuedouble;
+    strcpy(descriptor.root, cJSON_GetObjectItem(json, "root")->valuestring);
+    strcpy(descriptor.name, cJSON_GetObjectItem(json, "name")->valuestring);
+    strcpy(descriptor.rewrite_url, cJSON_GetObjectItem(json, "rewrite_url")->valuestring);
+    descriptor.root_len = (int)strlen(descriptor.root);
+    strcpy(descriptor.version, cJSON_GetObjectItem(json, "version")->valuestring);
+    strcpy(descriptor.uuid, cJSON_GetObjectItem(json, "uuid")->valuestring);
+
+    cJSON_Delete(json);
+    free(buf);
+
+    return descriptor;
+}
+
+char *get_meta_key_text(enum metakey meta_key) {
+
+    switch (meta_key) {
+        case MetaContent:
+            return "content";
+        case MetaWidth:
+            return "width";
+        case MetaHeight:
+            return "height";
+        case MetaMediaDuration:
+            return "duration";
+        case MetaMediaAudioCodec:
+            return "audioc";
+        case MetaMediaVideoCodec:
+            return "videoc";
+        case MetaMediaBitrate:
+            return "bitrate";
+        case MetaArtist:
+            return "artist";
+        case MetaAlbum:
+            return "album";
+        case MetaAlbumArtist:
+            return "album_artist";
+        case MetaGenre:
+            return "genre";
+        case MetaTitle:
+            return "title";
+        case MetaFontName:
+            return "font_name";
+        default:
+            return NULL;
+    }
+}
+
+
+void write_document(document_t *doc) {
+
+    if (IndexFd == -1) {
+        char dstfile[PATH_MAX];
+        pid_t tid = syscall(SYS_gettid);
+        snprintf(dstfile, PATH_MAX, "%s_index_%d", ScanCtx.index.path, tid);
+        IndexFd = open(dstfile, O_CREAT | O_WRONLY | O_APPEND, S_IRUSR | S_IWUSR);
+
+        if (IndexFd == -1) {
+            perror("open");
+        }
+    }
+
+    dyn_buffer_t buf = dyn_buffer_create();
+
+    // Ignore root directory in the file path
+    doc->ext = (short)(doc->ext - ScanCtx.index.desc.root_len);
+    doc->base = (short)(doc->base - ScanCtx.index.desc.root_len);
+    doc->filepath += ScanCtx.index.desc.root_len;
+
+    dyn_buffer_write(&buf, doc, sizeof(line_t));
+    dyn_buffer_write_str(&buf, doc->filepath);
+
+    meta_line_t *meta = doc->meta_head;
+    while (meta != NULL) {
+        dyn_buffer_write_char(&buf, meta->key);
+
+        if (IS_META_INT(meta->key)) {
+            dyn_buffer_write_int(&buf, meta->intval);
+        } else if (IS_META_LONG(meta->key)) {
+            dyn_buffer_write_long(&buf, meta->longval);
+        } else {
+            dyn_buffer_write_str(&buf, meta->strval);
+        }
+
+        meta_line_t *tmp = meta;
+        meta = meta->next;
+        free(tmp);
+    }
+    dyn_buffer_write_char(&buf, '\n');
+
+    write(IndexFd, buf.buf, buf.cur);
+    ScanCtx.stat_index_size += buf.cur;
+    dyn_buffer_destroy(&buf);
+}
+
+void serializer_cleanup() {
+    close(IndexFd);
+}
+
+void read_index(const char *path, const char index_id[UUID_STR_LEN], index_func func) {
+
+    line_t line;
+    dyn_buffer_t buf = dyn_buffer_create();
+
+    FILE *file = fopen(path, "rb");
+    while (1) {
+        buf.cur = 0;
+        fread((void *) &line, 1, sizeof(line_t), file);
+        if (feof(file)) {
+            break;
+        }
+
+        cJSON *document = cJSON_CreateObject();
+        cJSON_AddStringToObject(document, "index", index_id);
+
+        char uuid_str[UUID_STR_LEN];
+        uuid_unparse(line.uuid, uuid_str);
+
+        cJSON_AddStringToObject(document, "mime", mime_get_mime_text(line.mime));
+        cJSON_AddNumberToObject(document, "size", (double)line.size);
+        cJSON_AddNumberToObject(document, "mtime", line.mtime);
+
+        int c;
+        while ((c = getc(file)) != 0) {
+            dyn_buffer_write_char(&buf, (char) c);
+        }
+        dyn_buffer_write_char(&buf, '\0');
+
+        cJSON_AddStringToObject(document, "extension", buf.buf + line.ext);
+        if (*(buf.buf + line.ext - 1) == '.') {
+            *(buf.buf + line.ext - 1) = '\0';
+        } else {
+            *(buf.buf + line.ext) = '\0';
+        }
+        cJSON_AddStringToObject(document, "name", buf.buf + line.base);
+        *(buf.buf + line.base - 1) = '\0';
+        cJSON_AddStringToObject(document, "path", buf.buf);
+
+        enum metakey key = getc(file);
+        while (key != '\n') {
+            switch (key) {
+                case MetaWidth:
+                case MetaHeight:
+                case MetaMediaDuration:
+                case MetaMediaBitrate: {
+                    int value;
+                    fread(&value, sizeof(int), 1, file);
+                    cJSON_AddNumberToObject(document, get_meta_key_text(key), value);
+                    break;
+                }
+                case MetaMediaAudioCodec:
+                case MetaMediaVideoCodec: {
+                    int value;
+                    fread(&value, sizeof(int), 1, file);
+                    const AVCodecDescriptor *desc = avcodec_descriptor_get(value);
+                    if (desc != NULL) {
+                        cJSON_AddStringToObject(document, get_meta_key_text(key), desc->name);
+                    }
+                    break;
+                }
+
+                case MetaContent:
+                case MetaArtist:
+                case MetaAlbum:
+                case MetaAlbumArtist:
+                case MetaGenre:
+                case MetaFontName:
+                case MetaTitle: {
+                    buf.cur = 0;
+                    while ((c = getc(file)) != 0) {
+                        dyn_buffer_write_char(&buf, (char) c);
+                    }
+                    dyn_buffer_write_char(&buf, '\0');
+                    cJSON_AddStringToObject(document, get_meta_key_text(key), buf.buf);
+                    break;
+                }
+            }
+
+            key = getc(file);
+        }
+
+        func(document, uuid_str);
+        cJSON_free(document);
+    }
+    fclose(file);
+}
+
+void incremental_read(GHashTable *table, const char *filepath) {
+    FILE *file = fopen(filepath, "rb");
+    line_t line;
+
+    while (1) {
+        fread((void *) &line, 1, sizeof(line_t), file);
+        if (feof(file)) {
+            break;
+        }
+
+        incremental_put(table, line.ino, line.mtime);
+
+        while ((getc(file))) {}
+        skip_meta(file);
+    }
+    fclose(file);
+}
+
+/**
+ * Copy items from an index that are in the copy_table. Also copies from
+ * the store.
+ */
+void incremental_copy(store_t *store, store_t *dst_store, const char *filepath,
+                      const char *dst_filepath, GHashTable *copy_table) {
+    FILE *file = fopen(filepath, "rb");
+    FILE *dst_file = fopen(dst_filepath, "ab");
+    line_t line;
+
+    while (1) {
+        fread((void *) &line, 1, sizeof(line_t), file);
+        if (feof(file)) {
+            break;
+        }
+
+        if (incremental_get(copy_table, line.ino)) {
+            fwrite(&line, sizeof(line), 1, dst_file);
+
+            size_t buf_len;
+            char *buf = store_read(store, (char *) line.uuid, 16, &buf_len);
+            store_write(dst_store, (char *) line.uuid, 16, buf, buf_len);
+
+            char c;
+            while ((c = (char) getc(file))) {
+                fwrite(&c, sizeof(c), 1, dst_file);
+            }
+            fwrite("\0", sizeof(c), 1, dst_file);
+
+            enum metakey key;
+            while (1) {
+                key = getc(file);
+                if (key == '\n') {
+                    break;
+                }
+                fwrite(&key, sizeof(char), 1, dst_file);
+
+                if (IS_META_INT(key)) {
+                    int val;
+                    fread(&val, sizeof(val), 1, file);
+                    fwrite(&val, sizeof(val), 1, dst_file);
+                } else if (IS_META_LONG(key)) {
+                    long val;
+                    fread(&val, sizeof(val), 1, file);
+                    fwrite(&val, sizeof(val), 1, dst_file);
+                } else {
+                    while ((c = (char) getc(file))) {
+                        fwrite(&c, sizeof(c), 1, dst_file);
+                    }
+                    fwrite("\0", sizeof(c), 1, dst_file);
+                }
+            }
+        } else {
+            skip_meta(file);
+        }
+    }
+    fclose(file);
+}

src/io/serialize.h

@@ -0,0 +1,27 @@
+#ifndef SIST2_SERIALIZE_H
+#define SIST2_SERIALIZE_H
+
+#include "src/sist.h"
+#include <sys/syscall.h>
+
+typedef void(*index_func)(cJSON *, const char[UUID_STR_LEN]);
+
+void incremental_copy(store_t *store, store_t *dst_store, const char *filepath,
+                      const char *dst_filepath, GHashTable *copy_table);
+
+void write_document(document_t *doc);
+
+void read_index(const char *path, const char[UUID_STR_LEN], index_func);
+
+void incremental_read(GHashTable *table, const char *filepath);
+
+/**
+ * Must be called after write_document
+ */
+void serializer_cleanup();
+
+void write_index_descriptor(char *path, index_descriptor_t *desc);
+
+index_descriptor_t read_index_descriptor(char *path);
+
+#endif

src/io/store.c

@@ -0,0 +1,105 @@
+#include "store.h"
+#include "src/ctx.h"
+
+store_t *store_create(char *path) {
+
+    store_t *store = malloc(sizeof(struct store_t));
+    pthread_rwlock_init(&store->lock, NULL);
+
+    mdb_env_create(&store->env);
+
+    int open_ret = mdb_env_open(store->env,
+                 path,
+                 MDB_WRITEMAP | MDB_MAPASYNC,
+                 S_IRUSR | S_IWUSR
+    );
+
+    if (open_ret != 0) {
+        fprintf(stderr, "Error while opening store: %s", mdb_strerror(open_ret));
+        exit(1);
+    }
+
+    store->size = (size_t) 1024 * 1024 * 5;
+    ScanCtx.stat_tn_size = store->size;
+    mdb_env_set_mapsize(store->env, store->size);
+
+    // Open dbi
+    MDB_txn *txn;
+    int r3 = mdb_txn_begin(store->env, NULL, 0, &txn);
+    int r4 = mdb_dbi_open(txn, NULL, 0, &store->dbi);
+    mdb_txn_commit(txn);
+
+    return store;
+}
+
+void store_destroy(store_t *store) {
+
+    pthread_rwlock_destroy(&store->lock);
+    mdb_close(store->env, store->dbi);
+    mdb_env_close(store->env);
+    free(store);
+}
+
+void store_write(store_t *store, char *key, size_t key_len, char *buf, size_t buf_len) {
+
+    MDB_val mdb_key;
+    mdb_key.mv_data = key;
+    mdb_key.mv_size = key_len;
+
+    MDB_val mdb_value;
+    mdb_value.mv_data = buf;
+    mdb_value.mv_size = buf_len;
+
+    MDB_txn *txn;
+    pthread_rwlock_rdlock(&store->lock);
+    mdb_txn_begin(store->env, NULL, 0, &txn);
+
+    int put_ret = mdb_put(txn, store->dbi, &mdb_key, &mdb_value, 0);
+
+    if (put_ret == MDB_MAP_FULL) {
+        mdb_txn_abort(txn);
+        pthread_rwlock_unlock(&store->lock);
+
+        // Cannot resize when there is a opened transaction.
+        //  Resize take effect on the next commit.
+        pthread_rwlock_wrlock(&store->lock);
+        store->size += 1024 * 1024 * 5;
+        mdb_env_set_mapsize(store->env, store->size);
+        mdb_txn_begin(store->env, NULL, 0, &txn);
+        put_ret = mdb_put(txn, store->dbi, &mdb_key, &mdb_value, 0);
+        ScanCtx.stat_tn_size = store->size;
+    }
+
+    mdb_txn_commit(txn);
+    pthread_rwlock_unlock(&store->lock);
+
+    if (put_ret != 0) {
+        printf("%s\n", mdb_strerror(put_ret));
+    }
+}
+
+char *store_read(store_t *store, char *key, size_t key_len, size_t *ret_vallen) {
+    char *buf = NULL;
+    MDB_val mdb_key;
+    mdb_key.mv_data = key;
+    mdb_key.mv_size = key_len;
+
+    MDB_val mdb_value;
+
+    MDB_txn *txn;
+    mdb_txn_begin(store->env, NULL, MDB_RDONLY, &txn);
+
+    int get_ret = mdb_get(txn, store->dbi, &mdb_key, &mdb_value);
+
+    if (get_ret == MDB_NOTFOUND) {
+        *ret_vallen = 0;
+    } else {
+        *ret_vallen = mdb_value.mv_size;
+        buf = malloc(mdb_value.mv_size);
+        memcpy(buf, mdb_value.mv_data, mdb_value.mv_size);
+    }
+
+    mdb_txn_abort(txn);
+    return buf;
+}
+

src/io/store.h

@@ -0,0 +1,24 @@
+#ifndef SIST2_STORE_H
+#define SIST2_STORE_H
+
+#include <pthread.h>
+#include <lmdb.h>
+
+typedef struct store_t {
+    MDB_dbi dbi;
+    MDB_env *env;
+    size_t size;
+    pthread_rwlock_t lock;
+} store_t;
+
+#include "src/sist.h"
+
+store_t *store_create(char *path);
+
+void store_destroy(store_t *store);
+
+void store_write(store_t *store, char *key, size_t key_len, char *buf, size_t buf_len);
+
+char *store_read(store_t *store, char *key, size_t key_len, size_t *ret_vallen);
+
+#endif

src/io/walk.c

@@ -0,0 +1,34 @@
+#include "walk.h"
+#include "src/ctx.h"
+
+parse_job_t *create_parse_job(const char *filepath, const struct stat *info, int base) {
+    int len = (int) strlen(filepath);
+
+    parse_job_t *job = malloc(sizeof(parse_job_t) + len);
+
+    memcpy(&(job->filepath), filepath, len + 1);
+    job->base = base;
+    char *p = strrchr(filepath + base, '.');
+    if (p != NULL) {
+        job->ext = (int)(p - filepath + 1);
+    } else {
+        job->ext = len;
+    }
+
+    memcpy(&(job->info), info, sizeof(struct stat));
+
+    return job;
+}
+
+int handle_entry(const char *filepath, const struct stat *info, const int typeflag, struct FTW *ftw) {
+    if (typeflag == FTW_F && S_ISREG(info->st_mode)) {
+        parse_job_t *job = create_parse_job(filepath, info, ftw->base);
+        tpool_add_work(ScanCtx.pool, parse, job);
+    }
+
+    return 0;
+}
+
+int walk_directory_tree(const char *dirpath) {
+    return nftw(dirpath, handle_entry, 15, FTW_PHYS);
+}

src/io/walk.h

@@ -0,0 +1,10 @@
+#ifndef WALK_H
+#define WALK_H
+
+#define _XOPEN_SOURCE 500
+
+#include "src/sist.h"
+
+int walk_directory_tree(const char *);
+
+#endif

src/main.c

@@ -0,0 +1,333 @@
+#include "sist.h"
+#include "ctx.h"
+
+static const char *const Version = "1.0.0";
+
+static const char *const usage[] = {
+        "sist2 scan [OPTION]... PATH",
+        "sist2 index [OPTION]... INDEX",
+        "sist2 web [OPTION]... INDEX...",
+        NULL,
+};
+
+void init_dir(const char *dirpath) {
+    char path[PATH_MAX];
+    snprintf(path, PATH_MAX, "%sdescriptor.json", dirpath);
+
+    uuid_t uuid;
+    uuid_generate_time_safe(uuid);
+    uuid_unparse(uuid, ScanCtx.index.desc.uuid);
+    time(&ScanCtx.index.desc.timestamp);
+    strcpy(ScanCtx.index.desc.version, Version);
+
+    write_index_descriptor(path, &ScanCtx.index.desc);
+}
+
+void scan_print_header() {
+    printf("sist2 V%s\n", Version);
+    printf("---------------------\n");
+    printf("threads\t\t%d\n", ScanCtx.threads);
+    printf("tn_qscale\t%.1f/31.0\n", ScanCtx.tn_qscale);
+    printf("tn_size\t\t%dpx\n", ScanCtx.tn_size);
+    printf("output\t\t%s\n", ScanCtx.index.path);
+}
+
+void sist2_scan(const char *path, const char *incremental_from) {
+
+    av_log_set_level(AV_LOG_QUIET);
+
+    strcpy(ScanCtx.index.desc.root, abspath(path));
+    ScanCtx.index.desc.root_len = (short) strlen(ScanCtx.index.desc.root);
+
+    init_dir(ScanCtx.index.path);
+
+    ScanCtx.mime_table = mime_get_mime_table();
+    ScanCtx.ext_table = mime_get_ext_table();
+
+    char store_path[PATH_MAX];
+    snprintf(store_path, PATH_MAX, "%sthumbs", ScanCtx.index.path);
+    mkdir(store_path, S_IWUSR | S_IRUSR | S_IXUSR);
+    ScanCtx.index.store = store_create(store_path);
+
+    scan_print_header();
+
+    if (incremental_from != NULL) {
+        incremental_from = abspath(incremental_from);
+        ScanCtx.original_table = incremental_get_table();
+        ScanCtx.copy_table = incremental_get_table();
+
+        DIR *dir = opendir(incremental_from);
+        if (dir == NULL) {
+            perror("opendir");
+            return;
+        }
+        struct dirent *de;
+        while ((de = readdir(dir)) != NULL) {
+            if (strncmp(de->d_name, "_index_", sizeof("_index_") - 1) == 0) {
+                char file_path[PATH_MAX];
+                snprintf(file_path, PATH_MAX, "%s/%s", incremental_from, de->d_name);
+                incremental_read(ScanCtx.original_table, file_path);
+            }
+        }
+        closedir(dir);
+
+        printf("Loaded %d items in to mtime table.", g_hash_table_size(ScanCtx.original_table));
+    }
+
+    walk_directory_tree(ScanCtx.index.desc.root);
+    tpool_wait(ScanCtx.pool);
+
+    if (incremental_from != NULL) {
+        char dst_path[PATH_MAX];
+        snprintf(store_path, PATH_MAX, "%sthumbs", incremental_from);
+        snprintf(dst_path, PATH_MAX, "%s_index_original", ScanCtx.index.path);
+        store_t *source = store_create(store_path);
+
+        DIR *dir = opendir(incremental_from);
+        if (dir == NULL) {
+            perror("opendir");
+            return;
+        }
+        struct dirent *de;
+        while ((de = readdir(dir)) != NULL) {
+            if (strncmp(de->d_name, "_index_", sizeof("_index_") - 1) == 0) {
+                char file_path[PATH_MAX];
+                snprintf(file_path, PATH_MAX, "%s/%s", incremental_from, de->d_name);
+                incremental_copy(source, ScanCtx.index.store, file_path, dst_path, ScanCtx.copy_table);
+            }
+        }
+        closedir(dir);
+        store_destroy(source);
+    }
+
+    store_destroy(ScanCtx.index.store);
+    tpool_destroy(ScanCtx.pool);
+}
+
+void sist2_index(const char *path, int print_index, int arg_force_reset) {
+    if (!print_index) {
+        elastic_init(arg_force_reset);
+    }
+    char *index_path = abspath(path);
+    char descriptor_path[PATH_MAX];
+    snprintf(descriptor_path, PATH_MAX, "%s/descriptor.json", index_path);
+
+    index_descriptor_t desc = read_index_descriptor(descriptor_path);
+    if (strcmp(desc.version, Version) != 0) {
+        fprintf(stderr, "Version mismatch! Index is v%s but executable is v%s\n", desc.version, Version);
+        return;
+    }
+
+    DIR *dir = opendir(index_path);
+    if (dir == NULL) {
+        perror("opendir");
+        return;
+    }
+
+    index_func f;
+    if (print_index) {
+        f = print_json;
+    } else {
+        f = index_json;
+    }
+
+    struct dirent *de;
+    while ((de = readdir(dir)) != NULL) {
+        if (strncmp(de->d_name, "_index_", sizeof("_index_") - 1) == 0) {
+            char file_path[PATH_MAX];
+            snprintf(file_path, PATH_MAX, "%s/%s", index_path, de->d_name);
+            read_index(file_path, desc.uuid, f);
+        }
+    }
+
+    if (!print_index) {
+        elastic_flush();
+        destroy_indexer();
+    }
+}
+
+void sist2_web(const char *indices[], int index_count, const char *host, const char *port) {
+
+    for (int i = 0; i < index_count; i++) {
+        char *abs_path = abspath(indices[i]);
+
+        char path_tmp[PATH_MAX];
+
+        snprintf(path_tmp, PATH_MAX, "%sthumbs", abs_path);
+        WebCtx.indices[i].store = store_create(path_tmp);
+
+        snprintf(path_tmp, PATH_MAX, "%sdescriptor.json", abs_path);
+        WebCtx.indices[i].desc = read_index_descriptor(path_tmp);
+
+        strcpy(WebCtx.indices[i].path, abs_path);
+        printf("Loaded index: %s\n", WebCtx.indices[i].desc.name);
+    }
+
+    WebCtx.index_count = index_count;
+
+    serve(host, port);
+}
+
+int main(int argc, const char *argv[]) {
+
+    curl_global_init(CURL_GLOBAL_NOTHING);
+
+    float arg_quality = 0;
+    int arg_size = 0;
+    int arg_content_size = 0;
+    int arg_threads = 0;
+    char *arg_incremental = NULL;
+    char *arg_output = NULL;
+    char *arg_rewrite_url = NULL;
+    char *arg_name = NULL;
+
+    char *arg_es_url = NULL;
+    int arg_print_index = 0;
+    int arg_force_reset = 0;
+
+    char *arg_web_host = NULL;
+    char *arg_web_port = NULL;
+
+    struct argparse_option options[] = {
+            OPT_HELP(),
+
+            OPT_GROUP("Scan options"),
+            OPT_INTEGER('t', "threads", &arg_threads, "Number of threads. DEFAULT=1"),
+            OPT_FLOAT('q', "quality", &arg_quality,
+                      "Thumbnail quality, on a scale of 1.0 to 31.0, 1.0 being the best. DEFAULT=15"),
+            OPT_INTEGER(0, "size", &arg_size, "Thumbnail size, in pixels. DEFAULT=200"),
+            OPT_INTEGER(0, "content-size", &arg_content_size,
+                        "Number of bytes to be extracted from text documents. DEFAULT=4096"),
+            OPT_STRING(0, "incremental", &arg_incremental, "Reuse an existing index and only scan modified files."),
+            OPT_STRING('o', "output", &arg_output, "Output directory. DEFAULT=index.sist2/"),
+            OPT_STRING(0, "rewrite-url", &arg_rewrite_url, "Serve files from this url instead of from disk."),
+            OPT_STRING(0, "name", &arg_name, "Index display name. DEFAULT: (name of the directory)"),
+
+            OPT_GROUP("Index options"),
+            OPT_STRING(0, "es-url", &arg_es_url, "Elasticsearch url. DEFAULT=http://localhost:9200"),
+            OPT_BOOLEAN('p', "print", &arg_print_index, "Just print JSON documents to stdout."),
+            OPT_BOOLEAN('f', "force-reset", &arg_force_reset, "Reset Elasticsearch mappings and settings. "
+                                                              "(You must use this option the first time you use the index command)"),
+
+            OPT_GROUP("Web options"),
+            OPT_STRING(0, "es-url", &arg_es_url, "Elasticsearch url. DEFAULT=http://localhost:9200"),
+            OPT_STRING(0, "bind", &arg_web_host, "Listen on this address. DEFAULT=localhost"),
+            OPT_STRING(0, "port", &arg_web_port, "Listen on this port. DEFAULT=4090"),
+
+            OPT_END(),
+    };
+
+    struct argparse argparse;
+    argparse_init(&argparse, options, usage, 0);
+    argparse_describe(
+            &argparse,
+            "\nLightning-fast file system indexer and search tool.",
+            "\nMade by simon987 <me@simon987.net>. Released under GPL-3.0"
+    );
+
+    argc = argparse_parse(&argparse, argc, argv);
+
+    //Set defaults
+    if (arg_quality == 0) {
+        arg_quality = 15;
+    } else if (arg_quality < 1 || arg_quality > 31) {
+        fprintf(stderr, "Invalid quality: %f\n", arg_quality);
+        return 1;
+    }
+
+    if (arg_size == 0) {
+        arg_size = 200;
+    } else if (arg_size <= 0) {
+        fprintf(stderr, "Invalid size: %d\n", arg_size);
+        return 1;
+    }
+
+    if (arg_content_size == 0) {
+        arg_content_size = 4096;
+    } else if (arg_content_size <= 0) {
+        fprintf(stderr, "Invalid content-size: %d\n", arg_content_size);
+        return 1;
+    }
+
+    if (arg_threads == 0) {
+        arg_threads = 1;
+    } else if (arg_threads < 0) {
+        fprintf(stderr, "Invalid threads: %d\n", arg_threads);
+        return 1;
+    }
+
+    if (arg_output == NULL) {
+        arg_output = "index.sist2/";
+    }
+
+    if (arg_es_url == NULL) {
+        arg_es_url = "http://localhost:9200";
+    }
+
+    if (arg_web_host == NULL) {
+        arg_web_host = "localhost";
+    }
+
+    if (arg_web_port == NULL) {
+        arg_web_port = "4090";
+    }
+
+    // Commands
+    if (argc == 0) {
+        argparse_usage(&argparse);
+    } else if (strcmp(argv[0], "scan") == 0) {
+        if (argc < 2) {
+            fprintf(stderr, "Required positional argument: PATH.\n");
+            argparse_usage(&argparse);
+            return 1;
+        }
+
+        if (arg_name == NULL) {
+            arg_name = g_path_get_basename(argv[1]);
+        }
+
+        int ret = mkdir(arg_output, S_IRUSR | S_IWUSR | S_IXUSR);
+        if (ret != 0) {
+            fprintf(stderr, "Invalid output: '%s' (%s).\n", arg_output, strerror(errno));
+            return 1;
+        }
+
+        ScanCtx.tn_qscale = arg_quality;
+        ScanCtx.tn_size = arg_size;
+        ScanCtx.content_size = arg_content_size;
+        ScanCtx.pool = tpool_create(arg_threads, serializer_cleanup);
+        ScanCtx.threads = arg_threads;
+        strncpy(ScanCtx.index.path, arg_output, sizeof(ScanCtx.index.path));
+        strncpy(ScanCtx.index.desc.name, arg_name, sizeof(ScanCtx.index.desc.name));
+        if (arg_rewrite_url == NULL) {
+            strcpy(ScanCtx.index.desc.rewrite_url, "");
+        } else {
+            strcpy(ScanCtx.index.desc.rewrite_url, arg_rewrite_url);
+        }
+        sist2_scan(argv[1], arg_incremental);
+    } else if (strcmp(argv[0], "index") == 0) {
+        if (argc < 2) {
+            fprintf(stderr, "Required positional argument: PATH.\n");
+            argparse_usage(&argparse);
+            return 1;
+        }
+        IndexCtx.es_url = arg_es_url;
+
+        sist2_index(argv[1], arg_print_index, arg_force_reset);
+    } else if (strcmp(argv[0], "web") == 0) {
+        if (argc < 2) {
+            fprintf(stderr, "Required positional argument: PATH.\n");
+            argparse_usage(&argparse);
+            return 1;
+        }
+        WebCtx.es_url = arg_es_url;
+
+        sist2_web(argv + 1, argc - 1, arg_web_host, arg_web_port);
+    } else {
+        fprintf(stderr, "Invalid command: '%s'\n", argv[0]);
+        argparse_usage(&argparse);
+        return 1;
+    }
+    printf("\n");
+    return 0;
+}

src/parsing/font.c

@@ -0,0 +1,211 @@
+#include "font.h"
+
+#include "ft2build.h"
+#include "freetype/freetype.h"
+
+#include "src/ctx.h"
+
+__thread FT_Library library = NULL;
+
+
+typedef struct text_dimensions {
+    unsigned int width;
+    unsigned int height;
+    unsigned int baseline;
+} text_dimensions_t;
+
+typedef struct glyph {
+    unsigned int top;
+    unsigned int height;
+    unsigned int width;
+    unsigned int descent;
+    unsigned int ascent;
+    unsigned int advance_width;
+    unsigned char *pixmap;
+} glyph_t;
+
+
+__always_inline
+int kerning_offset(char c, char pc, FT_Face face) {
+    FT_Vector kerning;
+    FT_Get_Kerning(face, c, pc, FT_KERNING_DEFAULT, &kerning);
+
+    return (int) (kerning.x / 64);
+}
+
+__always_inline
+glyph_t ft_glyph_to_glyph(FT_GlyphSlot slot) {
+    glyph_t glyph;
+
+    glyph.pixmap = slot->bitmap.buffer;
+
+    glyph.width = slot->bitmap.width;
+    glyph.height = slot->bitmap.rows;
+    glyph.top = slot->bitmap_top;
+    glyph.advance_width = slot->advance.x / 64;
+
+    glyph.descent = MAX(0, glyph.height - glyph.top);
+    glyph.ascent = MAX(0, MAX(glyph.top, glyph.height) - glyph.descent);
+
+    return glyph;
+}
+
+__always_inline
+glyph_t get_glyph(char character, FT_Face face) {
+}
+
+text_dimensions_t text_dimension(char *text, FT_Face face) {
+    text_dimensions_t dimensions;
+
+    dimensions.width = 0;
+
+    int num_chars = (int) strlen(text);
+
+    unsigned int max_ascent = 0;
+    unsigned int max_descent = 0;
+
+    char pc = 0;
+    for (int i = 0; i < num_chars; i++) {
+        char c = text[i];
+
+        FT_Load_Char(face, c, 0);
+        glyph_t glyph = ft_glyph_to_glyph(face->glyph);
+
+        max_descent = MAX(max_descent, glyph.descent);
+        max_ascent = MAX(max_ascent, glyph.ascent);
+
+        int kerning_x = kerning_offset(c, pc, face);
+        dimensions.width += MAX(glyph.advance_width, glyph.width) + kerning_x;
+
+        pc = c;
+    }
+
+    dimensions.height = max_ascent + max_descent;
+    dimensions.baseline = max_descent;
+
+    return dimensions;
+}
+
+void draw_glyph(glyph_t *glyph, int x, int y, struct text_dimensions text_info, unsigned char *bitmap) {
+    unsigned int src = 0;
+    unsigned int dst = y * text_info.width + x;
+    unsigned int row_offset = text_info.width - glyph->width;
+    unsigned int buf_len = text_info.width * text_info.height;
+
+    for (unsigned int sy = 0; sy < glyph->height; sy++) {
+        for (unsigned int sx = 0; sx < glyph->width; sx++) {
+            if (dst < buf_len) {
+                bitmap[dst] |= glyph->pixmap[src];
+            }
+            src++;
+            dst++;
+        }
+        dst += row_offset;
+    }
+}
+
+void bmp_format(dyn_buffer_t *buf, text_dimensions_t dimensions, const unsigned char *bitmap) {
+
+    dyn_buffer_write_short(buf, 0x4D42); // Magic
+    dyn_buffer_write_int(buf, 0); // Size placeholder
+    dyn_buffer_write_int(buf, 0x5157); //Reserved
+    dyn_buffer_write_int(buf, 14 + 40 + 256 * 4); // pixels offset
+
+    dyn_buffer_write_int(buf, 40); // DIB size
+    dyn_buffer_write_int(buf, (int) dimensions.width);
+    dyn_buffer_write_int(buf, (int) dimensions.height);
+    dyn_buffer_write_short(buf, 1); // Color planes
+    dyn_buffer_write_short(buf, 8); // bits per pixel
+    dyn_buffer_write_int(buf, 0); // compression
+    dyn_buffer_write_int(buf, 0); // Ignored
+    dyn_buffer_write_int(buf, 3800); // hres
+    dyn_buffer_write_int(buf, 3800); // vres
+    dyn_buffer_write_int(buf, 256); // Color count
+    dyn_buffer_write_int(buf, 0); // Ignored
+
+    // RGBA32 Color table (Grayscale)
+    for (int i = 255; i >= 0; i--) {
+        dyn_buffer_write_int(buf, i + (i << 8) + (i << 16));
+    }
+
+    // Pixel array: write from bottom to top, with rows padded to multiples of 4-bytes
+    for (int y = (int) dimensions.height - 1; y >= 0; y--) {
+        for (unsigned int x = 0; x < dimensions.width; x++) {
+            dyn_buffer_write_char(buf, (char) bitmap[y * dimensions.width + x]);
+        }
+        while (buf->cur % 4 != 0) {
+            dyn_buffer_write_char(buf, 0);
+        }
+    }
+
+    // Size
+    *(int *) ((char *) buf->buf + 2) = buf->cur;
+}
+
+void parse_font(const char *buf, size_t buf_len, document_t *doc) {
+    if (library == NULL) {
+        FT_Init_FreeType(&library);
+    }
+
+    FT_Face face;
+    FT_Error err = FT_New_Memory_Face(library, (unsigned char *) buf, buf_len, 0, &face);
+    if (err != 0) {
+        return;
+    }
+
+    char font_name[1024];
+
+    if (face->style_name == NULL || *(face->style_name) == '?') {
+        strcpy(font_name, face->family_name);
+    } else {
+        snprintf(font_name, sizeof(font_name), "%s %s", face->family_name, face->style_name);
+    }
+
+    meta_line_t *meta_name = malloc(sizeof(meta_line_t) + strlen(font_name));
+    meta_name->key = MetaFontName;
+    strcpy(meta_name->strval, font_name);
+    APPEND_META(doc, meta_name)
+
+    int pixel = 64;
+    int num_chars = (int) strlen(font_name);
+
+    err = FT_Set_Pixel_Sizes(face, 0, pixel);
+    if (err != 0) {
+        return;
+    }
+
+    text_dimensions_t dimensions = text_dimension(font_name, face);
+    unsigned char *bitmap = calloc(dimensions.width * dimensions.height, 1);
+
+    FT_Vector pen;
+    pen.x = 0;
+
+    char pc = 0;
+    for (int i = 0; i < num_chars; i++) {
+        char c = font_name[i];
+
+        err = FT_Load_Char(face, c, FT_LOAD_NO_HINTING | FT_LOAD_RENDER);
+        if (err != 0) {
+            continue;
+        }
+        glyph_t glyph = ft_glyph_to_glyph(face->glyph);
+
+        pen.x += kerning_offset(c, pc, face);
+        pen.y = dimensions.height - glyph.ascent - dimensions.baseline;
+
+        draw_glyph(&glyph, pen.x, pen.y, dimensions, bitmap);
+
+        pen.x += glyph.advance_width;
+        pc = c;
+    }
+
+    dyn_buffer_t bmp_data = dyn_buffer_create();
+    bmp_format(&bmp_data, dimensions, bitmap);
+
+    store_write(ScanCtx.index.store, (char *) doc->uuid, sizeof(doc->uuid), (char *) bmp_data.buf, bmp_data.cur);
+
+    dyn_buffer_destroy(&bmp_data);
+    free(bitmap);
+
+    FT_Done_Face(face);
+}

src/parsing/font.h

@@ -0,0 +1,9 @@
+#ifndef SIST2_FONT_H
+#define SIST2_FONT_H
+
+#include "src/sist.h"
+
+
+void parse_font(const char * buf, size_t buf_len, document_t *doc);
+
+#endif

src/parsing/media.c

@@ -0,0 +1,269 @@
+#include "src/sist.h"
+#include "src/ctx.h"
+
+AVCodecContext *alloc_jpeg_encoder(int dstW, int dstH, float qscale) {
+
+    AVCodec *jpeg_codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
+    AVCodecContext *jpeg = avcodec_alloc_context3(jpeg_codec);
+    jpeg->width = dstW;
+    jpeg->height = dstH;
+    jpeg->time_base.den = 1000000;
+    jpeg->time_base.num = 1;
+    jpeg->i_quant_factor = qscale;
+
+    jpeg->pix_fmt = AV_PIX_FMT_YUVJ420P;
+    int ret = avcodec_open2(jpeg, jpeg_codec, NULL);
+
+    if (ret != 0) {
+        printf("Could not open jpeg encoder: %s!\n", av_err2str(ret));
+        return NULL;
+    }
+
+    return jpeg;
+}
+
+AVFrame *scale_frame(const AVCodecContext *decoder, const AVFrame *frame, int size) {
+    AVFrame *scaled_frame = av_frame_alloc();
+
+    int dstW;
+    int dstH;
+    if (frame->width <= size && frame->height <= size) {
+        dstW = frame->width;
+        dstH = frame->height;
+    } else {
+        double ratio = (double) frame->width / frame->height;
+        if (frame->width > frame->height) {
+            dstW = size;
+            dstH = (int) (size / ratio);
+        } else {
+            dstW = (int) (size * ratio);
+            dstH = size;
+        }
+    }
+
+    struct SwsContext *ctx = sws_getContext(
+            decoder->width, decoder->height, decoder->pix_fmt,
+            dstW, dstH, AV_PIX_FMT_YUVJ420P,
+            SWS_FAST_BILINEAR, 0, 0, 0
+    );
+
+    int dst_buf_len = avpicture_get_size(AV_PIX_FMT_YUVJ420P, dstW, dstH);
+    uint8_t *dst_buf = (uint8_t *) av_malloc(dst_buf_len);
+
+    avpicture_fill((AVPicture *) scaled_frame, dst_buf, AV_PIX_FMT_YUVJ420P, dstW, dstH);
+
+    sws_scale(ctx,
+              (const uint8_t *const *) frame->data, frame->linesize,
+              0, decoder->height,
+              scaled_frame->data, scaled_frame->linesize
+    );
+
+    scaled_frame->width = dstW;
+    scaled_frame->height = dstH;
+    scaled_frame->format = AV_PIX_FMT_YUV420P;
+
+    sws_freeContext(ctx);
+
+    return scaled_frame;
+}
+
+AVFrame *read_frame(AVFormatContext *pFormatCtx, AVCodecContext *decoder, int stream_idx) {
+    AVFrame *frame = av_frame_alloc();
+
+    AVPacket avPacket;
+    av_init_packet(&avPacket);
+
+    int receive_ret = -EAGAIN;
+    while (receive_ret == -EAGAIN) {
+        // Get video frame
+        while (1) {
+            int read_frame_ret = av_read_frame(pFormatCtx, &avPacket);
+
+            if (read_frame_ret != 0) {
+                if (read_frame_ret != AVERROR_EOF) {
+                    fprintf(stderr, "Error reading frame: %s\n", av_err2str(read_frame_ret));
+                }
+                av_frame_free(&frame);
+                av_packet_unref(&avPacket);
+                return NULL;
+            }
+
+            //Ignore audio/other frames
+            if (avPacket.stream_index != stream_idx) {
+                av_packet_unref(&avPacket);
+                continue;
+            }
+            break;
+        }
+
+        // Feed it to decoder
+        int decode_ret = avcodec_send_packet(decoder, &avPacket);
+        if (decode_ret != 0) {
+            printf("Error decoding frame: %s\n", av_err2str(decode_ret));
+        }
+        av_packet_unref(&avPacket);
+        receive_ret = avcodec_receive_frame(decoder, frame);
+    }
+    return frame;
+}
+
+void append_audio_meta(AVFormatContext *pFormatCtx, document_t *doc) {
+
+    AVDictionaryEntry *tag = NULL;
+    while ((tag = av_dict_get(pFormatCtx->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
+        char *key = tag->key;
+        for (; *key; ++key) *key = (char) tolower(*key);
+
+        if (strcmp(tag->key, "artist") == 0) {
+            size_t len = strlen(tag->value);
+            meta_line_t *meta_tag = malloc(sizeof(meta_line_t) + len);
+            meta_tag->key = MetaArtist;
+            memcpy(meta_tag->strval, tag->value, len);
+            APPEND_META(doc, meta_tag)
+        } else if (strcmp(tag->key, "genre") == 0) {
+            size_t len = strlen(tag->value);
+            meta_line_t *meta_tag = malloc(sizeof(meta_line_t) + len);
+            meta_tag->key = MetaGenre;
+            memcpy(meta_tag->strval, tag->value, len);
+            APPEND_META(doc, meta_tag)
+        } else if (strcmp(tag->key, "title") == 0) {
+            size_t len = strlen(tag->value);
+            meta_line_t *meta_tag = malloc(sizeof(meta_line_t) + len);
+            meta_tag->key = MetaTitle;
+            memcpy(meta_tag->strval, tag->value, len);
+            APPEND_META(doc, meta_tag)
+        } else if (strcmp(tag->key, "album_artist") == 0) {
+            size_t len = strlen(tag->value);
+            meta_line_t *meta_tag = malloc(sizeof(meta_line_t) + len);
+            meta_tag->key = MetaAlbumArtist;
+            memcpy(meta_tag->strval, tag->value, len);
+            APPEND_META(doc, meta_tag)
+        } else if (strcmp(tag->key, "album") == 0) {
+            size_t len = strlen(tag->value);
+            meta_line_t *meta_tag = malloc(sizeof(meta_line_t) + len);
+            meta_tag->key = MetaAlbum;
+            memcpy(meta_tag->strval, tag->value, len);
+            APPEND_META(doc, meta_tag)
+        }
+    }
+}
+
+void parse_media(const char *filepath, document_t *doc) {
+
+    int video_stream = -1;
+
+    AVFormatContext *pFormatCtx = avformat_alloc_context();
+    int res = avformat_open_input(&pFormatCtx, filepath, NULL, NULL);
+    if (res < 0) {
+        printf("ERR%s %s\n", filepath, av_err2str(res));
+        return;
+    }
+
+    avformat_find_stream_info(pFormatCtx, NULL);
+
+    for (int i = (int) pFormatCtx->nb_streams - 1; i >= 0; i--) {
+        AVStream *stream = pFormatCtx->streams[i];
+
+        if (stream->codecpar->codec_type == AVMEDIA_TYPE_AUDIO) {
+            meta_line_t *meta_audio = malloc(sizeof(meta_line_t));
+            meta_audio->key = MetaMediaAudioCodec;
+            meta_audio->intval = stream->codecpar->codec_id;
+            APPEND_META(doc, meta_audio)
+
+            append_audio_meta(pFormatCtx, doc);
+
+        } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+
+            meta_line_t *meta_vid = malloc(sizeof(meta_line_t));
+            meta_vid->key = MetaMediaVideoCodec;
+            meta_vid->intval = stream->codecpar->codec_id;
+            APPEND_META(doc, meta_vid)
+
+            meta_line_t *meta_w = malloc(sizeof(meta_line_t));
+            meta_w->key = MetaWidth;
+            meta_w->intval = stream->codecpar->width;
+            APPEND_META(doc, meta_w)
+
+            meta_line_t *meta_h = malloc(sizeof(meta_line_t));
+            meta_h->key = MetaHeight;
+            meta_h->intval = stream->codecpar->height;
+            APPEND_META(doc, meta_h)
+
+            video_stream = i;
+        }
+    }
+
+    if (video_stream != -1) {
+        AVStream *stream = pFormatCtx->streams[video_stream];
+
+        if (stream->nb_frames > 1) {
+            //This is a video (not a still image)
+            meta_line_t *meta_duration = malloc(sizeof(meta_line_t));
+            meta_duration->key = MetaMediaDuration;
+            meta_duration->longval = pFormatCtx->duration / AV_TIME_BASE;
+            APPEND_META(doc, meta_duration)
+
+            meta_line_t *meta_bitrate = malloc(sizeof(meta_line_t));
+            meta_bitrate->key = MetaMediaBitrate;
+            meta_bitrate->intval = pFormatCtx->bit_rate;
+            APPEND_META(doc, meta_bitrate)
+        }
+
+        if (stream->codecpar->width <= 20 || stream->codecpar->height <= 20) {
+            avformat_close_input(&pFormatCtx);
+            avformat_free_context(pFormatCtx);
+            return;
+        }
+
+        // Decoder
+        AVCodec *video_codec = avcodec_find_decoder(stream->codecpar->codec_id);
+        AVCodecContext *decoder = avcodec_alloc_context3(video_codec);
+        avcodec_parameters_to_context(decoder, stream->codecpar);
+        avcodec_open2(decoder, video_codec, NULL);
+
+        //Seek
+        if (stream->nb_frames > 1 && stream->codecpar->codec_id != AV_CODEC_ID_GIF) {
+            int seek_ret = 0;
+            for (int i = 20; i >= 0; i--) {
+                seek_ret = av_seek_frame(pFormatCtx, video_stream,
+                                         stream->duration * 0.10, 0);
+                if (seek_ret == 0) {
+                    break;
+                }
+            }
+        }
+
+        AVFrame *frame = read_frame(pFormatCtx, decoder, video_stream);
+        if (frame == NULL) {
+            avcodec_free_context(&decoder);
+            avformat_close_input(&pFormatCtx);
+            avformat_free_context(pFormatCtx);
+            return;
+        }
+
+        // Scale frame
+        AVFrame *scaled_frame = scale_frame(decoder, frame, ScanCtx.tn_size);
+
+        // Encode frame to jpeg
+        AVCodecContext *jpeg_encoder = alloc_jpeg_encoder(scaled_frame->width, scaled_frame->height, ScanCtx.tn_qscale);
+        avcodec_send_frame(jpeg_encoder, scaled_frame);
+
+        AVPacket jpeg_packet;
+        av_init_packet(&jpeg_packet);
+        avcodec_receive_packet(jpeg_encoder, &jpeg_packet);
+
+        // Save thumbnail
+        store_write(ScanCtx.index.store, (char *) doc->uuid, sizeof(doc->uuid), (char *) jpeg_packet.data, jpeg_packet.size);
+
+        av_packet_unref(&jpeg_packet);
+        av_frame_free(&frame);
+        av_free(*scaled_frame->data);
+        av_frame_free(&scaled_frame);
+        avcodec_free_context(&jpeg_encoder);
+        avcodec_free_context(&decoder);
+    }
+
+    avformat_close_input(&pFormatCtx);
+    avformat_free_context(pFormatCtx);
+}
+

src/parsing/media.h

@@ -0,0 +1,11 @@
+#ifndef SIST2_MEDIA_H
+#define SIST2_MEDIA_H
+
+
+#include "src/sist.h"
+
+#define MIN_VIDEO_SIZE 1024 * 64
+
+void parse_media(const char * filepath, document_t *doc);
+
+#endif

src/parsing/mime.c

@@ -0,0 +1,20 @@
+#include "mime.h"
+
+unsigned int mime_get_mime_by_ext(GHashTable *ext_table, const char * ext) {
+    char lower[64];
+    char *p = lower;
+    while ((*ext)) {
+        *p++ = (char)tolower(*ext++);
+    }
+    *p = '\0';
+    return (size_t) g_hash_table_lookup(ext_table, lower);
+}
+
+unsigned int mime_get_mime_by_string(GHashTable *mime_table, const char * str) {
+
+    const char * ptr = str;
+    while (*ptr == ' ' || *ptr == '[') {
+        ptr++;
+    }
+    return (size_t) g_hash_table_lookup(mime_table, ptr);
+}

src/parsing/mime.h

@@ -0,0 +1,45 @@
+#ifndef SIST2_MIME_H
+#define SIST2_MIME_H
+
+#include "src/sist.h"
+
+#define MAJOR_MIME(mime_id) (mime_id & 0x0FFF0000) >> 16
+
+#define MIME_EMPTY 1
+
+#define DONT_PARSE 0x80000000
+#define SHOULD_PARSE(mime_id) (mime_id & DONT_PARSE) != DONT_PARSE
+
+#define PDF_MASK 0x40000000
+#define IS_PDF(mime_id) (mime_id & PDF_MASK) == PDF_MASK
+
+#define FONT_MASK 0x20000000
+#define IS_FONT(mime_id) (mime_id & FONT_MASK) == FONT_MASK
+
+enum major_mime {
+    MimeInvalid = 0,
+    MimeModel = 1,
+    MimeExample = 2,
+    MimeMessage = 3,
+    MimeMultipart = 4,
+    MimeFont = 5,
+    MimeVideo = 6,
+    MimeAudio = 7,
+    MimeImage = 8,
+    MimeText = 9,
+    MimeApplication = 10,
+};
+
+enum mime;
+
+GHashTable *mime_get_mime_table();
+
+GHashTable *mime_get_ext_table();
+
+char *mime_get_mime_text(unsigned int);
+
+unsigned int mime_get_mime_by_ext(GHashTable *ext_table, const char * ext);
+
+unsigned int mime_get_mime_by_string(GHashTable *mime_table, const char * str);
+
+#endif

src/parsing/parse.c

@@ -0,0 +1,126 @@
+#include "src/sist.h"
+#include "src/ctx.h"
+
+__thread magic_t Magic;
+
+void *read_all(parse_job_t *job, const char *buf, int bytes_read, int *fd) {
+
+    void *full_buf;
+
+    if (job->info.st_size <= bytes_read) {
+        full_buf = malloc(job->info.st_size);
+        memcpy(full_buf, buf, job->info.st_size);
+    } else {
+        if (*fd == -1) {
+            *fd = open(job->filepath, O_RDONLY);
+            if (*fd == -1) {
+                perror("open");
+                printf("%s\n", job->filepath);
+                free(job);
+                return NULL;
+            }
+        }
+        full_buf = malloc(job->info.st_size);
+        memcpy(full_buf, buf, bytes_read);
+        int ret = read(*fd, full_buf + bytes_read, job->info.st_size - bytes_read);
+        if (ret == -1) {
+            perror("read");
+        }
+    }
+
+    return full_buf;
+}
+
+void parse(void *arg) {
+
+    parse_job_t *job = arg;
+    document_t doc;
+
+    if (incremental_get(ScanCtx.original_table, job->info.st_ino) == job->info.st_mtim.tv_sec) {
+        incremental_mark_file_for_copy(ScanCtx.copy_table, job->info.st_ino);
+        free(job);
+        return;
+    }
+
+    if (Magic == NULL) {
+        Magic = magic_open(MAGIC_MIME_TYPE);
+        magic_load(Magic, NULL);
+    }
+
+    doc.filepath = job->filepath;
+    doc.ext = (short) job->ext;
+    doc.base = (short) job->base;
+    doc.meta_head = NULL;
+    doc.meta_tail = NULL;
+    doc.mime = 0;
+    doc.size = job->info.st_size;
+    doc.ino = job->info.st_ino;
+    doc.mtime = job->info.st_mtim.tv_sec;
+
+    uuid_generate_time_safe(doc.uuid);
+    char *buf[PARSE_BUF_SIZE];
+
+    if (job->info.st_size == 0) {
+        doc.mime = MIME_EMPTY;
+    } else if (*(job->filepath + job->ext) != '\0') {
+        doc.mime = mime_get_mime_by_ext(ScanCtx.ext_table, job->filepath + job->ext);
+    }
+
+    int fd = -1;
+    int bytes_read = 0;
+
+    if (doc.mime == 0) {
+        // Get mime type with libmagic
+        fd = open(job->filepath, O_RDONLY);
+        if (fd == -1) {
+            perror("open");
+            free(job);
+            return;
+        }
+
+        bytes_read = read(fd, buf, PARSE_BUF_SIZE);
+
+        const char *magic_mime_str = magic_buffer(Magic, buf, bytes_read);
+        if (magic_mime_str != NULL) {
+            doc.mime = mime_get_mime_by_string(ScanCtx.mime_table, magic_mime_str);
+            if (doc.mime == 0) {
+                fprintf(stderr, "Couldn't find mime %s, %s!\n", magic_mime_str, job->filepath + job->base);
+            }
+        }
+    }
+
+    int mmime = MAJOR_MIME(doc.mime);
+
+    if (!(SHOULD_PARSE(doc.mime))) {
+
+    } else if ((mmime == MimeVideo && doc.size >= MIN_VIDEO_SIZE) || mmime == MimeAudio || mmime == MimeImage) {
+        parse_media(job->filepath, &doc);
+
+    } else if (IS_PDF(doc.mime)) {
+        void *pdf_buf = read_all(job, (char *) buf, bytes_read, &fd);
+        parse_pdf(pdf_buf, doc.size, &doc);
+
+        if (pdf_buf != buf) {
+            free(pdf_buf);
+        }
+
+    } else if (mmime == MimeText && ScanCtx.content_size > 0) {
+        parse_text(bytes_read, &fd, (char *) buf, &doc);
+
+    } else if (IS_FONT(doc.mime)) {
+        void *font_buf = read_all(job, (char *) buf, bytes_read, &fd);
+        parse_font(font_buf, doc.size, &doc);
+
+        if (font_buf != buf) {
+            free(font_buf);
+        }
+    }
+
+    write_document(&doc);
+
+    if (fd != -1) {
+        close(fd);
+    }
+
+    free(job);
+}

src/parsing/parse.h

@@ -0,0 +1,10 @@
+#ifndef SIST2_PARSE_H
+#define SIST2_PARSE_H
+
+#include "src/sist.h"
+
+#define PARSE_BUF_SIZE 4096
+
+void parse(void *arg);
+
+#endif

src/parsing/pdf.c

@@ -0,0 +1,114 @@
+#include "pdf.h"
+#include "src/ctx.h"
+
+fz_page *render_cover(fz_context *ctx, document_t *doc, fz_document *fzdoc) {
+
+    fz_page *cover = fz_load_page(ctx, fzdoc, 0);
+    fz_rect bounds = fz_bound_page(ctx, cover);
+
+    float scale;
+    unsigned char *tn_buf;
+    float w = (float) bounds.x1 - bounds.x0;
+    float h = (float) bounds.y1 - bounds.y0;
+    if (w > h) {
+        scale = (float) ScanCtx.tn_size / w;
+    } else {
+        scale = (float) ScanCtx.tn_size / h;
+    }
+    fz_matrix m = fz_scale(scale, scale);
+
+    fz_pixmap *pixmap;
+    fz_colorspace *color_space = fz_device_rgb(ctx);
+    pixmap = fz_new_pixmap_from_page(ctx, cover, m, color_space, 0);
+
+    fz_buffer *fzbuf = fz_new_buffer_from_pixmap_as_png(ctx, pixmap, fz_default_color_params);
+    size_t tn_len = fz_buffer_storage(ctx, fzbuf, &tn_buf);
+
+    store_write(ScanCtx.index.store, (char *) doc->uuid, sizeof(doc->uuid), (char *) tn_buf, tn_len);
+
+    fz_drop_pixmap(ctx, pixmap);
+    fz_drop_buffer(ctx, fzbuf);
+
+    return cover;
+}
+
+
+void fz_noop_callback(void *user, const char *message) {
+}
+
+void parse_pdf(void *buf, size_t buf_len, document_t *doc) {
+
+    //TODO error handling
+    fz_context *ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
+    fz_try(ctx)
+    {
+        fz_register_document_handlers(ctx);
+
+        ctx->warn.print = fz_noop_callback; //disable warnings
+        ctx->error.print = fz_noop_callback;
+
+        fz_stream *stream = fz_open_memory(ctx, buf, buf_len);
+        fz_document *fzdoc = fz_open_document_with_stream(ctx, mime_get_mime_text(doc->mime), stream);
+
+        int page_count = fz_count_pages(ctx, fzdoc);
+        fz_page *cover = render_cover(ctx, doc, fzdoc);
+
+        fz_stext_options opts;
+        fz_parse_stext_options(ctx, &opts, "preserve-ligatures");
+
+        text_buffer_t text_buf = text_buffer_create(ScanCtx.content_size);
+
+        for (int current_page = 0; current_page < page_count; current_page++) {
+            fz_page *page;
+            if (current_page == 0) {
+                page = cover;
+            } else {
+                page = fz_load_page(ctx, fzdoc, current_page);
+            }
+            fz_stext_page *stext = fz_new_stext_page_from_page(ctx, page, &opts);
+
+            fz_stext_block *block = stext->first_block;
+            while (block != NULL) {
+
+                if (block->type != FZ_STEXT_BLOCK_TEXT) {
+                    continue;
+                }
+
+                fz_stext_line *line = block->u.t.first_line;
+                while (line != NULL) {
+                    fz_stext_char *c = line->first_char;
+                    while (c != NULL) {
+                        if (text_buffer_append_char(&text_buf, c->c) == TEXT_BUF_FULL) {
+                            fz_drop_page(ctx, page);
+                            fz_drop_stext_page(ctx, stext);
+                            goto write_loop_end;
+                        }
+                        c = c->next;
+                    }
+                    line = line->next;
+                }
+                block = block->next;
+            }
+            fz_drop_page(ctx, page);
+            fz_drop_stext_page(ctx, stext);
+        }
+        write_loop_end:;
+        text_buffer_terminate_string(&text_buf);
+
+        meta_line_t *meta_content = malloc(sizeof(meta_line_t) + text_buf.dyn_buffer.cur);
+        meta_content->key = MetaContent;
+        memcpy(meta_content->strval, text_buf.dyn_buffer.buf, text_buf.dyn_buffer.cur);
+        text_buffer_destroy(&text_buf);
+        APPEND_META(doc, meta_content)
+
+        fz_drop_stream(ctx, stream);
+        fz_drop_document(ctx, fzdoc);
+        fz_drop_context(ctx);
+
+    }
+    fz_catch(ctx)
+    {
+//        printf("err");
+    }
+}
+

src/parsing/pdf.h

@@ -0,0 +1,9 @@
+#ifndef SIST2_PDF_H
+#define SIST2_PDF_H
+
+#include "src/sist.h"
+
+
+void parse_pdf(void *buf, size_t buf_len, document_t *doc);
+
+#endif

src/parsing/text.c

@@ -0,0 +1,43 @@
+#include "text.h"
+#include "src/ctx.h"
+
+void parse_text(int bytes_read, int *fd, char *buf, document_t *doc) {
+
+    char *intermediate_buf;
+    int intermediate_buf_len;
+
+    if (bytes_read == doc->size || bytes_read >= ScanCtx.content_size) {
+        int to_copy = MIN(bytes_read, ScanCtx.content_size);
+        intermediate_buf = malloc(to_copy);
+        intermediate_buf_len = to_copy;
+        memcpy(intermediate_buf, buf, to_copy);
+
+    } else {
+        if (*fd == -1) {
+            *fd = open(doc->filepath, O_RDONLY);
+        }
+
+        int to_read = MIN(ScanCtx.content_size, doc->size) - bytes_read;
+
+        intermediate_buf = malloc(to_read + bytes_read);
+        intermediate_buf_len = to_read + bytes_read;
+        if (bytes_read != 0) {
+            memcpy(intermediate_buf, buf, bytes_read);
+        }
+
+        read(*fd, intermediate_buf + bytes_read, to_read);
+    }
+
+    text_buffer_t text_buf = text_buffer_create(ScanCtx.content_size);
+    for (int i = 0; i < intermediate_buf_len; i++) {
+        text_buffer_append_char(&text_buf, *(intermediate_buf + i));
+    }
+    text_buffer_terminate_string(&text_buf);
+
+    meta_line_t *meta = malloc(sizeof(meta_line_t) + text_buf.dyn_buffer.cur);
+    meta->key = MetaContent;
+    strcpy(meta->strval, text_buf.dyn_buffer.buf);
+    text_buffer_destroy(&text_buf);
+    free(intermediate_buf);
+    APPEND_META(doc, meta)
+}

src/parsing/text.h

@@ -0,0 +1,8 @@
+#ifndef SIST2_TEXT_H
+#define SIST2_TEXT_H
+
+#include "src/sist.h"
+
+void parse_text(int bytes_read, int *fd, char *buf, document_t *doc);
+
+#endif

src/sist.h

@@ -0,0 +1,55 @@
+#ifndef SIST_H
+#define SIST_H
+
+#define UUID_STR_LEN 37
+
+#include <glib-2.0/glib.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <ftw.h>
+#include <uuid.h>
+#include <magic.h>
+#include <libavformat/avformat.h>
+#include <libswscale/swscale.h>
+#include <libswresample/swresample.h>
+#include <libavcodec/avcodec.h>
+#include <ctype.h>
+#include <mupdf/fitz.h>
+#include <mupdf/pdf.h>
+#include "argparse/argparse.h"
+#include <time.h>
+#include <limits.h>
+#include <pthread.h>
+#include <sys/stat.h>
+#include <wordexp.h>
+#include <onion/onion.h>
+#include <onion/handler.h>
+#include <onion/block.h>
+#include <onion/shortcuts.h>
+#include <curl/curl.h>
+
+
+#include "cJSON/cJSON.h"
+
+#include "types.h"
+#include "tpool.h"
+#include "util.h"
+#include "src/index/elastic.h"
+#include "io/store.h"
+#include "io/serialize.h"
+#include "io/walk.h"
+#include "parsing/parse.h"
+#include "parsing/mime.h"
+#include "parsing/text.h"
+#include "parsing/pdf.h"
+#include "parsing/media.h"
+#include "parsing/font.h"
+#include "index/web.h"
+#include "web/serve.h"
+
+;
+
+#endif

src/tpool.c

@@ -0,0 +1,206 @@
+#include "tpool.h"
+#include "ctx.h"
+
+typedef void (*thread_func_t)(void *arg);
+
+typedef struct tpool_work {
+    void *arg;
+    thread_func_t func;
+    struct tpool_work *next;
+} tpool_work_t;
+
+typedef struct tpool {
+    tpool_work_t *work_head;
+    tpool_work_t *work_tail;
+
+    pthread_mutex_t work_mutex;
+
+    pthread_cond_t has_work_cond;
+    pthread_cond_t working_cond;
+
+    int working_cnt;
+    int thread_cnt;
+    int work_cnt;
+    int done_cnt;
+
+    int stop;
+    void (*cleanup_func)();
+} tpool_t;
+
+
+/**
+ * Create a work object
+ */
+static tpool_work_t *tpool_work_create(thread_func_t func, void *arg) {
+
+    if (func == NULL) {
+        return NULL;
+    }
+
+    tpool_work_t *work = malloc(sizeof(tpool_work_t));
+    work->func = func;
+    work->arg = arg;
+    work->next = NULL;
+
+    return work;
+}
+
+/**
+ * Pop work object from thread pool
+ */
+static tpool_work_t *tpool_work_get(tpool_t *pool) {
+
+    tpool_work_t *work = pool->work_head;
+    if (work == NULL) {
+        return NULL;
+    }
+
+    if (work->next == NULL) {
+        pool->work_head = NULL;
+        pool->work_tail = NULL;
+    } else {
+        pool->work_head = work->next;
+    }
+
+    return work;
+}
+
+/**
+ * Push work object to thread pool
+ */
+int tpool_add_work(tpool_t *pool, thread_func_t func, void *arg) {
+
+    tpool_work_t *work = tpool_work_create(func, arg);
+    if (work == NULL) {
+        return 0;
+    }
+
+    pthread_mutex_lock(&(pool->work_mutex));
+    if (pool->work_head == NULL) {
+        pool->work_head = work;
+        pool->work_tail = pool->work_head;
+    } else {
+        pool->work_tail->next = work;
+        pool->work_tail = work;
+    }
+
+    pool->work_cnt++;
+
+    pthread_cond_broadcast(&(pool->has_work_cond));
+    pthread_mutex_unlock(&(pool->work_mutex));
+
+    return 1;
+}
+
+/**
+ * Thread worker function
+ */
+static void *tpool_worker(void *arg) {
+    tpool_t *pool = arg;
+
+    while (1) {
+        pthread_mutex_lock(&(pool->work_mutex));
+        if (pool->stop) {
+            break;
+        }
+
+        if (pool->work_head == NULL) {
+            pthread_cond_wait(&(pool->has_work_cond), &(pool->work_mutex));
+        }
+
+        tpool_work_t *work = tpool_work_get(pool);
+        pool->working_cnt++;
+        pthread_mutex_unlock(&(pool->work_mutex));
+
+        if (work != NULL) {
+            work->func(work->arg);
+            free(work);
+        }
+
+        pthread_mutex_lock(&(pool->work_mutex));
+        pool->working_cnt--;
+        pool->done_cnt++;
+
+        progress_bar_print((double)pool->done_cnt / pool->work_cnt, ScanCtx.stat_tn_size, ScanCtx.stat_index_size);
+
+        if (pool->working_cnt == 0 && pool->work_head == NULL) {
+            pthread_cond_signal(&(pool->working_cond));
+        }
+        pthread_mutex_unlock(&(pool->work_mutex));
+    }
+
+    pool->cleanup_func();
+
+    pool->thread_cnt--;
+    pthread_cond_signal(&(pool->working_cond));
+    pthread_mutex_unlock(&(pool->work_mutex));
+    return NULL;
+}
+
+void tpool_wait(tpool_t *pool) {
+    pthread_mutex_lock(&(pool->work_mutex));
+    while (1) {
+        usleep(1000000);
+        if (pool->working_cnt != 0) {
+            pthread_cond_wait(&(pool->working_cond), &(pool->work_mutex));
+        } else {
+            pool->stop = 1;
+            break;
+        }
+    }
+    pthread_mutex_unlock(&(pool->work_mutex));
+}
+
+void tpool_destroy(tpool_t *pool) {
+    if (pool == NULL) {
+        return;
+    }
+
+    pthread_mutex_lock(&(pool->work_mutex));
+    tpool_work_t *work = pool->work_head;
+    while (work != NULL) {
+        tpool_work_t *tmp = work->next;
+        free(work);
+        work = tmp;
+    }
+    pool->stop = 1;
+    pthread_cond_broadcast(&(pool->has_work_cond));
+    pthread_mutex_unlock(&(pool->work_mutex));
+
+    tpool_wait(pool);
+
+    pthread_mutex_destroy(&(pool->work_mutex));
+    pthread_cond_destroy(&(pool->has_work_cond));
+    pthread_cond_destroy(&(pool->working_cond));
+
+    free(pool);
+}
+
+/**
+ * Create a thread pool
+ * @param thread_cnt Worker threads count
+ */
+tpool_t *tpool_create(size_t thread_cnt, void cleanup_func()) {
+
+    tpool_t *pool = malloc(sizeof(tpool_t));
+    pool->thread_cnt = thread_cnt;
+    pool->working_cnt = 0;
+    pool->stop = 0;
+    pool->cleanup_func = cleanup_func;
+
+    pthread_mutex_init(&(pool->work_mutex), NULL);
+
+    pthread_cond_init(&(pool->has_work_cond), NULL);
+    pthread_cond_init(&(pool->working_cond), NULL);
+
+    pool->work_head = NULL;
+    pool->work_tail = NULL;
+
+    for (size_t i = 0; i < thread_cnt; i++) {
+        pthread_t thread;
+        pthread_create(&thread, NULL, tpool_worker, pool);
+        pthread_detach(thread);
+    }
+
+    return pool;
+}

src/tpool.h

@@ -0,0 +1,19 @@
+#ifndef SIST2_TPOOL_H
+#define SIST2_TPOOL_H
+
+#include "sist.h"
+
+struct tpool;
+typedef struct tpool tpool_t;
+
+typedef void (*thread_func_t)(void *arg);
+
+tpool_t *tpool_create(size_t num, void (*cleanup_func)());
+void tpool_destroy(tpool_t *tm);
+
+int tpool_add_work(tpool_t *pool, thread_func_t func, void *arg);
+void tpool_wait(tpool_t *tm);
+
+#endif
+
+

src/types.h

@@ -0,0 +1,87 @@
+#ifndef SIST2_TYPES_H
+#define SIST2_TYPES_H
+
+
+#define META_INT_MASK 0xF0
+#define META_STR_MASK 0xE0
+#define META_LONG_MASK 0xD0
+#define IS_META_INT(key) (key & META_INT_MASK) == META_INT_MASK
+#define IS_META_LONG(key) (key & META_LONG_MASK) == META_LONG_MASK
+#define IS_META_STR(meta) (meta->key & META_STR_MASK) == META_STR_MASK
+
+// This is written to file as a 8bit char!
+enum metakey {
+    MetaContent = 1 | META_STR_MASK,
+    MetaWidth = 2 | META_INT_MASK,
+    MetaHeight = 3 | META_INT_MASK,
+    MetaMediaDuration = 4 | META_LONG_MASK,
+    MetaMediaAudioCodec = 5 | META_INT_MASK,
+    MetaMediaVideoCodec = 6 | META_INT_MASK,
+    MetaMediaBitrate = 7 | META_LONG_MASK,
+    MetaArtist = 8 | META_STR_MASK,
+    MetaAlbum = 9 | META_STR_MASK,
+    MetaAlbumArtist = 10 | META_STR_MASK,
+    MetaGenre = 11 | META_STR_MASK,
+    MetaTitle = 12 | META_STR_MASK,
+    MetaFontName = 13 | META_STR_MASK,
+};
+
+typedef struct index_descriptor {
+    char uuid[UUID_STR_LEN];
+    char version[6];
+    long timestamp;
+    char root[PATH_MAX];
+    char rewrite_url[8196];
+    short root_len;
+    char name[1024];
+} index_descriptor_t;
+
+typedef struct index_t {
+    struct index_descriptor desc;
+    struct store_t *store;
+    char path[PATH_MAX];
+} index_t;
+
+typedef struct meta_line {
+    struct meta_line *next;
+    enum metakey key;
+    union {
+        unsigned long longval;
+        int intval;
+        char strval[0];
+    };
+} meta_line_t;
+
+
+typedef struct document {
+    unsigned char uuid[16];
+    unsigned long ino;
+    unsigned long size;
+    unsigned int mime;
+    int mtime;
+    short base;
+    short ext;
+    meta_line_t *meta_head;
+    meta_line_t *meta_tail;
+    char *filepath;
+} document_t;
+
+typedef struct parse_job_t {
+    int base;
+    int ext;
+    struct stat info;
+    char filepath[1];
+} parse_job_t;
+
+
+#define APPEND_META(doc, meta) \
+    meta->next = NULL;\
+    if (doc->meta_head == NULL) {\
+        doc->meta_head = meta;\
+        doc->meta_tail = doc->meta_head;\
+    } else {\
+        doc->meta_tail->next = meta;\
+        doc->meta_tail = meta;\
+    }
+
+#endif

src/util.c

@@ -0,0 +1,60 @@
+#define _GNU_SOURCE
+#include "util.h"
+
+
+#define PBSTR "========================================"
+#define PBWIDTH 40
+
+char *abspath(const char *path) {
+    char *abs = canonicalize_file_name(path);
+    abs = realloc(abs, strlen(abs) + 1);
+    strcat(abs, "/");
+
+    return abs;
+}
+
+void progress_bar_print(double percentage, size_t tn_size, size_t index_size) {
+
+    static int last_val = 0;
+    int val = (int) (percentage * 100);
+    if (last_val == val || val >= 100) {
+        return;
+    }
+    last_val = val;
+
+    int lpad = (int) ((percentage + 0.01) * PBWIDTH);
+    int rpad = PBWIDTH - lpad;
+
+    char tn_unit;
+    if (tn_size > 1000 * 1000 * 1000) {
+        tn_size = tn_size / 1000 / 1000 / 1000;
+        tn_unit = 'G';
+    } else {
+        tn_size = tn_size / 1000 / 1000;
+        tn_unit = 'M';
+    }
+
+    char index_unit;
+    if (index_size > 1000 * 1000 * 1000) {
+        index_size = index_size / 1000 / 1000 / 1000;
+        index_unit = 'G';
+    } else {
+        index_size = index_size / 1000 / 1000;
+        index_unit = 'M';
+    }
+
+    printf(
+            "\r%2d%%[%.*s>%*s] TN:%3d%c IDX:%3d%c",
+            val, lpad, PBSTR, rpad, "",
+            (int) tn_size, tn_unit,
+            (int) index_size, index_unit
+    );
+    fflush(stdout);
+}
+
+GHashTable *incremental_get_table() {
+    GHashTable *file_table = g_hash_table_new(g_direct_hash, g_direct_equal);
+    return file_table;
+}
+
+

src/util.h

@@ -0,0 +1,178 @@
+#ifndef SIST2_UTIL_H
+#define SIST2_UTIL_H
+
+#include <stdio.h>
+
+#define TEXT_BUF_FULL -1
+#define INITIAL_BUF_SIZE 1024 * 16
+#define SHOULD_IGNORE_CHAR(c) c < '0' || c > 'z'
+
+typedef struct dyn_buffer {
+    char *buf;
+    size_t cur;
+    size_t size;
+} dyn_buffer_t;
+
+#include "sist.h"
+
+typedef struct text_buffer {
+    size_t max_size;
+    int last_char_was_whitespace;
+    dyn_buffer_t dyn_buffer;
+} text_buffer_t;
+
+__always_inline
+dyn_buffer_t dyn_buffer_create() {
+    dyn_buffer_t buf;
+
+    buf.size = INITIAL_BUF_SIZE;
+    buf.cur = 0;
+    buf.buf = malloc(INITIAL_BUF_SIZE);
+
+    return buf;
+}
+
+__always_inline
+void grow_buffer(dyn_buffer_t *buf, size_t size) {
+    if (buf->cur + size > buf->size) {
+        do {
+            buf->size *= 2;
+        } while (buf->cur + size > buf->size);
+
+        buf->buf = realloc(buf->buf, buf->size);
+    }
+}
+
+__always_inline
+void grow_buffer_small(dyn_buffer_t *buf) {
+    if (buf->cur + sizeof(long) > buf->size) {
+        buf->size *= 2;
+        buf->buf = realloc(buf->buf, buf->size);
+    }
+}
+
+__always_inline
+void dyn_buffer_write(dyn_buffer_t *buf, void *data, size_t size) {
+    grow_buffer(buf, size);
+
+    memcpy(buf->buf + buf->cur, data, size);
+    buf->cur += size;
+}
+
+__always_inline
+void dyn_buffer_write_char(dyn_buffer_t *buf, char c) {
+    grow_buffer_small(buf);
+
+    *(buf->buf + buf->cur) = c;
+    buf->cur += sizeof(c);
+}
+
+__always_inline
+void dyn_buffer_write_str(dyn_buffer_t *buf, char *str) {
+    dyn_buffer_write(buf, str, strlen(str));
+    dyn_buffer_write_char(buf, '\0');
+}
+
+__always_inline
+void dyn_buffer_write_int(dyn_buffer_t *buf, int d) {
+    grow_buffer_small(buf);
+
+    *(int *) (buf->buf + buf->cur) = d;
+    buf->cur += sizeof(int);
+}
+
+__always_inline
+void dyn_buffer_write_short(dyn_buffer_t *buf, short s) {
+    grow_buffer_small(buf);
+
+    *(short *) (buf->buf + buf->cur) = s;
+    buf->cur += sizeof(short);
+}
+
+__always_inline
+void dyn_buffer_write_long(dyn_buffer_t *buf, unsigned long l) {
+    grow_buffer_small(buf);
+
+    *(unsigned long *) (buf->buf + buf->cur) = l;
+    buf->cur += sizeof(unsigned long);
+}
+
+__always_inline
+void dyn_buffer_destroy(dyn_buffer_t *buf) {
+    free(buf->buf);
+}
+
+__always_inline
+void text_buffer_destroy(text_buffer_t *buf) {
+    dyn_buffer_destroy(&buf->dyn_buffer);
+}
+
+__always_inline
+text_buffer_t text_buffer_create(int max_size) {
+    text_buffer_t text_buf;
+
+    text_buf.dyn_buffer = dyn_buffer_create();
+    text_buf.max_size = max_size;
+    text_buf.last_char_was_whitespace = FALSE;
+
+    return text_buf;
+}
+
+__always_inline
+void text_buffer_terminate_string(text_buffer_t *buf) {
+    dyn_buffer_write_char(&buf->dyn_buffer, '\0');
+}
+
+__always_inline
+int text_buffer_append_char(text_buffer_t *buf, int c) {
+
+    if (SHOULD_IGNORE_CHAR(c)) {
+        if (!buf->last_char_was_whitespace) {
+            dyn_buffer_write_char(&buf->dyn_buffer, ' ');
+            buf->last_char_was_whitespace = TRUE;
+
+            if (buf->dyn_buffer.cur >= buf->max_size) {
+                return TEXT_BUF_FULL;
+            }
+        }
+    } else {
+        buf->last_char_was_whitespace = FALSE;
+        dyn_buffer_write_char(&buf->dyn_buffer, (char) c);
+
+        if (buf->dyn_buffer.cur >= buf->max_size) {
+            return TEXT_BUF_FULL;
+        }
+    }
+
+    return 0;
+}
+
+char *abspath(const char * path);
+
+void progress_bar_print(double percentage, size_t tn_size, size_t index_size);
+
+
+__always_inline
+void incremental_put(GHashTable *table, unsigned long inode_no, int mtime) {
+    g_hash_table_insert(table, (gpointer) inode_no, GINT_TO_POINTER(mtime));
+}
+
+__always_inline
+int incremental_get(GHashTable *table, unsigned long inode_no) {
+    if (table != NULL) {
+        return GPOINTER_TO_INT(g_hash_table_lookup(table, (gpointer) inode_no));
+    } else {
+        return 0;
+    }
+}
+
+__always_inline
+int incremental_mark_file_for_copy(GHashTable *table, unsigned long inode_no) {
+    g_hash_table_insert(table, GINT_TO_POINTER(inode_no), GINT_TO_POINTER(1));
+}
+
+GHashTable *incremental_get_table();
+
+
+
+#endif

src/web/serve.c

@@ -0,0 +1,395 @@
+#include "serve.h"
+#include <src/ctx.h>
+#include <onion/types_internal.h>
+
+#include "static_generated.c"
+
+#define CHUNK_SIZE 1024 * 1024 * 10
+
+__always_inline
+void set_default_headers(onion_response *res) {
+    onion_response_set_header(res, "Server", "sist2");
+}
+
+index_t *get_index_by_id(const char *index_id) {
+    for (int i = WebCtx.index_count; i >= 0; i--) {
+        if (strcmp(index_id, WebCtx.indices[i].desc.uuid) == 0) {
+            return &WebCtx.indices[i];
+        }
+    }
+    return NULL;
+}
+
+store_t *get_store(const char *index_id) {
+    index_t *idx = get_index_by_id(index_id);
+    if (idx != NULL) {
+        return idx->store;
+    }
+    return NULL;
+}
+
+int search_index(void *p, onion_request *req, onion_response *res) {
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "text/html");
+    onion_response_set_length(res, sizeof(search_html));
+    onion_response_write(res, search_html, sizeof(search_html));
+    return OCS_PROCESSED;
+}
+
+int javascript(void *p, onion_request *req, onion_response *res) {
+    onion_response_set_header(res, "Content-Type", "text/javascript");
+    onion_response_set_length(res, sizeof(bundle_js));
+    onion_response_write(res, bundle_js, sizeof(bundle_js));
+    return OCS_PROCESSED;
+}
+
+int style(void *p, onion_request *req, onion_response *res) {
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "text/css");
+    onion_response_set_length(res, sizeof(bundle_css));
+    onion_response_write(res, bundle_css, sizeof(bundle_css));
+    return OCS_PROCESSED;
+}
+
+int bg_bars(void *p, onion_request *req, onion_response *res) {
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "image/png");
+    onion_response_set_length(res, sizeof(bg_bars_png));
+    onion_response_write(res, bg_bars_png, sizeof(bg_bars_png));
+    return OCS_PROCESSED;
+}
+
+int img_sprite_skin_flag(void *p, onion_request *req, onion_response *res) {
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "image/png");
+    onion_response_set_length(res, sizeof(sprite_skin_flat_png));
+    onion_response_write(res, sprite_skin_flat_png, sizeof(sprite_skin_flat_png));
+    return OCS_PROCESSED;
+}
+
+int thumbnail(void *p, onion_request *req, onion_response *res) {
+    int flags = onion_request_get_flags(req);
+    if ((flags & OR_METHODS) != OR_GET) {
+        return OCS_NOT_PROCESSED;
+    }
+    const char *arg_index = onion_request_get_query(req, "1");
+    const char *arg_uuid = onion_request_get_query(req, "2");
+
+    if (arg_uuid == NULL || arg_index == NULL) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    uuid_t uuid;
+    uuid_parse(arg_uuid, uuid);
+
+    store_t *store = get_store(arg_index);
+
+    if (store == NULL) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "image/jpeg");
+
+    size_t data_len = 0;
+    char *data = store_read(store, (char *) uuid, sizeof(uuid_t), &data_len);
+    onion_response_set_length(res, data_len);
+    int written = onion_response_write(res, data, data_len);
+    onion_response_flush(res);
+    if (written != data_len || data_len == 0) {
+        printf("Couldn't write thumb\n");
+    }
+    free(data);
+
+    return OCS_PROCESSED;
+}
+
+/**
+ * Modified version of onion_shortcut_response_file that allows
+ * browsers to seek media files.
+ */
+int chunked_response_file(const char *filename, const char *mime,
+                          int partial, onion_request *request, onion_response *res) {
+    int fd = open(filename, O_RDONLY | O_CLOEXEC);
+    struct stat st;
+
+    if (fd < 0 || stat(filename, &st) != 0 || S_ISDIR(st.st_mode)) {
+        close(fd);
+        return OCS_NOT_PROCESSED;
+    }
+
+    size_t length = st.st_size;
+    size_t ends;
+
+    const char *range = onion_request_get_header(request, "Range");
+    if (partial && range && strncmp(range, "bytes=", 6) == 0) {
+        onion_response_set_header(res, "Accept-Ranges", "bytes");
+
+        onion_response_set_code(res, HTTP_PARTIAL_CONTENT);
+
+        char tmp[1024];
+        if (strlen(range + 6) >= sizeof(tmp)) {
+            close(fd);
+            return OCS_INTERNAL_ERROR;
+        }
+        strncpy(tmp, range + 6, sizeof(tmp) - 1);
+        char *start = tmp;
+        char *end = tmp;
+
+        while (*end != '-' && *end) {
+            end++;
+        }
+
+        if (*end == '-') {
+            *end = '\0';
+            end++;
+
+            size_t starts;
+            starts = atol(start);
+            if (*end) {
+                // %d-%d
+                ends = atol(end);
+            } else {
+                // %d-
+                ends = MIN(starts + CHUNK_SIZE, length);
+            }
+            if (ends >= length || starts >= length || starts < 0) {
+                close(fd);
+                return OCS_INTERNAL_ERROR;
+            }
+            length = ends - starts;
+
+            if (starts != 0) {
+                lseek(fd, starts, SEEK_SET);
+            }
+            snprintf(tmp, sizeof(tmp), "bytes %ld-%ld/%ld",
+                     starts, ends - 1, st.st_size);
+            onion_response_set_header(res, "Content-Range", tmp);
+        }
+    }
+    onion_response_set_length(res, length);
+    onion_response_set_header(res, "Content-Type", mime);
+    onion_response_write_headers(res);
+    if ((onion_request_get_flags(request) & OR_HEAD) == OR_HEAD) {
+        length = 0;
+    }
+
+    if (length) {
+        int bytes_read = 0, bytes_written;
+        size_t total_read = 0;
+        char buf[4046];
+        if (length > sizeof(buf)) {
+            size_t max = length - sizeof(buf);
+            while (total_read < max) {
+                bytes_read = read(fd, buf, sizeof(buf));
+                if (bytes_read < 0) {
+                    break;
+                }
+                total_read += bytes_read;
+                bytes_written = onion_response_write(res, buf, bytes_read);
+                if (bytes_written != bytes_read) {
+                    break;
+                }
+            }
+        }
+        if (sizeof(buf) >= (length - total_read)) {
+            bytes_read = read(fd, buf, length - total_read);
+            onion_response_write(res, buf, bytes_read);
+        }
+    }
+    close(fd);
+    return OCS_PROCESSED;
+}
+
+int search(void *p, onion_request *req, onion_response *res) {
+
+    int flags = onion_request_get_flags(req);
+    if ((flags & OR_METHODS) != OR_POST) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    char *scroll_param;
+    const char *scroll = onion_request_get_query(req, "scroll");
+    if (scroll != NULL) {
+        scroll_param = "?scroll=3m";
+    } else {
+        scroll_param = "";
+    }
+
+    const struct onion_block_t *block = onion_request_get_data(req);
+
+    if (block == NULL) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    char url[4096];
+    snprintf(url, 4096, "%s/sist2/_search%s", WebCtx.es_url, scroll_param);
+    response_t *r = web_post(url, onion_block_data(block), "Content-Type: application/json");
+
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "application/json");
+    onion_response_set_length(res, r->size);
+
+    if (r->status_code == 200) {
+        onion_response_write(res, r->body, r->size);
+    }
+
+    free_response(r);
+
+    return OCS_PROCESSED;
+}
+
+int scroll(void *p, onion_request *req, onion_response *res) {
+
+    int flags = onion_request_get_flags(req);
+    if ((flags & OR_METHODS) != OR_GET) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    char url[4096];
+    snprintf(url, 4096, "%s/_search/scroll", WebCtx.es_url);
+
+    const char *scroll_id = onion_request_get_query(req, "scroll_id");
+
+    cJSON *json = cJSON_CreateObject();
+    cJSON_AddStringToObject(json, "scroll_id", scroll_id);
+    cJSON_AddStringToObject(json, "scroll", "3m");
+
+    char *json_str = cJSON_PrintUnformatted(json);
+    response_t *r = web_post(url, json_str, "Content-Type: application/json");
+
+    cJSON_Delete(json);
+    cJSON_free(json_str);
+
+    if (r->status_code != 200) {
+        free_response(r);
+        return OCS_NOT_PROCESSED;
+    }
+
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "application/json");
+    onion_response_set_header(res, "Content-Disposition", "application/json");
+    onion_response_set_length(res, r->size);
+    onion_response_write(res, r->body, r->size);
+    free_response(r);
+
+    return OCS_PROCESSED;
+}
+
+int serve_file_from_url(cJSON *json, index_t *idx, onion_request *req, onion_response *res) {
+
+    const char *path = cJSON_GetObjectItem(json, "path")->valuestring;
+    const char *name = cJSON_GetObjectItem(json, "name")->valuestring;
+    const char *ext = cJSON_GetObjectItem(json, "extension")->valuestring;
+
+    char url[8196];
+    snprintf(url, sizeof(url),
+             "%s%s/%s%s%s",
+             idx->desc.rewrite_url, path, name, strlen(ext) == 0 ? "" : ".", ext);
+
+    return onion_shortcut_redirect(url, req, res);
+}
+
+int serve_file_from_disk(cJSON *json, index_t *idx, onion_request *req, onion_response *res) {
+
+    const char *path = cJSON_GetObjectItem(json, "path")->valuestring;
+    const char *name = cJSON_GetObjectItem(json, "name")->valuestring;
+    const char *ext = cJSON_GetObjectItem(json, "extension")->valuestring;
+    const char *mime = cJSON_GetObjectItem(json, "mime")->valuestring;
+
+    char full_path[PATH_MAX];
+    snprintf(full_path, PATH_MAX, "%s%s/%s%s%s",
+             idx->desc.root, path, name, strlen(ext) == 0 ? "" : ".", ext);
+
+    return chunked_response_file(full_path, mime, 1, req, res);
+}
+
+int index_info(void *p, onion_request *req, onion_response *res) {
+    cJSON *json = cJSON_CreateObject();
+    cJSON *arr = cJSON_AddArrayToObject(json, "indices");
+
+    set_default_headers(res);
+    onion_response_set_header(res, "Content-Type", "application/json");
+
+    for (int i = 0; i < WebCtx.index_count; i++) {
+        index_t *idx = &WebCtx.indices[i];
+
+        cJSON *idx_json = cJSON_CreateObject();
+        cJSON_AddStringToObject(idx_json, "name", idx->desc.name);
+        cJSON_AddStringToObject(idx_json, "version", idx->desc.version);
+        cJSON_AddStringToObject(idx_json, "id", idx->desc.uuid);
+        cJSON_AddNumberToObject(idx_json, "timestamp", (double)idx->desc.timestamp);
+        cJSON_AddItemToArray(arr, idx_json);
+    }
+
+    char *json_str = cJSON_PrintUnformatted(json);
+    onion_response_write0(res, json_str);
+    free(json_str);
+    cJSON_Delete(json);
+
+    return OCS_PROCESSED;
+}
+
+int file(void *p, onion_request *req, onion_response *res) {
+
+    const char *arg_uuid = onion_request_get_query(req, "1");
+    if (arg_uuid == NULL) {
+        return OCS_PROCESSED;
+    }
+
+    cJSON *source = elastic_get_document(arg_uuid);
+
+    const char *index_id = cJSON_GetObjectItem(source, "index")->valuestring;
+
+    index_t *idx = get_index_by_id(index_id);
+
+    if (idx == NULL) {
+        return OCS_NOT_PROCESSED;
+    }
+
+    const char *name = cJSON_GetObjectItem(source, "name")->valuestring;
+    const char *ext = cJSON_GetObjectItem(source, "extension")->valuestring;
+    char disposition[8196];
+    snprintf(disposition, sizeof(disposition), "inline; filename=\"%s%s%s\"",
+             name, strlen(ext) == 0 ? "" : ".", ext);
+    onion_response_set_header(res, "Content-Disposition", disposition);
+
+    if (strlen(idx->desc.rewrite_url) == 0) {
+        return serve_file_from_disk(source, idx, req, res);
+    } else {
+        return serve_file_from_url(source, idx, req, res);
+    }
+}
+
+void serve(const char *hostname, const char *port) {
+    onion *o = onion_new(O_POOL);
+    onion_set_timeout(o, 3500);
+
+    onion_set_hostname(o, hostname);
+    onion_set_port(o, port);
+
+    onion_url *urls = onion_root_url(o);
+
+    // Static paths
+    onion_url_add(urls, "", search_index);
+    onion_url_add(urls, "css", style);
+    onion_url_add(urls, "js", javascript);
+    onion_url_add(urls, "img/bg-bars.png", bg_bars);
+    onion_url_add(urls, "img/sprite-skin-flat.png", img_sprite_skin_flag);
+
+    onion_url_add(urls, "es", search);
+    onion_url_add(urls, "scroll", scroll);
+    onion_url_add(
+            urls,
+            "^t/([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})/"
+            "([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})$",
+            thumbnail
+    );
+    onion_url_add(urls, "^f/([a-fA-F0-9]{8}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{4}-[a-fA-F0-9]{12})$", file);
+    onion_url_add(urls, "i", index_info);
+
+    printf("Starting web server @ http://%s:%s\n", hostname, port);
+
+    onion_listen(o);
+    onion_free(o);
+}

src/web/serve.h

@@ -0,0 +1,8 @@
+#ifndef SIST2_SERVE_H
+#define SIST2_SERVE_H
+
+#include "src/sist.h"
+
+void serve(const char *hostname, const char *port);
+
+#endif

web/css/auto-complete.css

@@ -0,0 +1,9 @@
+.autocomplete-suggestions {
+    text-align: left; cursor: default; border: 1px solid #ccc; border-top: 0; background: #fff; box-shadow: -1px 1px 3px rgba(0,0,0,.1);
+
+    /* core styles should not be changed */
+    position: absolute; display: none; z-index: 9999; max-height: 254px; overflow: hidden; overflow-y: auto; box-sizing: border-box;
+}
+.autocomplete-suggestion { position: relative; padding: 0 .6em; line-height: 23px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; font-size: 1.02em; color: #333; }
+.autocomplete-suggestion b { font-weight: normal; color: #1f8dd6; }
+.autocomplete-suggestion.selected { background: #f0f0f0; }

web/css/ion.rangeSlider.min.css

@@ -0,0 +1 @@
+.irs{position:relative;display:block;-webkit-touch-callout:none;-webkit-user-select:none;-khtml-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none}.irs-line{position:relative;display:block;overflow:hidden;outline:none !important}.irs-line-left,.irs-line-mid,.irs-line-right{position:absolute;display:block;top:0}.irs-line-left{left:0;width:11%}.irs-line-mid{left:9%;width:82%}.irs-line-right{right:0;width:11%}.irs-bar{position:absolute;display:block;left:0;width:0}.irs-bar-edge{position:absolute;display:block;top:0;left:0}.irs-shadow{position:absolute;display:none;left:0;width:0}.irs-slider{position:absolute;display:block;cursor:default;z-index:1}.irs-slider.single{}.irs-slider.from{}.irs-slider.to{}.irs-slider.type_last{z-index:2}.irs-min{position:absolute;display:block;left:0;cursor:default}.irs-max{position:absolute;display:block;right:0;cursor:default}.irs-from,.irs-single,.irs-to{position:absolute;display:block;top:0;left:0;cursor:default;white-space:nowrap}.irs-grid{position:absolute;display:none;bottom:0;left:0;width:100%;height:20px}.irs-with-grid .irs-grid{display:block}.irs-grid-pol{position:absolute;top:0;left:0;width:1px;height:8px;background:#000}.irs-grid-pol.small{height:4px}.irs-grid-text{position:absolute;bottom:0;left:0;white-space:nowrap;text-align:center;font-size:9px;line-height:9px;padding:0 3px;color:#000}.irs-disable-mask{position:absolute;display:block;top:0;left:-1%;width:102%;height:100%;cursor:default;background:rgba(0,0,0,0.0);z-index:2}.irs-disabled{opacity:0.4}.lt-ie9 .irs-disabled{filter: alpha(opacity=40)}.irs-hidden-input{position:absolute !important;display:block !important;top:0 !important;left:0 !important;width:0 !important;height:0 !important;font-size:0 !important;line-height:0 !important;padding:0 !important;margin:0 !important;outline:none !important;z-index:-9999 !important;background:none !important;border-style:solid !important;border-color:transparent !important}

web/css/ion.rangeSlider.skinFlat.min.css

@@ -0,0 +1 @@
+.irs-bar,.irs-bar-edge,.irs-line-left,.irs-line-mid,.irs-line-right,.irs-slider{background:url("../img/sprite-skin-flat.png") repeat-x}.irs{height:40px}.irs-with-grid{height:60px}.irs-line{height:12px;top:25px}.irs-line-left{height:12px;background-position:0 -30px}.irs-line-mid{height:12px;background-position:0 0}.irs-line-right{height:12px;background-position:100% -30px}.irs-bar{height:12px;top:25px;background-position:0 -60px}.irs-bar-edge{top:25px;height:12px;width:9px;background-position:0 -90px}.irs-shadow{height:3px;top:34px;background:#000;opacity:0.25}.lt-ie9 .irs-shadow{filter: alpha(opacity=25)}.irs-slider{width:16px;height:18px;top:22px;background-position:0 -120px}.irs-slider.state_hover,.irs-slider:hover{background-position:0 -150px}.irs-max,.irs-min{color:#999;font-size:10px;line-height:1.333;text-shadow:none;top:0;padding:1px 3px;background:#e1e4e9;-moz-border-radius:4px;border-radius:4px}.irs-from,.irs-single,.irs-to{color:#fff;font-size:10px;line-height:1.333;text-shadow:none;padding:1px 5px;background:#2196F3;-moz-border-radius:4px;border-radius:4px}.irs-from:after,.irs-single:after,.irs-to:after{position:absolute;display:block;content:"";bottom:-6px;left:50%;width:0;height:0;margin-left:-3px;overflow:hidden;border:3px solid transparent;border-top-color:#2196F3}.irs-grid-pol{background:#e1e4e9}.irs-grid-text{color:#999}.irs-disabled{}

web/css/main.css

@@ -0,0 +1,163 @@
+body {overflow-y:scroll;}
+.card {
+    margin-top: 1em;
+}
+.navbar-brand {
+    font-size: 1.75rem;
+    padding: 0;
+}
+.navbar {
+    background: #F7F7F7; border-bottom: solid 1px #dfdfdf;
+}
+.document {
+    padding: 0.5rem;
+}
+
+.document p {
+    margin-bottom: 0;
+}
+
+.document:hover p {
+    text-decoration: underline;
+}
+
+.badge-video {
+    color: #FFFFFF;
+    background-color: #F27761;
+}
+
+.badge-image {
+    color: #FFFFFF;
+    background-color: #AA99C9;
+}
+
+.badge-audio {
+    color: #FFFFFF;
+    background-color: #00ADEF;
+}
+
+.badge-resolution {
+    color: #212529;
+    background-color: #FFC107;
+}
+
+.badge-text {
+    color: #FFFFFF;
+    background-color: #FAAB3C;
+}
+
+.card-img-overlay {
+    pointer-events: none;
+    padding: 0.75rem;
+
+    bottom: unset;
+    top: 0;
+    left: unset;
+    right: unset;
+}
+
+.file-title {
+    font-size: 10pt;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    overflow: hidden;
+}
+
+.badge {
+    margin-right: 3px;
+}
+
+.fit {
+    display: block;
+    min-width: 64px;
+    max-width: 100%;
+    max-height: 175px;
+    margin: 0 auto 0;
+    padding: 3px 3px 0 3px;
+    width: auto;
+    height: auto;
+}
+
+.audio-fit {
+    height: 39px;
+    vertical-align: bottom;
+    display: inline;
+}
+
+@media (min-width: 1200px) {
+    .card-columns {
+        column-count: 4;
+    }
+}
+
+@media (min-width: 1500px) {
+    .container  {
+        max-width: 1440px;
+    }
+    .card-columns {
+        column-count: 5;
+    }
+}
+
+@media (min-width: 1800px) {
+    .container  {
+        max-width: 1550px;
+    }
+}
+
+mark {
+    background: #fff217;
+    border-radius: 0;
+    padding: 1px 0;
+}
+
+.content-div {
+    font-family: SFMono-Regular,Menlo,Monaco,Consolas,"Liberation Mono","Courier New",monospace;
+    font-size: 13px;
+    padding: 1em;
+    background-color: #f5f5f5;
+    border: 1px solid #ccc;
+    border-radius: 4px;
+    margin: 3px;
+}
+
+.irs-single, .irs-from, .irs-to {
+    font-size: 13px;
+}
+
+.irs-slider {
+    cursor: col-resize;
+}
+
+.custom-select {
+    overflow: auto;
+}
+
+.irs {
+    margin-top: 1em;
+    margin-bottom: 1em;
+}
+
+.inspire-tree .selected > .wholerow, .inspire-tree .selected > .title-wrap:hover + .wholerow
+{
+    background: none;
+}
+
+.inspire-tree {
+    font-weight: 400;
+    font-size: 14px;
+    font-family: Helvetica, Nueue, Verdana, sans-serif;
+    max-height: 350px;
+    overflow: auto;
+}
+
+.page-indicator {
+    line-height: 1rem;
+    padding: 0.5rem;
+}
+
+.btn-xs {
+    padding: .1rem .3rem;
+    font-size: .875rem;
+    border-radius: .2rem;
+}

web/js/4_lodash.min.js

@@ -0,0 +1,137 @@
+/**
+ * @license
+ * Lodash lodash.com/license | Underscore.js 1.8.3 underscorejs.org/LICENSE
+ */
+;(function(){function n(n,t,r){switch(r.length){case 0:return n.call(t);case 1:return n.call(t,r[0]);case 2:return n.call(t,r[0],r[1]);case 3:return n.call(t,r[0],r[1],r[2])}return n.apply(t,r)}function t(n,t,r,e){for(var u=-1,i=null==n?0:n.length;++u<i;){var o=n[u];t(e,o,r(o),n)}return e}function r(n,t){for(var r=-1,e=null==n?0:n.length;++r<e&&false!==t(n[r],r,n););return n}function e(n,t){for(var r=null==n?0:n.length;r--&&false!==t(n[r],r,n););return n}function u(n,t){for(var r=-1,e=null==n?0:n.length;++r<e;)if(!t(n[r],r,n))return false;
+return true}function i(n,t){for(var r=-1,e=null==n?0:n.length,u=0,i=[];++r<e;){var o=n[r];t(o,r,n)&&(i[u++]=o)}return i}function o(n,t){return!(null==n||!n.length)&&-1<v(n,t,0)}function f(n,t,r){for(var e=-1,u=null==n?0:n.length;++e<u;)if(r(t,n[e]))return true;return false}function c(n,t){for(var r=-1,e=null==n?0:n.length,u=Array(e);++r<e;)u[r]=t(n[r],r,n);return u}function a(n,t){for(var r=-1,e=t.length,u=n.length;++r<e;)n[u+r]=t[r];return n}function l(n,t,r,e){var u=-1,i=null==n?0:n.length;for(e&&i&&(r=n[++u]);++u<i;)r=t(r,n[u],u,n);
+return r}function s(n,t,r,e){var u=null==n?0:n.length;for(e&&u&&(r=n[--u]);u--;)r=t(r,n[u],u,n);return r}function h(n,t){for(var r=-1,e=null==n?0:n.length;++r<e;)if(t(n[r],r,n))return true;return false}function p(n,t,r){var e;return r(n,function(n,r,u){if(t(n,r,u))return e=r,false}),e}function _(n,t,r,e){var u=n.length;for(r+=e?1:-1;e?r--:++r<u;)if(t(n[r],r,n))return r;return-1}function v(n,t,r){if(t===t)n:{--r;for(var e=n.length;++r<e;)if(n[r]===t){n=r;break n}n=-1}else n=_(n,d,r);return n}function g(n,t,r,e){
+--r;for(var u=n.length;++r<u;)if(e(n[r],t))return r;return-1}function d(n){return n!==n}function y(n,t){var r=null==n?0:n.length;return r?m(n,t)/r:F}function b(n){return function(t){return null==t?T:t[n]}}function x(n){return function(t){return null==n?T:n[t]}}function j(n,t,r,e,u){return u(n,function(n,u,i){r=e?(e=false,n):t(r,n,u,i)}),r}function w(n,t){var r=n.length;for(n.sort(t);r--;)n[r]=n[r].c;return n}function m(n,t){for(var r,e=-1,u=n.length;++e<u;){var i=t(n[e]);i!==T&&(r=r===T?i:r+i)}return r;
+}function A(n,t){for(var r=-1,e=Array(n);++r<n;)e[r]=t(r);return e}function E(n,t){return c(t,function(t){return[t,n[t]]})}function k(n){return function(t){return n(t)}}function S(n,t){return c(t,function(t){return n[t]})}function O(n,t){return n.has(t)}function I(n,t){for(var r=-1,e=n.length;++r<e&&-1<v(t,n[r],0););return r}function R(n,t){for(var r=n.length;r--&&-1<v(t,n[r],0););return r}function z(n){return"\\"+Un[n]}function W(n){var t=-1,r=Array(n.size);return n.forEach(function(n,e){r[++t]=[e,n];
+}),r}function B(n,t){return function(r){return n(t(r))}}function L(n,t){for(var r=-1,e=n.length,u=0,i=[];++r<e;){var o=n[r];o!==t&&"__lodash_placeholder__"!==o||(n[r]="__lodash_placeholder__",i[u++]=r)}return i}function U(n){var t=-1,r=Array(n.size);return n.forEach(function(n){r[++t]=n}),r}function C(n){var t=-1,r=Array(n.size);return n.forEach(function(n){r[++t]=[n,n]}),r}function D(n){if(Rn.test(n)){for(var t=On.lastIndex=0;On.test(n);)++t;n=t}else n=Qn(n);return n}function M(n){return Rn.test(n)?n.match(On)||[]:n.split("");
+}var T,$=1/0,F=NaN,N=[["ary",128],["bind",1],["bindKey",2],["curry",8],["curryRight",16],["flip",512],["partial",32],["partialRight",64],["rearg",256]],P=/\b__p\+='';/g,Z=/\b(__p\+=)''\+/g,q=/(__e\(.*?\)|\b__t\))\+'';/g,V=/&(?:amp|lt|gt|quot|#39);/g,K=/[&<>"']/g,G=RegExp(V.source),H=RegExp(K.source),J=/<%-([\s\S]+?)%>/g,Y=/<%([\s\S]+?)%>/g,Q=/<%=([\s\S]+?)%>/g,X=/\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/,nn=/^\w*$/,tn=/[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g,rn=/[\\^$.*+?()[\]{}|]/g,en=RegExp(rn.source),un=/^\s+|\s+$/g,on=/^\s+/,fn=/\s+$/,cn=/\{(?:\n\/\* \[wrapped with .+\] \*\/)?\n?/,an=/\{\n\/\* \[wrapped with (.+)\] \*/,ln=/,? & /,sn=/[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g,hn=/\\(\\)?/g,pn=/\$\{([^\\}]*(?:\\.[^\\}]*)*)\}/g,_n=/\w*$/,vn=/^[-+]0x[0-9a-f]+$/i,gn=/^0b[01]+$/i,dn=/^\[object .+?Constructor\]$/,yn=/^0o[0-7]+$/i,bn=/^(?:0|[1-9]\d*)$/,xn=/[\xc0-\xd6\xd8-\xf6\xf8-\xff\u0100-\u017f]/g,jn=/($^)/,wn=/['\n\r\u2028\u2029\\]/g,mn="[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?(?:\\u200d(?:[^\\ud800-\\udfff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])[\\ufe0e\\ufe0f]?(?:[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|\\ud83c[\\udffb-\\udfff])?)*",An="(?:[\\u2700-\\u27bf]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff])"+mn,En="(?:[^\\ud800-\\udfff][\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]?|[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]|(?:\\ud83c[\\udde6-\\uddff]){2}|[\\ud800-\\udbff][\\udc00-\\udfff]|[\\ud800-\\udfff])",kn=RegExp("['\u2019]","g"),Sn=RegExp("[\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff]","g"),On=RegExp("\\ud83c[\\udffb-\\udfff](?=\\ud83c[\\udffb-\\udfff])|"+En+mn,"g"),In=RegExp(["[A-Z\\xc0-\\xd6\\xd8-\\xde]?[a-z\\xdf-\\xf6\\xf8-\\xff]+(?:['\u2019](?:d|ll|m|re|s|t|ve))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde]|$)|(?:[A-Z\\xc0-\\xd6\\xd8-\\xde]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?(?=[\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000]|[A-Z\\xc0-\\xd6\\xd8-\\xde](?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])|$)|[A-Z\\xc0-\\xd6\\xd8-\\xde]?(?:[a-z\\xdf-\\xf6\\xf8-\\xff]|[^\\ud800-\\udfff\\xac\\xb1\\xd7\\xf7\\x00-\\x2f\\x3a-\\x40\\x5b-\\x60\\x7b-\\xbf\\u2000-\\u206f \\t\\x0b\\f\\xa0\\ufeff\\n\\r\\u2028\\u2029\\u1680\\u180e\\u2000\\u2001\\u2002\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200a\\u202f\\u205f\\u3000\\d+\\u2700-\\u27bfa-z\\xdf-\\xf6\\xf8-\\xffA-Z\\xc0-\\xd6\\xd8-\\xde])+(?:['\u2019](?:d|ll|m|re|s|t|ve))?|[A-Z\\xc0-\\xd6\\xd8-\\xde]+(?:['\u2019](?:D|LL|M|RE|S|T|VE))?|\\d*(?:1ST|2ND|3RD|(?![123])\\dTH)(?=\\b|[a-z_])|\\d*(?:1st|2nd|3rd|(?![123])\\dth)(?=\\b|[A-Z_])|\\d+",An].join("|"),"g"),Rn=RegExp("[\\u200d\\ud800-\\udfff\\u0300-\\u036f\\ufe20-\\ufe2f\\u20d0-\\u20ff\\ufe0e\\ufe0f]"),zn=/[a-z][A-Z]|[A-Z]{2}[a-z]|[0-9][a-zA-Z]|[a-zA-Z][0-9]|[^a-zA-Z0-9 ]/,Wn="Array Buffer DataView Date Error Float32Array Float64Array Function Int8Array Int16Array Int32Array Map Math Object Promise RegExp Set String Symbol TypeError Uint8Array Uint8ClampedArray Uint16Array Uint32Array WeakMap _ clearTimeout isFinite parseInt setTimeout".split(" "),Bn={};
+Bn["[object Float32Array]"]=Bn["[object Float64Array]"]=Bn["[object Int8Array]"]=Bn["[object Int16Array]"]=Bn["[object Int32Array]"]=Bn["[object Uint8Array]"]=Bn["[object Uint8ClampedArray]"]=Bn["[object Uint16Array]"]=Bn["[object Uint32Array]"]=true,Bn["[object Arguments]"]=Bn["[object Array]"]=Bn["[object ArrayBuffer]"]=Bn["[object Boolean]"]=Bn["[object DataView]"]=Bn["[object Date]"]=Bn["[object Error]"]=Bn["[object Function]"]=Bn["[object Map]"]=Bn["[object Number]"]=Bn["[object Object]"]=Bn["[object RegExp]"]=Bn["[object Set]"]=Bn["[object String]"]=Bn["[object WeakMap]"]=false;
+var Ln={};Ln["[object Arguments]"]=Ln["[object Array]"]=Ln["[object ArrayBuffer]"]=Ln["[object DataView]"]=Ln["[object Boolean]"]=Ln["[object Date]"]=Ln["[object Float32Array]"]=Ln["[object Float64Array]"]=Ln["[object Int8Array]"]=Ln["[object Int16Array]"]=Ln["[object Int32Array]"]=Ln["[object Map]"]=Ln["[object Number]"]=Ln["[object Object]"]=Ln["[object RegExp]"]=Ln["[object Set]"]=Ln["[object String]"]=Ln["[object Symbol]"]=Ln["[object Uint8Array]"]=Ln["[object Uint8ClampedArray]"]=Ln["[object Uint16Array]"]=Ln["[object Uint32Array]"]=true,
+Ln["[object Error]"]=Ln["[object Function]"]=Ln["[object WeakMap]"]=false;var Un={"\\":"\\","'":"'","\n":"n","\r":"r","\u2028":"u2028","\u2029":"u2029"},Cn=parseFloat,Dn=parseInt,Mn=typeof global=="object"&&global&&global.Object===Object&&global,Tn=typeof self=="object"&&self&&self.Object===Object&&self,$n=Mn||Tn||Function("return this")(),Fn=typeof exports=="object"&&exports&&!exports.nodeType&&exports,Nn=Fn&&typeof module=="object"&&module&&!module.nodeType&&module,Pn=Nn&&Nn.exports===Fn,Zn=Pn&&Mn.process,qn=function(){
+try{var n=Nn&&Nn.f&&Nn.f("util").types;return n?n:Zn&&Zn.binding&&Zn.binding("util")}catch(n){}}(),Vn=qn&&qn.isArrayBuffer,Kn=qn&&qn.isDate,Gn=qn&&qn.isMap,Hn=qn&&qn.isRegExp,Jn=qn&&qn.isSet,Yn=qn&&qn.isTypedArray,Qn=b("length"),Xn=x({"\xc0":"A","\xc1":"A","\xc2":"A","\xc3":"A","\xc4":"A","\xc5":"A","\xe0":"a","\xe1":"a","\xe2":"a","\xe3":"a","\xe4":"a","\xe5":"a","\xc7":"C","\xe7":"c","\xd0":"D","\xf0":"d","\xc8":"E","\xc9":"E","\xca":"E","\xcb":"E","\xe8":"e","\xe9":"e","\xea":"e","\xeb":"e","\xcc":"I",
+"\xcd":"I","\xce":"I","\xcf":"I","\xec":"i","\xed":"i","\xee":"i","\xef":"i","\xd1":"N","\xf1":"n","\xd2":"O","\xd3":"O","\xd4":"O","\xd5":"O","\xd6":"O","\xd8":"O","\xf2":"o","\xf3":"o","\xf4":"o","\xf5":"o","\xf6":"o","\xf8":"o","\xd9":"U","\xda":"U","\xdb":"U","\xdc":"U","\xf9":"u","\xfa":"u","\xfb":"u","\xfc":"u","\xdd":"Y","\xfd":"y","\xff":"y","\xc6":"Ae","\xe6":"ae","\xde":"Th","\xfe":"th","\xdf":"ss","\u0100":"A","\u0102":"A","\u0104":"A","\u0101":"a","\u0103":"a","\u0105":"a","\u0106":"C",
+"\u0108":"C","\u010a":"C","\u010c":"C","\u0107":"c","\u0109":"c","\u010b":"c","\u010d":"c","\u010e":"D","\u0110":"D","\u010f":"d","\u0111":"d","\u0112":"E","\u0114":"E","\u0116":"E","\u0118":"E","\u011a":"E","\u0113":"e","\u0115":"e","\u0117":"e","\u0119":"e","\u011b":"e","\u011c":"G","\u011e":"G","\u0120":"G","\u0122":"G","\u011d":"g","\u011f":"g","\u0121":"g","\u0123":"g","\u0124":"H","\u0126":"H","\u0125":"h","\u0127":"h","\u0128":"I","\u012a":"I","\u012c":"I","\u012e":"I","\u0130":"I","\u0129":"i",
+"\u012b":"i","\u012d":"i","\u012f":"i","\u0131":"i","\u0134":"J","\u0135":"j","\u0136":"K","\u0137":"k","\u0138":"k","\u0139":"L","\u013b":"L","\u013d":"L","\u013f":"L","\u0141":"L","\u013a":"l","\u013c":"l","\u013e":"l","\u0140":"l","\u0142":"l","\u0143":"N","\u0145":"N","\u0147":"N","\u014a":"N","\u0144":"n","\u0146":"n","\u0148":"n","\u014b":"n","\u014c":"O","\u014e":"O","\u0150":"O","\u014d":"o","\u014f":"o","\u0151":"o","\u0154":"R","\u0156":"R","\u0158":"R","\u0155":"r","\u0157":"r","\u0159":"r",
+"\u015a":"S","\u015c":"S","\u015e":"S","\u0160":"S","\u015b":"s","\u015d":"s","\u015f":"s","\u0161":"s","\u0162":"T","\u0164":"T","\u0166":"T","\u0163":"t","\u0165":"t","\u0167":"t","\u0168":"U","\u016a":"U","\u016c":"U","\u016e":"U","\u0170":"U","\u0172":"U","\u0169":"u","\u016b":"u","\u016d":"u","\u016f":"u","\u0171":"u","\u0173":"u","\u0174":"W","\u0175":"w","\u0176":"Y","\u0177":"y","\u0178":"Y","\u0179":"Z","\u017b":"Z","\u017d":"Z","\u017a":"z","\u017c":"z","\u017e":"z","\u0132":"IJ","\u0133":"ij",
+"\u0152":"Oe","\u0153":"oe","\u0149":"'n","\u017f":"s"}),nt=x({"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"}),tt=x({"&amp;":"&","&lt;":"<","&gt;":">","&quot;":'"',"&#39;":"'"}),rt=function x(mn){function An(n){if(yu(n)&&!ff(n)&&!(n instanceof Un)){if(n instanceof On)return n;if(oi.call(n,"__wrapped__"))return Fe(n)}return new On(n)}function En(){}function On(n,t){this.__wrapped__=n,this.__actions__=[],this.__chain__=!!t,this.__index__=0,this.__values__=T}function Un(n){this.__wrapped__=n,
+this.__actions__=[],this.__dir__=1,this.__filtered__=false,this.__iteratees__=[],this.__takeCount__=4294967295,this.__views__=[]}function Mn(n){var t=-1,r=null==n?0:n.length;for(this.clear();++t<r;){var e=n[t];this.set(e[0],e[1])}}function Tn(n){var t=-1,r=null==n?0:n.length;for(this.clear();++t<r;){var e=n[t];this.set(e[0],e[1])}}function Fn(n){var t=-1,r=null==n?0:n.length;for(this.clear();++t<r;){var e=n[t];this.set(e[0],e[1])}}function Nn(n){var t=-1,r=null==n?0:n.length;for(this.__data__=new Fn;++t<r;)this.add(n[t]);
+}function Zn(n){this.size=(this.__data__=new Tn(n)).size}function qn(n,t){var r,e=ff(n),u=!e&&of(n),i=!e&&!u&&af(n),o=!e&&!u&&!i&&_f(n),u=(e=e||u||i||o)?A(n.length,ni):[],f=u.length;for(r in n)!t&&!oi.call(n,r)||e&&("length"==r||i&&("offset"==r||"parent"==r)||o&&("buffer"==r||"byteLength"==r||"byteOffset"==r)||Se(r,f))||u.push(r);return u}function Qn(n){var t=n.length;return t?n[ir(0,t-1)]:T}function et(n,t){return De(Ur(n),pt(t,0,n.length))}function ut(n){return De(Ur(n))}function it(n,t,r){(r===T||lu(n[t],r))&&(r!==T||t in n)||st(n,t,r);
+}function ot(n,t,r){var e=n[t];oi.call(n,t)&&lu(e,r)&&(r!==T||t in n)||st(n,t,r)}function ft(n,t){for(var r=n.length;r--;)if(lu(n[r][0],t))return r;return-1}function ct(n,t,r,e){return uo(n,function(n,u,i){t(e,n,r(n),i)}),e}function at(n,t){return n&&Cr(t,Wu(t),n)}function lt(n,t){return n&&Cr(t,Bu(t),n)}function st(n,t,r){"__proto__"==t&&Ai?Ai(n,t,{configurable:true,enumerable:true,value:r,writable:true}):n[t]=r}function ht(n,t){for(var r=-1,e=t.length,u=Ku(e),i=null==n;++r<e;)u[r]=i?T:Ru(n,t[r]);return u;
+}function pt(n,t,r){return n===n&&(r!==T&&(n=n<=r?n:r),t!==T&&(n=n>=t?n:t)),n}function _t(n,t,e,u,i,o){var f,c=1&t,a=2&t,l=4&t;if(e&&(f=i?e(n,u,i,o):e(n)),f!==T)return f;if(!du(n))return n;if(u=ff(n)){if(f=me(n),!c)return Ur(n,f)}else{var s=vo(n),h="[object Function]"==s||"[object GeneratorFunction]"==s;if(af(n))return Ir(n,c);if("[object Object]"==s||"[object Arguments]"==s||h&&!i){if(f=a||h?{}:Ae(n),!c)return a?Mr(n,lt(f,n)):Dr(n,at(f,n))}else{if(!Ln[s])return i?n:{};f=Ee(n,s,c)}}if(o||(o=new Zn),
+i=o.get(n))return i;o.set(n,f),pf(n)?n.forEach(function(r){f.add(_t(r,t,e,r,n,o))}):sf(n)&&n.forEach(function(r,u){f.set(u,_t(r,t,e,u,n,o))});var a=l?a?ve:_e:a?Bu:Wu,p=u?T:a(n);return r(p||n,function(r,u){p&&(u=r,r=n[u]),ot(f,u,_t(r,t,e,u,n,o))}),f}function vt(n){var t=Wu(n);return function(r){return gt(r,n,t)}}function gt(n,t,r){var e=r.length;if(null==n)return!e;for(n=Qu(n);e--;){var u=r[e],i=t[u],o=n[u];if(o===T&&!(u in n)||!i(o))return false}return true}function dt(n,t,r){if(typeof n!="function")throw new ti("Expected a function");
+return bo(function(){n.apply(T,r)},t)}function yt(n,t,r,e){var u=-1,i=o,a=true,l=n.length,s=[],h=t.length;if(!l)return s;r&&(t=c(t,k(r))),e?(i=f,a=false):200<=t.length&&(i=O,a=false,t=new Nn(t));n:for(;++u<l;){var p=n[u],_=null==r?p:r(p),p=e||0!==p?p:0;if(a&&_===_){for(var v=h;v--;)if(t[v]===_)continue n;s.push(p)}else i(t,_,e)||s.push(p)}return s}function bt(n,t){var r=true;return uo(n,function(n,e,u){return r=!!t(n,e,u)}),r}function xt(n,t,r){for(var e=-1,u=n.length;++e<u;){var i=n[e],o=t(i);if(null!=o&&(f===T?o===o&&!wu(o):r(o,f)))var f=o,c=i;
+}return c}function jt(n,t){var r=[];return uo(n,function(n,e,u){t(n,e,u)&&r.push(n)}),r}function wt(n,t,r,e,u){var i=-1,o=n.length;for(r||(r=ke),u||(u=[]);++i<o;){var f=n[i];0<t&&r(f)?1<t?wt(f,t-1,r,e,u):a(u,f):e||(u[u.length]=f)}return u}function mt(n,t){return n&&oo(n,t,Wu)}function At(n,t){return n&&fo(n,t,Wu)}function Et(n,t){return i(t,function(t){return _u(n[t])})}function kt(n,t){t=Sr(t,n);for(var r=0,e=t.length;null!=n&&r<e;)n=n[Me(t[r++])];return r&&r==e?n:T}function St(n,t,r){return t=t(n),
+ff(n)?t:a(t,r(n))}function Ot(n){if(null==n)n=n===T?"[object Undefined]":"[object Null]";else if(mi&&mi in Qu(n)){var t=oi.call(n,mi),r=n[mi];try{n[mi]=T;var e=true}catch(n){}var u=ai.call(n);e&&(t?n[mi]=r:delete n[mi]),n=u}else n=ai.call(n);return n}function It(n,t){return n>t}function Rt(n,t){return null!=n&&oi.call(n,t)}function zt(n,t){return null!=n&&t in Qu(n)}function Wt(n,t,r){for(var e=r?f:o,u=n[0].length,i=n.length,a=i,l=Ku(i),s=1/0,h=[];a--;){var p=n[a];a&&t&&(p=c(p,k(t))),s=Ci(p.length,s),
+l[a]=!r&&(t||120<=u&&120<=p.length)?new Nn(a&&p):T}var p=n[0],_=-1,v=l[0];n:for(;++_<u&&h.length<s;){var g=p[_],d=t?t(g):g,g=r||0!==g?g:0;if(v?!O(v,d):!e(h,d,r)){for(a=i;--a;){var y=l[a];if(y?!O(y,d):!e(n[a],d,r))continue n}v&&v.push(d),h.push(g)}}return h}function Bt(n,t,r){var e={};return mt(n,function(n,u,i){t(e,r(n),u,i)}),e}function Lt(t,r,e){return r=Sr(r,t),t=2>r.length?t:kt(t,hr(r,0,-1)),r=null==t?t:t[Me(Ve(r))],null==r?T:n(r,t,e)}function Ut(n){return yu(n)&&"[object Arguments]"==Ot(n)}function Ct(n){
+return yu(n)&&"[object ArrayBuffer]"==Ot(n)}function Dt(n){return yu(n)&&"[object Date]"==Ot(n)}function Mt(n,t,r,e,u){if(n===t)t=true;else if(null==n||null==t||!yu(n)&&!yu(t))t=n!==n&&t!==t;else n:{var i=ff(n),o=ff(t),f=i?"[object Array]":vo(n),c=o?"[object Array]":vo(t),f="[object Arguments]"==f?"[object Object]":f,c="[object Arguments]"==c?"[object Object]":c,a="[object Object]"==f,o="[object Object]"==c;if((c=f==c)&&af(n)){if(!af(t)){t=false;break n}i=true,a=false}if(c&&!a)u||(u=new Zn),t=i||_f(n)?se(n,t,r,e,Mt,u):he(n,t,f,r,e,Mt,u);else{
+if(!(1&r)&&(i=a&&oi.call(n,"__wrapped__"),f=o&&oi.call(t,"__wrapped__"),i||f)){n=i?n.value():n,t=f?t.value():t,u||(u=new Zn),t=Mt(n,t,r,e,u);break n}if(c)t:if(u||(u=new Zn),i=1&r,f=_e(n),o=f.length,c=_e(t).length,o==c||i){for(a=o;a--;){var l=f[a];if(!(i?l in t:oi.call(t,l))){t=false;break t}}if((c=u.get(n))&&u.get(t))t=c==t;else{c=true,u.set(n,t),u.set(t,n);for(var s=i;++a<o;){var l=f[a],h=n[l],p=t[l];if(e)var _=i?e(p,h,l,t,n,u):e(h,p,l,n,t,u);if(_===T?h!==p&&!Mt(h,p,r,e,u):!_){c=false;break}s||(s="constructor"==l);
+}c&&!s&&(r=n.constructor,e=t.constructor,r!=e&&"constructor"in n&&"constructor"in t&&!(typeof r=="function"&&r instanceof r&&typeof e=="function"&&e instanceof e)&&(c=false)),u.delete(n),u.delete(t),t=c}}else t=false;else t=false}}return t}function Tt(n){return yu(n)&&"[object Map]"==vo(n)}function $t(n,t,r,e){var u=r.length,i=u,o=!e;if(null==n)return!i;for(n=Qu(n);u--;){var f=r[u];if(o&&f[2]?f[1]!==n[f[0]]:!(f[0]in n))return false}for(;++u<i;){var f=r[u],c=f[0],a=n[c],l=f[1];if(o&&f[2]){if(a===T&&!(c in n))return false;
+}else{if(f=new Zn,e)var s=e(a,l,c,n,t,f);if(s===T?!Mt(l,a,3,e,f):!s)return false}}return true}function Ft(n){return!(!du(n)||ci&&ci in n)&&(_u(n)?hi:dn).test(Te(n))}function Nt(n){return yu(n)&&"[object RegExp]"==Ot(n)}function Pt(n){return yu(n)&&"[object Set]"==vo(n)}function Zt(n){return yu(n)&&gu(n.length)&&!!Bn[Ot(n)]}function qt(n){return typeof n=="function"?n:null==n?$u:typeof n=="object"?ff(n)?Jt(n[0],n[1]):Ht(n):Zu(n)}function Vt(n){if(!ze(n))return Li(n);var t,r=[];for(t in Qu(n))oi.call(n,t)&&"constructor"!=t&&r.push(t);
+return r}function Kt(n,t){return n<t}function Gt(n,t){var r=-1,e=su(n)?Ku(n.length):[];return uo(n,function(n,u,i){e[++r]=t(n,u,i)}),e}function Ht(n){var t=xe(n);return 1==t.length&&t[0][2]?We(t[0][0],t[0][1]):function(r){return r===n||$t(r,n,t)}}function Jt(n,t){return Ie(n)&&t===t&&!du(t)?We(Me(n),t):function(r){var e=Ru(r,n);return e===T&&e===t?zu(r,n):Mt(t,e,3)}}function Yt(n,t,r,e,u){n!==t&&oo(t,function(i,o){if(u||(u=new Zn),du(i)){var f=u,c=Le(n,o),a=Le(t,o),l=f.get(a);if(l)it(n,o,l);else{
+var l=e?e(c,a,o+"",n,t,f):T,s=l===T;if(s){var h=ff(a),p=!h&&af(a),_=!h&&!p&&_f(a),l=a;h||p||_?ff(c)?l=c:hu(c)?l=Ur(c):p?(s=false,l=Ir(a,true)):_?(s=false,l=zr(a,true)):l=[]:xu(a)||of(a)?(l=c,of(c)?l=Ou(c):du(c)&&!_u(c)||(l=Ae(a))):s=false}s&&(f.set(a,l),Yt(l,a,r,e,f),f.delete(a)),it(n,o,l)}}else f=e?e(Le(n,o),i,o+"",n,t,u):T,f===T&&(f=i),it(n,o,f)},Bu)}function Qt(n,t){var r=n.length;if(r)return t+=0>t?r:0,Se(t,r)?n[t]:T}function Xt(n,t,r){var e=-1;return t=c(t.length?t:[$u],k(ye())),n=Gt(n,function(n){return{
+a:c(t,function(t){return t(n)}),b:++e,c:n}}),w(n,function(n,t){var e;n:{e=-1;for(var u=n.a,i=t.a,o=u.length,f=r.length;++e<o;){var c=Wr(u[e],i[e]);if(c){e=e>=f?c:c*("desc"==r[e]?-1:1);break n}}e=n.b-t.b}return e})}function nr(n,t){return tr(n,t,function(t,r){return zu(n,r)})}function tr(n,t,r){for(var e=-1,u=t.length,i={};++e<u;){var o=t[e],f=kt(n,o);r(f,o)&&lr(i,Sr(o,n),f)}return i}function rr(n){return function(t){return kt(t,n)}}function er(n,t,r,e){var u=e?g:v,i=-1,o=t.length,f=n;for(n===t&&(t=Ur(t)),
+r&&(f=c(n,k(r)));++i<o;)for(var a=0,l=t[i],l=r?r(l):l;-1<(a=u(f,l,a,e));)f!==n&&xi.call(f,a,1),xi.call(n,a,1);return n}function ur(n,t){for(var r=n?t.length:0,e=r-1;r--;){var u=t[r];if(r==e||u!==i){var i=u;Se(u)?xi.call(n,u,1):xr(n,u)}}}function ir(n,t){return n+Ii(Ti()*(t-n+1))}function or(n,t){var r="";if(!n||1>t||9007199254740991<t)return r;do t%2&&(r+=n),(t=Ii(t/2))&&(n+=n);while(t);return r}function fr(n,t){return xo(Be(n,t,$u),n+"")}function cr(n){return Qn(Uu(n))}function ar(n,t){var r=Uu(n);
+return De(r,pt(t,0,r.length))}function lr(n,t,r,e){if(!du(n))return n;t=Sr(t,n);for(var u=-1,i=t.length,o=i-1,f=n;null!=f&&++u<i;){var c=Me(t[u]),a=r;if(u!=o){var l=f[c],a=e?e(l,c,f):T;a===T&&(a=du(l)?l:Se(t[u+1])?[]:{})}ot(f,c,a),f=f[c]}return n}function sr(n){return De(Uu(n))}function hr(n,t,r){var e=-1,u=n.length;for(0>t&&(t=-t>u?0:u+t),r=r>u?u:r,0>r&&(r+=u),u=t>r?0:r-t>>>0,t>>>=0,r=Ku(u);++e<u;)r[e]=n[e+t];return r}function pr(n,t){var r;return uo(n,function(n,e,u){return r=t(n,e,u),!r}),!!r}
+function _r(n,t,r){var e=0,u=null==n?e:n.length;if(typeof t=="number"&&t===t&&2147483647>=u){for(;e<u;){var i=e+u>>>1,o=n[i];null!==o&&!wu(o)&&(r?o<=t:o<t)?e=i+1:u=i}return u}return vr(n,t,$u,r)}function vr(n,t,r,e){t=r(t);for(var u=0,i=null==n?0:n.length,o=t!==t,f=null===t,c=wu(t),a=t===T;u<i;){var l=Ii((u+i)/2),s=r(n[l]),h=s!==T,p=null===s,_=s===s,v=wu(s);(o?e||_:a?_&&(e||h):f?_&&h&&(e||!p):c?_&&h&&!p&&(e||!v):p||v?0:e?s<=t:s<t)?u=l+1:i=l}return Ci(i,4294967294)}function gr(n,t){for(var r=-1,e=n.length,u=0,i=[];++r<e;){
+var o=n[r],f=t?t(o):o;if(!r||!lu(f,c)){var c=f;i[u++]=0===o?0:o}}return i}function dr(n){return typeof n=="number"?n:wu(n)?F:+n}function yr(n){if(typeof n=="string")return n;if(ff(n))return c(n,yr)+"";if(wu(n))return ro?ro.call(n):"";var t=n+"";return"0"==t&&1/n==-$?"-0":t}function br(n,t,r){var e=-1,u=o,i=n.length,c=true,a=[],l=a;if(r)c=false,u=f;else if(200<=i){if(u=t?null:so(n))return U(u);c=false,u=O,l=new Nn}else l=t?[]:a;n:for(;++e<i;){var s=n[e],h=t?t(s):s,s=r||0!==s?s:0;if(c&&h===h){for(var p=l.length;p--;)if(l[p]===h)continue n;
+t&&l.push(h),a.push(s)}else u(l,h,r)||(l!==a&&l.push(h),a.push(s))}return a}function xr(n,t){return t=Sr(t,n),n=2>t.length?n:kt(n,hr(t,0,-1)),null==n||delete n[Me(Ve(t))]}function jr(n,t,r,e){for(var u=n.length,i=e?u:-1;(e?i--:++i<u)&&t(n[i],i,n););return r?hr(n,e?0:i,e?i+1:u):hr(n,e?i+1:0,e?u:i)}function wr(n,t){var r=n;return r instanceof Un&&(r=r.value()),l(t,function(n,t){return t.func.apply(t.thisArg,a([n],t.args))},r)}function mr(n,t,r){var e=n.length;if(2>e)return e?br(n[0]):[];for(var u=-1,i=Ku(e);++u<e;)for(var o=n[u],f=-1;++f<e;)f!=u&&(i[u]=yt(i[u]||o,n[f],t,r));
+return br(wt(i,1),t,r)}function Ar(n,t,r){for(var e=-1,u=n.length,i=t.length,o={};++e<u;)r(o,n[e],e<i?t[e]:T);return o}function Er(n){return hu(n)?n:[]}function kr(n){return typeof n=="function"?n:$u}function Sr(n,t){return ff(n)?n:Ie(n,t)?[n]:jo(Iu(n))}function Or(n,t,r){var e=n.length;return r=r===T?e:r,!t&&r>=e?n:hr(n,t,r)}function Ir(n,t){if(t)return n.slice();var r=n.length,r=gi?gi(r):new n.constructor(r);return n.copy(r),r}function Rr(n){var t=new n.constructor(n.byteLength);return new vi(t).set(new vi(n)),
+t}function zr(n,t){return new n.constructor(t?Rr(n.buffer):n.buffer,n.byteOffset,n.length)}function Wr(n,t){if(n!==t){var r=n!==T,e=null===n,u=n===n,i=wu(n),o=t!==T,f=null===t,c=t===t,a=wu(t);if(!f&&!a&&!i&&n>t||i&&o&&c&&!f&&!a||e&&o&&c||!r&&c||!u)return 1;if(!e&&!i&&!a&&n<t||a&&r&&u&&!e&&!i||f&&r&&u||!o&&u||!c)return-1}return 0}function Br(n,t,r,e){var u=-1,i=n.length,o=r.length,f=-1,c=t.length,a=Ui(i-o,0),l=Ku(c+a);for(e=!e;++f<c;)l[f]=t[f];for(;++u<o;)(e||u<i)&&(l[r[u]]=n[u]);for(;a--;)l[f++]=n[u++];
+return l}function Lr(n,t,r,e){var u=-1,i=n.length,o=-1,f=r.length,c=-1,a=t.length,l=Ui(i-f,0),s=Ku(l+a);for(e=!e;++u<l;)s[u]=n[u];for(l=u;++c<a;)s[l+c]=t[c];for(;++o<f;)(e||u<i)&&(s[l+r[o]]=n[u++]);return s}function Ur(n,t){var r=-1,e=n.length;for(t||(t=Ku(e));++r<e;)t[r]=n[r];return t}function Cr(n,t,r,e){var u=!r;r||(r={});for(var i=-1,o=t.length;++i<o;){var f=t[i],c=e?e(r[f],n[f],f,r,n):T;c===T&&(c=n[f]),u?st(r,f,c):ot(r,f,c)}return r}function Dr(n,t){return Cr(n,po(n),t)}function Mr(n,t){return Cr(n,_o(n),t);
+}function Tr(n,r){return function(e,u){var i=ff(e)?t:ct,o=r?r():{};return i(e,n,ye(u,2),o)}}function $r(n){return fr(function(t,r){var e=-1,u=r.length,i=1<u?r[u-1]:T,o=2<u?r[2]:T,i=3<n.length&&typeof i=="function"?(u--,i):T;for(o&&Oe(r[0],r[1],o)&&(i=3>u?T:i,u=1),t=Qu(t);++e<u;)(o=r[e])&&n(t,o,e,i);return t})}function Fr(n,t){return function(r,e){if(null==r)return r;if(!su(r))return n(r,e);for(var u=r.length,i=t?u:-1,o=Qu(r);(t?i--:++i<u)&&false!==e(o[i],i,o););return r}}function Nr(n){return function(t,r,e){
+var u=-1,i=Qu(t);e=e(t);for(var o=e.length;o--;){var f=e[n?o:++u];if(false===r(i[f],f,i))break}return t}}function Pr(n,t,r){function e(){return(this&&this!==$n&&this instanceof e?i:n).apply(u?r:this,arguments)}var u=1&t,i=Vr(n);return e}function Zr(n){return function(t){t=Iu(t);var r=Rn.test(t)?M(t):T,e=r?r[0]:t.charAt(0);return t=r?Or(r,1).join(""):t.slice(1),e[n]()+t}}function qr(n){return function(t){return l(Mu(Du(t).replace(kn,"")),n,"")}}function Vr(n){return function(){var t=arguments;switch(t.length){
+case 0:return new n;case 1:return new n(t[0]);case 2:return new n(t[0],t[1]);case 3:return new n(t[0],t[1],t[2]);case 4:return new n(t[0],t[1],t[2],t[3]);case 5:return new n(t[0],t[1],t[2],t[3],t[4]);case 6:return new n(t[0],t[1],t[2],t[3],t[4],t[5]);case 7:return new n(t[0],t[1],t[2],t[3],t[4],t[5],t[6])}var r=eo(n.prototype),t=n.apply(r,t);return du(t)?t:r}}function Kr(t,r,e){function u(){for(var o=arguments.length,f=Ku(o),c=o,a=de(u);c--;)f[c]=arguments[c];return c=3>o&&f[0]!==a&&f[o-1]!==a?[]:L(f,a),
+o-=c.length,o<e?ue(t,r,Jr,u.placeholder,T,f,c,T,T,e-o):n(this&&this!==$n&&this instanceof u?i:t,this,f)}var i=Vr(t);return u}function Gr(n){return function(t,r,e){var u=Qu(t);if(!su(t)){var i=ye(r,3);t=Wu(t),r=function(n){return i(u[n],n,u)}}return r=n(t,r,e),-1<r?u[i?t[r]:r]:T}}function Hr(n){return pe(function(t){var r=t.length,e=r,u=On.prototype.thru;for(n&&t.reverse();e--;){var i=t[e];if(typeof i!="function")throw new ti("Expected a function");if(u&&!o&&"wrapper"==ge(i))var o=new On([],true)}for(e=o?e:r;++e<r;)var i=t[e],u=ge(i),f="wrapper"==u?ho(i):T,o=f&&Re(f[0])&&424==f[1]&&!f[4].length&&1==f[9]?o[ge(f[0])].apply(o,f[3]):1==i.length&&Re(i)?o[u]():o.thru(i);
+return function(){var n=arguments,e=n[0];if(o&&1==n.length&&ff(e))return o.plant(e).value();for(var u=0,n=r?t[u].apply(this,n):e;++u<r;)n=t[u].call(this,n);return n}})}function Jr(n,t,r,e,u,i,o,f,c,a){function l(){for(var d=arguments.length,y=Ku(d),b=d;b--;)y[b]=arguments[b];if(_){var x,j=de(l),b=y.length;for(x=0;b--;)y[b]===j&&++x}if(e&&(y=Br(y,e,u,_)),i&&(y=Lr(y,i,o,_)),d-=x,_&&d<a)return j=L(y,j),ue(n,t,Jr,l.placeholder,r,y,j,f,c,a-d);if(j=h?r:this,b=p?j[n]:n,d=y.length,f){x=y.length;for(var w=Ci(f.length,x),m=Ur(y);w--;){
+var A=f[w];y[w]=Se(A,x)?m[A]:T}}else v&&1<d&&y.reverse();return s&&c<d&&(y.length=c),this&&this!==$n&&this instanceof l&&(b=g||Vr(b)),b.apply(j,y)}var s=128&t,h=1&t,p=2&t,_=24&t,v=512&t,g=p?T:Vr(n);return l}function Yr(n,t){return function(r,e){return Bt(r,n,t(e))}}function Qr(n,t){return function(r,e){var u;if(r===T&&e===T)return t;if(r!==T&&(u=r),e!==T){if(u===T)return e;typeof r=="string"||typeof e=="string"?(r=yr(r),e=yr(e)):(r=dr(r),e=dr(e)),u=n(r,e)}return u}}function Xr(t){return pe(function(r){
+return r=c(r,k(ye())),fr(function(e){var u=this;return t(r,function(t){return n(t,u,e)})})})}function ne(n,t){t=t===T?" ":yr(t);var r=t.length;return 2>r?r?or(t,n):t:(r=or(t,Oi(n/D(t))),Rn.test(t)?Or(M(r),0,n).join(""):r.slice(0,n))}function te(t,r,e,u){function i(){for(var r=-1,c=arguments.length,a=-1,l=u.length,s=Ku(l+c),h=this&&this!==$n&&this instanceof i?f:t;++a<l;)s[a]=u[a];for(;c--;)s[a++]=arguments[++r];return n(h,o?e:this,s)}var o=1&r,f=Vr(t);return i}function re(n){return function(t,r,e){
+e&&typeof e!="number"&&Oe(t,r,e)&&(r=e=T),t=Au(t),r===T?(r=t,t=0):r=Au(r),e=e===T?t<r?1:-1:Au(e);var u=-1;r=Ui(Oi((r-t)/(e||1)),0);for(var i=Ku(r);r--;)i[n?r:++u]=t,t+=e;return i}}function ee(n){return function(t,r){return typeof t=="string"&&typeof r=="string"||(t=Su(t),r=Su(r)),n(t,r)}}function ue(n,t,r,e,u,i,o,f,c,a){var l=8&t,s=l?o:T;o=l?T:o;var h=l?i:T;return i=l?T:i,t=(t|(l?32:64))&~(l?64:32),4&t||(t&=-4),u=[n,t,u,h,s,i,o,f,c,a],r=r.apply(T,u),Re(n)&&yo(r,u),r.placeholder=e,Ue(r,n,t)}function ie(n){
+var t=Yu[n];return function(n,r){if(n=Su(n),(r=null==r?0:Ci(Eu(r),292))&&Wi(n)){var e=(Iu(n)+"e").split("e"),e=t(e[0]+"e"+(+e[1]+r)),e=(Iu(e)+"e").split("e");return+(e[0]+"e"+(+e[1]-r))}return t(n)}}function oe(n){return function(t){var r=vo(t);return"[object Map]"==r?W(t):"[object Set]"==r?C(t):E(t,n(t))}}function fe(n,t,r,e,u,i,o,f){var c=2&t;if(!c&&typeof n!="function")throw new ti("Expected a function");var a=e?e.length:0;if(a||(t&=-97,e=u=T),o=o===T?o:Ui(Eu(o),0),f=f===T?f:Eu(f),a-=u?u.length:0,
+64&t){var l=e,s=u;e=u=T}var h=c?T:ho(n);return i=[n,t,r,e,u,l,s,i,o,f],h&&(r=i[1],n=h[1],t=r|n,e=128==n&&8==r||128==n&&256==r&&i[7].length<=h[8]||384==n&&h[7].length<=h[8]&&8==r,131>t||e)&&(1&n&&(i[2]=h[2],t|=1&r?0:4),(r=h[3])&&(e=i[3],i[3]=e?Br(e,r,h[4]):r,i[4]=e?L(i[3],"__lodash_placeholder__"):h[4]),(r=h[5])&&(e=i[5],i[5]=e?Lr(e,r,h[6]):r,i[6]=e?L(i[5],"__lodash_placeholder__"):h[6]),(r=h[7])&&(i[7]=r),128&n&&(i[8]=null==i[8]?h[8]:Ci(i[8],h[8])),null==i[9]&&(i[9]=h[9]),i[0]=h[0],i[1]=t),n=i[0],
+t=i[1],r=i[2],e=i[3],u=i[4],f=i[9]=i[9]===T?c?0:n.length:Ui(i[9]-a,0),!f&&24&t&&(t&=-25),Ue((h?co:yo)(t&&1!=t?8==t||16==t?Kr(n,t,f):32!=t&&33!=t||u.length?Jr.apply(T,i):te(n,t,r,e):Pr(n,t,r),i),n,t)}function ce(n,t,r,e){return n===T||lu(n,ei[r])&&!oi.call(e,r)?t:n}function ae(n,t,r,e,u,i){return du(n)&&du(t)&&(i.set(t,n),Yt(n,t,T,ae,i),i.delete(t)),n}function le(n){return xu(n)?T:n}function se(n,t,r,e,u,i){var o=1&r,f=n.length,c=t.length;if(f!=c&&!(o&&c>f))return false;if((c=i.get(n))&&i.get(t))return c==t;
+var c=-1,a=true,l=2&r?new Nn:T;for(i.set(n,t),i.set(t,n);++c<f;){var s=n[c],p=t[c];if(e)var _=o?e(p,s,c,t,n,i):e(s,p,c,n,t,i);if(_!==T){if(_)continue;a=false;break}if(l){if(!h(t,function(n,t){if(!O(l,t)&&(s===n||u(s,n,r,e,i)))return l.push(t)})){a=false;break}}else if(s!==p&&!u(s,p,r,e,i)){a=false;break}}return i.delete(n),i.delete(t),a}function he(n,t,r,e,u,i,o){switch(r){case"[object DataView]":if(n.byteLength!=t.byteLength||n.byteOffset!=t.byteOffset)break;n=n.buffer,t=t.buffer;case"[object ArrayBuffer]":
+if(n.byteLength!=t.byteLength||!i(new vi(n),new vi(t)))break;return true;case"[object Boolean]":case"[object Date]":case"[object Number]":return lu(+n,+t);case"[object Error]":return n.name==t.name&&n.message==t.message;case"[object RegExp]":case"[object String]":return n==t+"";case"[object Map]":var f=W;case"[object Set]":if(f||(f=U),n.size!=t.size&&!(1&e))break;return(r=o.get(n))?r==t:(e|=2,o.set(n,t),t=se(f(n),f(t),e,u,i,o),o.delete(n),t);case"[object Symbol]":if(to)return to.call(n)==to.call(t)}
+return false}function pe(n){return xo(Be(n,T,Ze),n+"")}function _e(n){return St(n,Wu,po)}function ve(n){return St(n,Bu,_o)}function ge(n){for(var t=n.name+"",r=Gi[t],e=oi.call(Gi,t)?r.length:0;e--;){var u=r[e],i=u.func;if(null==i||i==n)return u.name}return t}function de(n){return(oi.call(An,"placeholder")?An:n).placeholder}function ye(){var n=An.iteratee||Fu,n=n===Fu?qt:n;return arguments.length?n(arguments[0],arguments[1]):n}function be(n,t){var r=n.__data__,e=typeof t;return("string"==e||"number"==e||"symbol"==e||"boolean"==e?"__proto__"!==t:null===t)?r[typeof t=="string"?"string":"hash"]:r.map;
+}function xe(n){for(var t=Wu(n),r=t.length;r--;){var e=t[r],u=n[e];t[r]=[e,u,u===u&&!du(u)]}return t}function je(n,t){var r=null==n?T:n[t];return Ft(r)?r:T}function we(n,t,r){t=Sr(t,n);for(var e=-1,u=t.length,i=false;++e<u;){var o=Me(t[e]);if(!(i=null!=n&&r(n,o)))break;n=n[o]}return i||++e!=u?i:(u=null==n?0:n.length,!!u&&gu(u)&&Se(o,u)&&(ff(n)||of(n)))}function me(n){var t=n.length,r=new n.constructor(t);return t&&"string"==typeof n[0]&&oi.call(n,"index")&&(r.index=n.index,r.input=n.input),r}function Ae(n){
+return typeof n.constructor!="function"||ze(n)?{}:eo(di(n))}function Ee(n,t,r){var e=n.constructor;switch(t){case"[object ArrayBuffer]":return Rr(n);case"[object Boolean]":case"[object Date]":return new e(+n);case"[object DataView]":return t=r?Rr(n.buffer):n.buffer,new n.constructor(t,n.byteOffset,n.byteLength);case"[object Float32Array]":case"[object Float64Array]":case"[object Int8Array]":case"[object Int16Array]":case"[object Int32Array]":case"[object Uint8Array]":case"[object Uint8ClampedArray]":
+case"[object Uint16Array]":case"[object Uint32Array]":return zr(n,r);case"[object Map]":return new e;case"[object Number]":case"[object String]":return new e(n);case"[object RegExp]":return t=new n.constructor(n.source,_n.exec(n)),t.lastIndex=n.lastIndex,t;case"[object Set]":return new e;case"[object Symbol]":return to?Qu(to.call(n)):{}}}function ke(n){return ff(n)||of(n)||!!(ji&&n&&n[ji])}function Se(n,t){var r=typeof n;return t=null==t?9007199254740991:t,!!t&&("number"==r||"symbol"!=r&&bn.test(n))&&-1<n&&0==n%1&&n<t;
+}function Oe(n,t,r){if(!du(r))return false;var e=typeof t;return!!("number"==e?su(r)&&Se(t,r.length):"string"==e&&t in r)&&lu(r[t],n)}function Ie(n,t){if(ff(n))return false;var r=typeof n;return!("number"!=r&&"symbol"!=r&&"boolean"!=r&&null!=n&&!wu(n))||(nn.test(n)||!X.test(n)||null!=t&&n in Qu(t))}function Re(n){var t=ge(n),r=An[t];return typeof r=="function"&&t in Un.prototype&&(n===r||(t=ho(r),!!t&&n===t[0]))}function ze(n){var t=n&&n.constructor;return n===(typeof t=="function"&&t.prototype||ei)}function We(n,t){
+return function(r){return null!=r&&(r[n]===t&&(t!==T||n in Qu(r)))}}function Be(t,r,e){return r=Ui(r===T?t.length-1:r,0),function(){for(var u=arguments,i=-1,o=Ui(u.length-r,0),f=Ku(o);++i<o;)f[i]=u[r+i];for(i=-1,o=Ku(r+1);++i<r;)o[i]=u[i];return o[r]=e(f),n(t,this,o)}}function Le(n,t){if(("constructor"!==t||"function"!=typeof n[t])&&"__proto__"!=t)return n[t]}function Ue(n,t,r){var e=t+"";t=xo;var u,i=$e;return u=(u=e.match(an))?u[1].split(ln):[],r=i(u,r),(i=r.length)&&(u=i-1,r[u]=(1<i?"& ":"")+r[u],
+r=r.join(2<i?", ":" "),e=e.replace(cn,"{\n/* [wrapped with "+r+"] */\n")),t(n,e)}function Ce(n){var t=0,r=0;return function(){var e=Di(),u=16-(e-r);if(r=e,0<u){if(800<=++t)return arguments[0]}else t=0;return n.apply(T,arguments)}}function De(n,t){var r=-1,e=n.length,u=e-1;for(t=t===T?e:t;++r<t;){var e=ir(r,u),i=n[e];n[e]=n[r],n[r]=i}return n.length=t,n}function Me(n){if(typeof n=="string"||wu(n))return n;var t=n+"";return"0"==t&&1/n==-$?"-0":t}function Te(n){if(null!=n){try{return ii.call(n)}catch(n){}
+return n+""}return""}function $e(n,t){return r(N,function(r){var e="_."+r[0];t&r[1]&&!o(n,e)&&n.push(e)}),n.sort()}function Fe(n){if(n instanceof Un)return n.clone();var t=new On(n.__wrapped__,n.__chain__);return t.__actions__=Ur(n.__actions__),t.__index__=n.__index__,t.__values__=n.__values__,t}function Ne(n,t,r){var e=null==n?0:n.length;return e?(r=null==r?0:Eu(r),0>r&&(r=Ui(e+r,0)),_(n,ye(t,3),r)):-1}function Pe(n,t,r){var e=null==n?0:n.length;if(!e)return-1;var u=e-1;return r!==T&&(u=Eu(r),u=0>r?Ui(e+u,0):Ci(u,e-1)),
+_(n,ye(t,3),u,true)}function Ze(n){return(null==n?0:n.length)?wt(n,1):[]}function qe(n){return n&&n.length?n[0]:T}function Ve(n){var t=null==n?0:n.length;return t?n[t-1]:T}function Ke(n,t){return n&&n.length&&t&&t.length?er(n,t):n}function Ge(n){return null==n?n:$i.call(n)}function He(n){if(!n||!n.length)return[];var t=0;return n=i(n,function(n){if(hu(n))return t=Ui(n.length,t),true}),A(t,function(t){return c(n,b(t))})}function Je(t,r){if(!t||!t.length)return[];var e=He(t);return null==r?e:c(e,function(t){
+return n(r,T,t)})}function Ye(n){return n=An(n),n.__chain__=true,n}function Qe(n,t){return t(n)}function Xe(){return this}function nu(n,t){return(ff(n)?r:uo)(n,ye(t,3))}function tu(n,t){return(ff(n)?e:io)(n,ye(t,3))}function ru(n,t){return(ff(n)?c:Gt)(n,ye(t,3))}function eu(n,t,r){return t=r?T:t,t=n&&null==t?n.length:t,fe(n,128,T,T,T,T,t)}function uu(n,t){var r;if(typeof t!="function")throw new ti("Expected a function");return n=Eu(n),function(){return 0<--n&&(r=t.apply(this,arguments)),1>=n&&(t=T),
+r}}function iu(n,t,r){return t=r?T:t,n=fe(n,8,T,T,T,T,T,t),n.placeholder=iu.placeholder,n}function ou(n,t,r){return t=r?T:t,n=fe(n,16,T,T,T,T,T,t),n.placeholder=ou.placeholder,n}function fu(n,t,r){function e(t){var r=c,e=a;return c=a=T,_=t,s=n.apply(e,r)}function u(n){var r=n-p;return n-=_,p===T||r>=t||0>r||g&&n>=l}function i(){var n=Go();if(u(n))return o(n);var r,e=bo;r=n-_,n=t-(n-p),r=g?Ci(n,l-r):n,h=e(i,r)}function o(n){return h=T,d&&c?e(n):(c=a=T,s)}function f(){var n=Go(),r=u(n);if(c=arguments,
+a=this,p=n,r){if(h===T)return _=n=p,h=bo(i,t),v?e(n):s;if(g)return lo(h),h=bo(i,t),e(p)}return h===T&&(h=bo(i,t)),s}var c,a,l,s,h,p,_=0,v=false,g=false,d=true;if(typeof n!="function")throw new ti("Expected a function");return t=Su(t)||0,du(r)&&(v=!!r.leading,l=(g="maxWait"in r)?Ui(Su(r.maxWait)||0,t):l,d="trailing"in r?!!r.trailing:d),f.cancel=function(){h!==T&&lo(h),_=0,c=p=a=h=T},f.flush=function(){return h===T?s:o(Go())},f}function cu(n,t){function r(){var e=arguments,u=t?t.apply(this,e):e[0],i=r.cache;
+return i.has(u)?i.get(u):(e=n.apply(this,e),r.cache=i.set(u,e)||i,e)}if(typeof n!="function"||null!=t&&typeof t!="function")throw new ti("Expected a function");return r.cache=new(cu.Cache||Fn),r}function au(n){if(typeof n!="function")throw new ti("Expected a function");return function(){var t=arguments;switch(t.length){case 0:return!n.call(this);case 1:return!n.call(this,t[0]);case 2:return!n.call(this,t[0],t[1]);case 3:return!n.call(this,t[0],t[1],t[2])}return!n.apply(this,t)}}function lu(n,t){return n===t||n!==n&&t!==t;
+}function su(n){return null!=n&&gu(n.length)&&!_u(n)}function hu(n){return yu(n)&&su(n)}function pu(n){if(!yu(n))return false;var t=Ot(n);return"[object Error]"==t||"[object DOMException]"==t||typeof n.message=="string"&&typeof n.name=="string"&&!xu(n)}function _u(n){return!!du(n)&&(n=Ot(n),"[object Function]"==n||"[object GeneratorFunction]"==n||"[object AsyncFunction]"==n||"[object Proxy]"==n)}function vu(n){return typeof n=="number"&&n==Eu(n)}function gu(n){return typeof n=="number"&&-1<n&&0==n%1&&9007199254740991>=n;
+}function du(n){var t=typeof n;return null!=n&&("object"==t||"function"==t)}function yu(n){return null!=n&&typeof n=="object"}function bu(n){return typeof n=="number"||yu(n)&&"[object Number]"==Ot(n)}function xu(n){return!(!yu(n)||"[object Object]"!=Ot(n))&&(n=di(n),null===n||(n=oi.call(n,"constructor")&&n.constructor,typeof n=="function"&&n instanceof n&&ii.call(n)==li))}function ju(n){return typeof n=="string"||!ff(n)&&yu(n)&&"[object String]"==Ot(n)}function wu(n){return typeof n=="symbol"||yu(n)&&"[object Symbol]"==Ot(n);
+}function mu(n){if(!n)return[];if(su(n))return ju(n)?M(n):Ur(n);if(wi&&n[wi]){n=n[wi]();for(var t,r=[];!(t=n.next()).done;)r.push(t.value);return r}return t=vo(n),("[object Map]"==t?W:"[object Set]"==t?U:Uu)(n)}function Au(n){return n?(n=Su(n),n===$||n===-$?1.7976931348623157e308*(0>n?-1:1):n===n?n:0):0===n?n:0}function Eu(n){n=Au(n);var t=n%1;return n===n?t?n-t:n:0}function ku(n){return n?pt(Eu(n),0,4294967295):0}function Su(n){if(typeof n=="number")return n;if(wu(n))return F;if(du(n)&&(n=typeof n.valueOf=="function"?n.valueOf():n,
+n=du(n)?n+"":n),typeof n!="string")return 0===n?n:+n;n=n.replace(un,"");var t=gn.test(n);return t||yn.test(n)?Dn(n.slice(2),t?2:8):vn.test(n)?F:+n}function Ou(n){return Cr(n,Bu(n))}function Iu(n){return null==n?"":yr(n)}function Ru(n,t,r){return n=null==n?T:kt(n,t),n===T?r:n}function zu(n,t){return null!=n&&we(n,t,zt)}function Wu(n){return su(n)?qn(n):Vt(n)}function Bu(n){if(su(n))n=qn(n,true);else if(du(n)){var t,r=ze(n),e=[];for(t in n)("constructor"!=t||!r&&oi.call(n,t))&&e.push(t);n=e}else{if(t=[],
+null!=n)for(r in Qu(n))t.push(r);n=t}return n}function Lu(n,t){if(null==n)return{};var r=c(ve(n),function(n){return[n]});return t=ye(t),tr(n,r,function(n,r){return t(n,r[0])})}function Uu(n){return null==n?[]:S(n,Wu(n))}function Cu(n){return $f(Iu(n).toLowerCase())}function Du(n){return(n=Iu(n))&&n.replace(xn,Xn).replace(Sn,"")}function Mu(n,t,r){return n=Iu(n),t=r?T:t,t===T?zn.test(n)?n.match(In)||[]:n.match(sn)||[]:n.match(t)||[]}function Tu(n){return function(){return n}}function $u(n){return n;
+}function Fu(n){return qt(typeof n=="function"?n:_t(n,1))}function Nu(n,t,e){var u=Wu(t),i=Et(t,u);null!=e||du(t)&&(i.length||!u.length)||(e=t,t=n,n=this,i=Et(t,Wu(t)));var o=!(du(e)&&"chain"in e&&!e.chain),f=_u(n);return r(i,function(r){var e=t[r];n[r]=e,f&&(n.prototype[r]=function(){var t=this.__chain__;if(o||t){var r=n(this.__wrapped__);return(r.__actions__=Ur(this.__actions__)).push({func:e,args:arguments,thisArg:n}),r.__chain__=t,r}return e.apply(n,a([this.value()],arguments))})}),n}function Pu(){}
+function Zu(n){return Ie(n)?b(Me(n)):rr(n)}function qu(){return[]}function Vu(){return false}mn=null==mn?$n:rt.defaults($n.Object(),mn,rt.pick($n,Wn));var Ku=mn.Array,Gu=mn.Date,Hu=mn.Error,Ju=mn.Function,Yu=mn.Math,Qu=mn.Object,Xu=mn.RegExp,ni=mn.String,ti=mn.TypeError,ri=Ku.prototype,ei=Qu.prototype,ui=mn["__core-js_shared__"],ii=Ju.prototype.toString,oi=ei.hasOwnProperty,fi=0,ci=function(){var n=/[^.]+$/.exec(ui&&ui.keys&&ui.keys.IE_PROTO||"");return n?"Symbol(src)_1."+n:""}(),ai=ei.toString,li=ii.call(Qu),si=$n._,hi=Xu("^"+ii.call(oi).replace(rn,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),pi=Pn?mn.Buffer:T,_i=mn.Symbol,vi=mn.Uint8Array,gi=pi?pi.g:T,di=B(Qu.getPrototypeOf,Qu),yi=Qu.create,bi=ei.propertyIsEnumerable,xi=ri.splice,ji=_i?_i.isConcatSpreadable:T,wi=_i?_i.iterator:T,mi=_i?_i.toStringTag:T,Ai=function(){
+try{var n=je(Qu,"defineProperty");return n({},"",{}),n}catch(n){}}(),Ei=mn.clearTimeout!==$n.clearTimeout&&mn.clearTimeout,ki=Gu&&Gu.now!==$n.Date.now&&Gu.now,Si=mn.setTimeout!==$n.setTimeout&&mn.setTimeout,Oi=Yu.ceil,Ii=Yu.floor,Ri=Qu.getOwnPropertySymbols,zi=pi?pi.isBuffer:T,Wi=mn.isFinite,Bi=ri.join,Li=B(Qu.keys,Qu),Ui=Yu.max,Ci=Yu.min,Di=Gu.now,Mi=mn.parseInt,Ti=Yu.random,$i=ri.reverse,Fi=je(mn,"DataView"),Ni=je(mn,"Map"),Pi=je(mn,"Promise"),Zi=je(mn,"Set"),qi=je(mn,"WeakMap"),Vi=je(Qu,"create"),Ki=qi&&new qi,Gi={},Hi=Te(Fi),Ji=Te(Ni),Yi=Te(Pi),Qi=Te(Zi),Xi=Te(qi),no=_i?_i.prototype:T,to=no?no.valueOf:T,ro=no?no.toString:T,eo=function(){
+function n(){}return function(t){return du(t)?yi?yi(t):(n.prototype=t,t=new n,n.prototype=T,t):{}}}();An.templateSettings={escape:J,evaluate:Y,interpolate:Q,variable:"",imports:{_:An}},An.prototype=En.prototype,An.prototype.constructor=An,On.prototype=eo(En.prototype),On.prototype.constructor=On,Un.prototype=eo(En.prototype),Un.prototype.constructor=Un,Mn.prototype.clear=function(){this.__data__=Vi?Vi(null):{},this.size=0},Mn.prototype.delete=function(n){return n=this.has(n)&&delete this.__data__[n],
+this.size-=n?1:0,n},Mn.prototype.get=function(n){var t=this.__data__;return Vi?(n=t[n],"__lodash_hash_undefined__"===n?T:n):oi.call(t,n)?t[n]:T},Mn.prototype.has=function(n){var t=this.__data__;return Vi?t[n]!==T:oi.call(t,n)},Mn.prototype.set=function(n,t){var r=this.__data__;return this.size+=this.has(n)?0:1,r[n]=Vi&&t===T?"__lodash_hash_undefined__":t,this},Tn.prototype.clear=function(){this.__data__=[],this.size=0},Tn.prototype.delete=function(n){var t=this.__data__;return n=ft(t,n),!(0>n)&&(n==t.length-1?t.pop():xi.call(t,n,1),
+--this.size,true)},Tn.prototype.get=function(n){var t=this.__data__;return n=ft(t,n),0>n?T:t[n][1]},Tn.prototype.has=function(n){return-1<ft(this.__data__,n)},Tn.prototype.set=function(n,t){var r=this.__data__,e=ft(r,n);return 0>e?(++this.size,r.push([n,t])):r[e][1]=t,this},Fn.prototype.clear=function(){this.size=0,this.__data__={hash:new Mn,map:new(Ni||Tn),string:new Mn}},Fn.prototype.delete=function(n){return n=be(this,n).delete(n),this.size-=n?1:0,n},Fn.prototype.get=function(n){return be(this,n).get(n);
+},Fn.prototype.has=function(n){return be(this,n).has(n)},Fn.prototype.set=function(n,t){var r=be(this,n),e=r.size;return r.set(n,t),this.size+=r.size==e?0:1,this},Nn.prototype.add=Nn.prototype.push=function(n){return this.__data__.set(n,"__lodash_hash_undefined__"),this},Nn.prototype.has=function(n){return this.__data__.has(n)},Zn.prototype.clear=function(){this.__data__=new Tn,this.size=0},Zn.prototype.delete=function(n){var t=this.__data__;return n=t.delete(n),this.size=t.size,n},Zn.prototype.get=function(n){
+return this.__data__.get(n)},Zn.prototype.has=function(n){return this.__data__.has(n)},Zn.prototype.set=function(n,t){var r=this.__data__;if(r instanceof Tn){var e=r.__data__;if(!Ni||199>e.length)return e.push([n,t]),this.size=++r.size,this;r=this.__data__=new Fn(e)}return r.set(n,t),this.size=r.size,this};var uo=Fr(mt),io=Fr(At,true),oo=Nr(),fo=Nr(true),co=Ki?function(n,t){return Ki.set(n,t),n}:$u,ao=Ai?function(n,t){return Ai(n,"toString",{configurable:true,enumerable:false,value:Tu(t),writable:true})}:$u,lo=Ei||function(n){
+return $n.clearTimeout(n)},so=Zi&&1/U(new Zi([,-0]))[1]==$?function(n){return new Zi(n)}:Pu,ho=Ki?function(n){return Ki.get(n)}:Pu,po=Ri?function(n){return null==n?[]:(n=Qu(n),i(Ri(n),function(t){return bi.call(n,t)}))}:qu,_o=Ri?function(n){for(var t=[];n;)a(t,po(n)),n=di(n);return t}:qu,vo=Ot;(Fi&&"[object DataView]"!=vo(new Fi(new ArrayBuffer(1)))||Ni&&"[object Map]"!=vo(new Ni)||Pi&&"[object Promise]"!=vo(Pi.resolve())||Zi&&"[object Set]"!=vo(new Zi)||qi&&"[object WeakMap]"!=vo(new qi))&&(vo=function(n){
+var t=Ot(n);if(n=(n="[object Object]"==t?n.constructor:T)?Te(n):"")switch(n){case Hi:return"[object DataView]";case Ji:return"[object Map]";case Yi:return"[object Promise]";case Qi:return"[object Set]";case Xi:return"[object WeakMap]"}return t});var go=ui?_u:Vu,yo=Ce(co),bo=Si||function(n,t){return $n.setTimeout(n,t)},xo=Ce(ao),jo=function(n){n=cu(n,function(n){return 500===t.size&&t.clear(),n});var t=n.cache;return n}(function(n){var t=[];return 46===n.charCodeAt(0)&&t.push(""),n.replace(tn,function(n,r,e,u){
+t.push(e?u.replace(hn,"$1"):r||n)}),t}),wo=fr(function(n,t){return hu(n)?yt(n,wt(t,1,hu,true)):[]}),mo=fr(function(n,t){var r=Ve(t);return hu(r)&&(r=T),hu(n)?yt(n,wt(t,1,hu,true),ye(r,2)):[]}),Ao=fr(function(n,t){var r=Ve(t);return hu(r)&&(r=T),hu(n)?yt(n,wt(t,1,hu,true),T,r):[]}),Eo=fr(function(n){var t=c(n,Er);return t.length&&t[0]===n[0]?Wt(t):[]}),ko=fr(function(n){var t=Ve(n),r=c(n,Er);return t===Ve(r)?t=T:r.pop(),r.length&&r[0]===n[0]?Wt(r,ye(t,2)):[]}),So=fr(function(n){var t=Ve(n),r=c(n,Er);return(t=typeof t=="function"?t:T)&&r.pop(),
+r.length&&r[0]===n[0]?Wt(r,T,t):[]}),Oo=fr(Ke),Io=pe(function(n,t){var r=null==n?0:n.length,e=ht(n,t);return ur(n,c(t,function(n){return Se(n,r)?+n:n}).sort(Wr)),e}),Ro=fr(function(n){return br(wt(n,1,hu,true))}),zo=fr(function(n){var t=Ve(n);return hu(t)&&(t=T),br(wt(n,1,hu,true),ye(t,2))}),Wo=fr(function(n){var t=Ve(n),t=typeof t=="function"?t:T;return br(wt(n,1,hu,true),T,t)}),Bo=fr(function(n,t){return hu(n)?yt(n,t):[]}),Lo=fr(function(n){return mr(i(n,hu))}),Uo=fr(function(n){var t=Ve(n);return hu(t)&&(t=T),
+mr(i(n,hu),ye(t,2))}),Co=fr(function(n){var t=Ve(n),t=typeof t=="function"?t:T;return mr(i(n,hu),T,t)}),Do=fr(He),Mo=fr(function(n){var t=n.length,t=1<t?n[t-1]:T,t=typeof t=="function"?(n.pop(),t):T;return Je(n,t)}),To=pe(function(n){function t(t){return ht(t,n)}var r=n.length,e=r?n[0]:0,u=this.__wrapped__;return!(1<r||this.__actions__.length)&&u instanceof Un&&Se(e)?(u=u.slice(e,+e+(r?1:0)),u.__actions__.push({func:Qe,args:[t],thisArg:T}),new On(u,this.__chain__).thru(function(n){return r&&!n.length&&n.push(T),
+n})):this.thru(t)}),$o=Tr(function(n,t,r){oi.call(n,r)?++n[r]:st(n,r,1)}),Fo=Gr(Ne),No=Gr(Pe),Po=Tr(function(n,t,r){oi.call(n,r)?n[r].push(t):st(n,r,[t])}),Zo=fr(function(t,r,e){var u=-1,i=typeof r=="function",o=su(t)?Ku(t.length):[];return uo(t,function(t){o[++u]=i?n(r,t,e):Lt(t,r,e)}),o}),qo=Tr(function(n,t,r){st(n,r,t)}),Vo=Tr(function(n,t,r){n[r?0:1].push(t)},function(){return[[],[]]}),Ko=fr(function(n,t){if(null==n)return[];var r=t.length;return 1<r&&Oe(n,t[0],t[1])?t=[]:2<r&&Oe(t[0],t[1],t[2])&&(t=[t[0]]),
+Xt(n,wt(t,1),[])}),Go=ki||function(){return $n.Date.now()},Ho=fr(function(n,t,r){var e=1;if(r.length)var u=L(r,de(Ho)),e=32|e;return fe(n,e,t,r,u)}),Jo=fr(function(n,t,r){var e=3;if(r.length)var u=L(r,de(Jo)),e=32|e;return fe(t,e,n,r,u)}),Yo=fr(function(n,t){return dt(n,1,t)}),Qo=fr(function(n,t,r){return dt(n,Su(t)||0,r)});cu.Cache=Fn;var Xo=fr(function(t,r){r=1==r.length&&ff(r[0])?c(r[0],k(ye())):c(wt(r,1),k(ye()));var e=r.length;return fr(function(u){for(var i=-1,o=Ci(u.length,e);++i<o;)u[i]=r[i].call(this,u[i]);
+return n(t,this,u)})}),nf=fr(function(n,t){return fe(n,32,T,t,L(t,de(nf)))}),tf=fr(function(n,t){return fe(n,64,T,t,L(t,de(tf)))}),rf=pe(function(n,t){return fe(n,256,T,T,T,t)}),ef=ee(It),uf=ee(function(n,t){return n>=t}),of=Ut(function(){return arguments}())?Ut:function(n){return yu(n)&&oi.call(n,"callee")&&!bi.call(n,"callee")},ff=Ku.isArray,cf=Vn?k(Vn):Ct,af=zi||Vu,lf=Kn?k(Kn):Dt,sf=Gn?k(Gn):Tt,hf=Hn?k(Hn):Nt,pf=Jn?k(Jn):Pt,_f=Yn?k(Yn):Zt,vf=ee(Kt),gf=ee(function(n,t){return n<=t}),df=$r(function(n,t){
+if(ze(t)||su(t))Cr(t,Wu(t),n);else for(var r in t)oi.call(t,r)&&ot(n,r,t[r])}),yf=$r(function(n,t){Cr(t,Bu(t),n)}),bf=$r(function(n,t,r,e){Cr(t,Bu(t),n,e)}),xf=$r(function(n,t,r,e){Cr(t,Wu(t),n,e)}),jf=pe(ht),wf=fr(function(n,t){n=Qu(n);var r=-1,e=t.length,u=2<e?t[2]:T;for(u&&Oe(t[0],t[1],u)&&(e=1);++r<e;)for(var u=t[r],i=Bu(u),o=-1,f=i.length;++o<f;){var c=i[o],a=n[c];(a===T||lu(a,ei[c])&&!oi.call(n,c))&&(n[c]=u[c])}return n}),mf=fr(function(t){return t.push(T,ae),n(Of,T,t)}),Af=Yr(function(n,t,r){
+null!=t&&typeof t.toString!="function"&&(t=ai.call(t)),n[t]=r},Tu($u)),Ef=Yr(function(n,t,r){null!=t&&typeof t.toString!="function"&&(t=ai.call(t)),oi.call(n,t)?n[t].push(r):n[t]=[r]},ye),kf=fr(Lt),Sf=$r(function(n,t,r){Yt(n,t,r)}),Of=$r(function(n,t,r,e){Yt(n,t,r,e)}),If=pe(function(n,t){var r={};if(null==n)return r;var e=false;t=c(t,function(t){return t=Sr(t,n),e||(e=1<t.length),t}),Cr(n,ve(n),r),e&&(r=_t(r,7,le));for(var u=t.length;u--;)xr(r,t[u]);return r}),Rf=pe(function(n,t){return null==n?{}:nr(n,t);
+}),zf=oe(Wu),Wf=oe(Bu),Bf=qr(function(n,t,r){return t=t.toLowerCase(),n+(r?Cu(t):t)}),Lf=qr(function(n,t,r){return n+(r?"-":"")+t.toLowerCase()}),Uf=qr(function(n,t,r){return n+(r?" ":"")+t.toLowerCase()}),Cf=Zr("toLowerCase"),Df=qr(function(n,t,r){return n+(r?"_":"")+t.toLowerCase()}),Mf=qr(function(n,t,r){return n+(r?" ":"")+$f(t)}),Tf=qr(function(n,t,r){return n+(r?" ":"")+t.toUpperCase()}),$f=Zr("toUpperCase"),Ff=fr(function(t,r){try{return n(t,T,r)}catch(n){return pu(n)?n:new Hu(n)}}),Nf=pe(function(n,t){
+return r(t,function(t){t=Me(t),st(n,t,Ho(n[t],n))}),n}),Pf=Hr(),Zf=Hr(true),qf=fr(function(n,t){return function(r){return Lt(r,n,t)}}),Vf=fr(function(n,t){return function(r){return Lt(n,r,t)}}),Kf=Xr(c),Gf=Xr(u),Hf=Xr(h),Jf=re(),Yf=re(true),Qf=Qr(function(n,t){return n+t},0),Xf=ie("ceil"),nc=Qr(function(n,t){return n/t},1),tc=ie("floor"),rc=Qr(function(n,t){return n*t},1),ec=ie("round"),uc=Qr(function(n,t){return n-t},0);return An.after=function(n,t){if(typeof t!="function")throw new ti("Expected a function");
+return n=Eu(n),function(){if(1>--n)return t.apply(this,arguments)}},An.ary=eu,An.assign=df,An.assignIn=yf,An.assignInWith=bf,An.assignWith=xf,An.at=jf,An.before=uu,An.bind=Ho,An.bindAll=Nf,An.bindKey=Jo,An.castArray=function(){if(!arguments.length)return[];var n=arguments[0];return ff(n)?n:[n]},An.chain=Ye,An.chunk=function(n,t,r){if(t=(r?Oe(n,t,r):t===T)?1:Ui(Eu(t),0),r=null==n?0:n.length,!r||1>t)return[];for(var e=0,u=0,i=Ku(Oi(r/t));e<r;)i[u++]=hr(n,e,e+=t);return i},An.compact=function(n){for(var t=-1,r=null==n?0:n.length,e=0,u=[];++t<r;){
+var i=n[t];i&&(u[e++]=i)}return u},An.concat=function(){var n=arguments.length;if(!n)return[];for(var t=Ku(n-1),r=arguments[0];n--;)t[n-1]=arguments[n];return a(ff(r)?Ur(r):[r],wt(t,1))},An.cond=function(t){var r=null==t?0:t.length,e=ye();return t=r?c(t,function(n){if("function"!=typeof n[1])throw new ti("Expected a function");return[e(n[0]),n[1]]}):[],fr(function(e){for(var u=-1;++u<r;){var i=t[u];if(n(i[0],this,e))return n(i[1],this,e)}})},An.conforms=function(n){return vt(_t(n,1))},An.constant=Tu,
+An.countBy=$o,An.create=function(n,t){var r=eo(n);return null==t?r:at(r,t)},An.curry=iu,An.curryRight=ou,An.debounce=fu,An.defaults=wf,An.defaultsDeep=mf,An.defer=Yo,An.delay=Qo,An.difference=wo,An.differenceBy=mo,An.differenceWith=Ao,An.drop=function(n,t,r){var e=null==n?0:n.length;return e?(t=r||t===T?1:Eu(t),hr(n,0>t?0:t,e)):[]},An.dropRight=function(n,t,r){var e=null==n?0:n.length;return e?(t=r||t===T?1:Eu(t),t=e-t,hr(n,0,0>t?0:t)):[]},An.dropRightWhile=function(n,t){return n&&n.length?jr(n,ye(t,3),true,true):[];
+},An.dropWhile=function(n,t){return n&&n.length?jr(n,ye(t,3),true):[]},An.fill=function(n,t,r,e){var u=null==n?0:n.length;if(!u)return[];for(r&&typeof r!="number"&&Oe(n,t,r)&&(r=0,e=u),u=n.length,r=Eu(r),0>r&&(r=-r>u?0:u+r),e=e===T||e>u?u:Eu(e),0>e&&(e+=u),e=r>e?0:ku(e);r<e;)n[r++]=t;return n},An.filter=function(n,t){return(ff(n)?i:jt)(n,ye(t,3))},An.flatMap=function(n,t){return wt(ru(n,t),1)},An.flatMapDeep=function(n,t){return wt(ru(n,t),$)},An.flatMapDepth=function(n,t,r){return r=r===T?1:Eu(r),
+wt(ru(n,t),r)},An.flatten=Ze,An.flattenDeep=function(n){return(null==n?0:n.length)?wt(n,$):[]},An.flattenDepth=function(n,t){return null!=n&&n.length?(t=t===T?1:Eu(t),wt(n,t)):[]},An.flip=function(n){return fe(n,512)},An.flow=Pf,An.flowRight=Zf,An.fromPairs=function(n){for(var t=-1,r=null==n?0:n.length,e={};++t<r;){var u=n[t];e[u[0]]=u[1]}return e},An.functions=function(n){return null==n?[]:Et(n,Wu(n))},An.functionsIn=function(n){return null==n?[]:Et(n,Bu(n))},An.groupBy=Po,An.initial=function(n){
+return(null==n?0:n.length)?hr(n,0,-1):[]},An.intersection=Eo,An.intersectionBy=ko,An.intersectionWith=So,An.invert=Af,An.invertBy=Ef,An.invokeMap=Zo,An.iteratee=Fu,An.keyBy=qo,An.keys=Wu,An.keysIn=Bu,An.map=ru,An.mapKeys=function(n,t){var r={};return t=ye(t,3),mt(n,function(n,e,u){st(r,t(n,e,u),n)}),r},An.mapValues=function(n,t){var r={};return t=ye(t,3),mt(n,function(n,e,u){st(r,e,t(n,e,u))}),r},An.matches=function(n){return Ht(_t(n,1))},An.matchesProperty=function(n,t){return Jt(n,_t(t,1))},An.memoize=cu,
+An.merge=Sf,An.mergeWith=Of,An.method=qf,An.methodOf=Vf,An.mixin=Nu,An.negate=au,An.nthArg=function(n){return n=Eu(n),fr(function(t){return Qt(t,n)})},An.omit=If,An.omitBy=function(n,t){return Lu(n,au(ye(t)))},An.once=function(n){return uu(2,n)},An.orderBy=function(n,t,r,e){return null==n?[]:(ff(t)||(t=null==t?[]:[t]),r=e?T:r,ff(r)||(r=null==r?[]:[r]),Xt(n,t,r))},An.over=Kf,An.overArgs=Xo,An.overEvery=Gf,An.overSome=Hf,An.partial=nf,An.partialRight=tf,An.partition=Vo,An.pick=Rf,An.pickBy=Lu,An.property=Zu,
+An.propertyOf=function(n){return function(t){return null==n?T:kt(n,t)}},An.pull=Oo,An.pullAll=Ke,An.pullAllBy=function(n,t,r){return n&&n.length&&t&&t.length?er(n,t,ye(r,2)):n},An.pullAllWith=function(n,t,r){return n&&n.length&&t&&t.length?er(n,t,T,r):n},An.pullAt=Io,An.range=Jf,An.rangeRight=Yf,An.rearg=rf,An.reject=function(n,t){return(ff(n)?i:jt)(n,au(ye(t,3)))},An.remove=function(n,t){var r=[];if(!n||!n.length)return r;var e=-1,u=[],i=n.length;for(t=ye(t,3);++e<i;){var o=n[e];t(o,e,n)&&(r.push(o),
+u.push(e))}return ur(n,u),r},An.rest=function(n,t){if(typeof n!="function")throw new ti("Expected a function");return t=t===T?t:Eu(t),fr(n,t)},An.reverse=Ge,An.sampleSize=function(n,t,r){return t=(r?Oe(n,t,r):t===T)?1:Eu(t),(ff(n)?et:ar)(n,t)},An.set=function(n,t,r){return null==n?n:lr(n,t,r)},An.setWith=function(n,t,r,e){return e=typeof e=="function"?e:T,null==n?n:lr(n,t,r,e)},An.shuffle=function(n){return(ff(n)?ut:sr)(n)},An.slice=function(n,t,r){var e=null==n?0:n.length;return e?(r&&typeof r!="number"&&Oe(n,t,r)?(t=0,
+r=e):(t=null==t?0:Eu(t),r=r===T?e:Eu(r)),hr(n,t,r)):[]},An.sortBy=Ko,An.sortedUniq=function(n){return n&&n.length?gr(n):[]},An.sortedUniqBy=function(n,t){return n&&n.length?gr(n,ye(t,2)):[]},An.split=function(n,t,r){return r&&typeof r!="number"&&Oe(n,t,r)&&(t=r=T),r=r===T?4294967295:r>>>0,r?(n=Iu(n))&&(typeof t=="string"||null!=t&&!hf(t))&&(t=yr(t),!t&&Rn.test(n))?Or(M(n),0,r):n.split(t,r):[]},An.spread=function(t,r){if(typeof t!="function")throw new ti("Expected a function");return r=null==r?0:Ui(Eu(r),0),
+fr(function(e){var u=e[r];return e=Or(e,0,r),u&&a(e,u),n(t,this,e)})},An.tail=function(n){var t=null==n?0:n.length;return t?hr(n,1,t):[]},An.take=function(n,t,r){return n&&n.length?(t=r||t===T?1:Eu(t),hr(n,0,0>t?0:t)):[]},An.takeRight=function(n,t,r){var e=null==n?0:n.length;return e?(t=r||t===T?1:Eu(t),t=e-t,hr(n,0>t?0:t,e)):[]},An.takeRightWhile=function(n,t){return n&&n.length?jr(n,ye(t,3),false,true):[]},An.takeWhile=function(n,t){return n&&n.length?jr(n,ye(t,3)):[]},An.tap=function(n,t){return t(n),
+n},An.throttle=function(n,t,r){var e=true,u=true;if(typeof n!="function")throw new ti("Expected a function");return du(r)&&(e="leading"in r?!!r.leading:e,u="trailing"in r?!!r.trailing:u),fu(n,t,{leading:e,maxWait:t,trailing:u})},An.thru=Qe,An.toArray=mu,An.toPairs=zf,An.toPairsIn=Wf,An.toPath=function(n){return ff(n)?c(n,Me):wu(n)?[n]:Ur(jo(Iu(n)))},An.toPlainObject=Ou,An.transform=function(n,t,e){var u=ff(n),i=u||af(n)||_f(n);if(t=ye(t,4),null==e){var o=n&&n.constructor;e=i?u?new o:[]:du(n)&&_u(o)?eo(di(n)):{};
+}return(i?r:mt)(n,function(n,r,u){return t(e,n,r,u)}),e},An.unary=function(n){return eu(n,1)},An.union=Ro,An.unionBy=zo,An.unionWith=Wo,An.uniq=function(n){return n&&n.length?br(n):[]},An.uniqBy=function(n,t){return n&&n.length?br(n,ye(t,2)):[]},An.uniqWith=function(n,t){return t=typeof t=="function"?t:T,n&&n.length?br(n,T,t):[]},An.unset=function(n,t){return null==n||xr(n,t)},An.unzip=He,An.unzipWith=Je,An.update=function(n,t,r){return null==n?n:lr(n,t,kr(r)(kt(n,t)),void 0)},An.updateWith=function(n,t,r,e){
+return e=typeof e=="function"?e:T,null!=n&&(n=lr(n,t,kr(r)(kt(n,t)),e)),n},An.values=Uu,An.valuesIn=function(n){return null==n?[]:S(n,Bu(n))},An.without=Bo,An.words=Mu,An.wrap=function(n,t){return nf(kr(t),n)},An.xor=Lo,An.xorBy=Uo,An.xorWith=Co,An.zip=Do,An.zipObject=function(n,t){return Ar(n||[],t||[],ot)},An.zipObjectDeep=function(n,t){return Ar(n||[],t||[],lr)},An.zipWith=Mo,An.entries=zf,An.entriesIn=Wf,An.extend=yf,An.extendWith=bf,Nu(An,An),An.add=Qf,An.attempt=Ff,An.camelCase=Bf,An.capitalize=Cu,
+An.ceil=Xf,An.clamp=function(n,t,r){return r===T&&(r=t,t=T),r!==T&&(r=Su(r),r=r===r?r:0),t!==T&&(t=Su(t),t=t===t?t:0),pt(Su(n),t,r)},An.clone=function(n){return _t(n,4)},An.cloneDeep=function(n){return _t(n,5)},An.cloneDeepWith=function(n,t){return t=typeof t=="function"?t:T,_t(n,5,t)},An.cloneWith=function(n,t){return t=typeof t=="function"?t:T,_t(n,4,t)},An.conformsTo=function(n,t){return null==t||gt(n,t,Wu(t))},An.deburr=Du,An.defaultTo=function(n,t){return null==n||n!==n?t:n},An.divide=nc,An.endsWith=function(n,t,r){
+n=Iu(n),t=yr(t);var e=n.length,e=r=r===T?e:pt(Eu(r),0,e);return r-=t.length,0<=r&&n.slice(r,e)==t},An.eq=lu,An.escape=function(n){return(n=Iu(n))&&H.test(n)?n.replace(K,nt):n},An.escapeRegExp=function(n){return(n=Iu(n))&&en.test(n)?n.replace(rn,"\\$&"):n},An.every=function(n,t,r){var e=ff(n)?u:bt;return r&&Oe(n,t,r)&&(t=T),e(n,ye(t,3))},An.find=Fo,An.findIndex=Ne,An.findKey=function(n,t){return p(n,ye(t,3),mt)},An.findLast=No,An.findLastIndex=Pe,An.findLastKey=function(n,t){return p(n,ye(t,3),At);
+},An.floor=tc,An.forEach=nu,An.forEachRight=tu,An.forIn=function(n,t){return null==n?n:oo(n,ye(t,3),Bu)},An.forInRight=function(n,t){return null==n?n:fo(n,ye(t,3),Bu)},An.forOwn=function(n,t){return n&&mt(n,ye(t,3))},An.forOwnRight=function(n,t){return n&&At(n,ye(t,3))},An.get=Ru,An.gt=ef,An.gte=uf,An.has=function(n,t){return null!=n&&we(n,t,Rt)},An.hasIn=zu,An.head=qe,An.identity=$u,An.includes=function(n,t,r,e){return n=su(n)?n:Uu(n),r=r&&!e?Eu(r):0,e=n.length,0>r&&(r=Ui(e+r,0)),ju(n)?r<=e&&-1<n.indexOf(t,r):!!e&&-1<v(n,t,r);
+},An.indexOf=function(n,t,r){var e=null==n?0:n.length;return e?(r=null==r?0:Eu(r),0>r&&(r=Ui(e+r,0)),v(n,t,r)):-1},An.inRange=function(n,t,r){return t=Au(t),r===T?(r=t,t=0):r=Au(r),n=Su(n),n>=Ci(t,r)&&n<Ui(t,r)},An.invoke=kf,An.isArguments=of,An.isArray=ff,An.isArrayBuffer=cf,An.isArrayLike=su,An.isArrayLikeObject=hu,An.isBoolean=function(n){return true===n||false===n||yu(n)&&"[object Boolean]"==Ot(n)},An.isBuffer=af,An.isDate=lf,An.isElement=function(n){return yu(n)&&1===n.nodeType&&!xu(n)},An.isEmpty=function(n){
+if(null==n)return true;if(su(n)&&(ff(n)||typeof n=="string"||typeof n.splice=="function"||af(n)||_f(n)||of(n)))return!n.length;var t=vo(n);if("[object Map]"==t||"[object Set]"==t)return!n.size;if(ze(n))return!Vt(n).length;for(var r in n)if(oi.call(n,r))return false;return true},An.isEqual=function(n,t){return Mt(n,t)},An.isEqualWith=function(n,t,r){var e=(r=typeof r=="function"?r:T)?r(n,t):T;return e===T?Mt(n,t,T,r):!!e},An.isError=pu,An.isFinite=function(n){return typeof n=="number"&&Wi(n)},An.isFunction=_u,
+An.isInteger=vu,An.isLength=gu,An.isMap=sf,An.isMatch=function(n,t){return n===t||$t(n,t,xe(t))},An.isMatchWith=function(n,t,r){return r=typeof r=="function"?r:T,$t(n,t,xe(t),r)},An.isNaN=function(n){return bu(n)&&n!=+n},An.isNative=function(n){if(go(n))throw new Hu("Unsupported core-js use. Try https://npms.io/search?q=ponyfill.");return Ft(n)},An.isNil=function(n){return null==n},An.isNull=function(n){return null===n},An.isNumber=bu,An.isObject=du,An.isObjectLike=yu,An.isPlainObject=xu,An.isRegExp=hf,
+An.isSafeInteger=function(n){return vu(n)&&-9007199254740991<=n&&9007199254740991>=n},An.isSet=pf,An.isString=ju,An.isSymbol=wu,An.isTypedArray=_f,An.isUndefined=function(n){return n===T},An.isWeakMap=function(n){return yu(n)&&"[object WeakMap]"==vo(n)},An.isWeakSet=function(n){return yu(n)&&"[object WeakSet]"==Ot(n)},An.join=function(n,t){return null==n?"":Bi.call(n,t)},An.kebabCase=Lf,An.last=Ve,An.lastIndexOf=function(n,t,r){var e=null==n?0:n.length;if(!e)return-1;var u=e;if(r!==T&&(u=Eu(r),u=0>u?Ui(e+u,0):Ci(u,e-1)),
+t===t){for(r=u+1;r--&&n[r]!==t;);n=r}else n=_(n,d,u,true);return n},An.lowerCase=Uf,An.lowerFirst=Cf,An.lt=vf,An.lte=gf,An.max=function(n){return n&&n.length?xt(n,$u,It):T},An.maxBy=function(n,t){return n&&n.length?xt(n,ye(t,2),It):T},An.mean=function(n){return y(n,$u)},An.meanBy=function(n,t){return y(n,ye(t,2))},An.min=function(n){return n&&n.length?xt(n,$u,Kt):T},An.minBy=function(n,t){return n&&n.length?xt(n,ye(t,2),Kt):T},An.stubArray=qu,An.stubFalse=Vu,An.stubObject=function(){return{}},An.stubString=function(){
+return""},An.stubTrue=function(){return true},An.multiply=rc,An.nth=function(n,t){return n&&n.length?Qt(n,Eu(t)):T},An.noConflict=function(){return $n._===this&&($n._=si),this},An.noop=Pu,An.now=Go,An.pad=function(n,t,r){n=Iu(n);var e=(t=Eu(t))?D(n):0;return!t||e>=t?n:(t=(t-e)/2,ne(Ii(t),r)+n+ne(Oi(t),r))},An.padEnd=function(n,t,r){n=Iu(n);var e=(t=Eu(t))?D(n):0;return t&&e<t?n+ne(t-e,r):n},An.padStart=function(n,t,r){n=Iu(n);var e=(t=Eu(t))?D(n):0;return t&&e<t?ne(t-e,r)+n:n},An.parseInt=function(n,t,r){
+return r||null==t?t=0:t&&(t=+t),Mi(Iu(n).replace(on,""),t||0)},An.random=function(n,t,r){if(r&&typeof r!="boolean"&&Oe(n,t,r)&&(t=r=T),r===T&&(typeof t=="boolean"?(r=t,t=T):typeof n=="boolean"&&(r=n,n=T)),n===T&&t===T?(n=0,t=1):(n=Au(n),t===T?(t=n,n=0):t=Au(t)),n>t){var e=n;n=t,t=e}return r||n%1||t%1?(r=Ti(),Ci(n+r*(t-n+Cn("1e-"+((r+"").length-1))),t)):ir(n,t)},An.reduce=function(n,t,r){var e=ff(n)?l:j,u=3>arguments.length;return e(n,ye(t,4),r,u,uo)},An.reduceRight=function(n,t,r){var e=ff(n)?s:j,u=3>arguments.length;
+return e(n,ye(t,4),r,u,io)},An.repeat=function(n,t,r){return t=(r?Oe(n,t,r):t===T)?1:Eu(t),or(Iu(n),t)},An.replace=function(){var n=arguments,t=Iu(n[0]);return 3>n.length?t:t.replace(n[1],n[2])},An.result=function(n,t,r){t=Sr(t,n);var e=-1,u=t.length;for(u||(u=1,n=T);++e<u;){var i=null==n?T:n[Me(t[e])];i===T&&(e=u,i=r),n=_u(i)?i.call(n):i}return n},An.round=ec,An.runInContext=x,An.sample=function(n){return(ff(n)?Qn:cr)(n)},An.size=function(n){if(null==n)return 0;if(su(n))return ju(n)?D(n):n.length;
+var t=vo(n);return"[object Map]"==t||"[object Set]"==t?n.size:Vt(n).length},An.snakeCase=Df,An.some=function(n,t,r){var e=ff(n)?h:pr;return r&&Oe(n,t,r)&&(t=T),e(n,ye(t,3))},An.sortedIndex=function(n,t){return _r(n,t)},An.sortedIndexBy=function(n,t,r){return vr(n,t,ye(r,2))},An.sortedIndexOf=function(n,t){var r=null==n?0:n.length;if(r){var e=_r(n,t);if(e<r&&lu(n[e],t))return e}return-1},An.sortedLastIndex=function(n,t){return _r(n,t,true)},An.sortedLastIndexBy=function(n,t,r){return vr(n,t,ye(r,2),true);
+},An.sortedLastIndexOf=function(n,t){if(null==n?0:n.length){var r=_r(n,t,true)-1;if(lu(n[r],t))return r}return-1},An.startCase=Mf,An.startsWith=function(n,t,r){return n=Iu(n),r=null==r?0:pt(Eu(r),0,n.length),t=yr(t),n.slice(r,r+t.length)==t},An.subtract=uc,An.sum=function(n){return n&&n.length?m(n,$u):0},An.sumBy=function(n,t){return n&&n.length?m(n,ye(t,2)):0},An.template=function(n,t,r){var e=An.templateSettings;r&&Oe(n,t,r)&&(t=T),n=Iu(n),t=bf({},t,e,ce),r=bf({},t.imports,e.imports,ce);var u,i,o=Wu(r),f=S(r,o),c=0;
+r=t.interpolate||jn;var a="__p+='";r=Xu((t.escape||jn).source+"|"+r.source+"|"+(r===Q?pn:jn).source+"|"+(t.evaluate||jn).source+"|$","g");var l=oi.call(t,"sourceURL")?"//# sourceURL="+(t.sourceURL+"").replace(/[\r\n]/g," ")+"\n":"";if(n.replace(r,function(t,r,e,o,f,l){return e||(e=o),a+=n.slice(c,l).replace(wn,z),r&&(u=true,a+="'+__e("+r+")+'"),f&&(i=true,a+="';"+f+";\n__p+='"),e&&(a+="'+((__t=("+e+"))==null?'':__t)+'"),c=l+t.length,t}),a+="';",(t=oi.call(t,"variable")&&t.variable)||(a="with(obj){"+a+"}"),
+a=(i?a.replace(P,""):a).replace(Z,"$1").replace(q,"$1;"),a="function("+(t||"obj")+"){"+(t?"":"obj||(obj={});")+"var __t,__p=''"+(u?",__e=_.escape":"")+(i?",__j=Array.prototype.join;function print(){__p+=__j.call(arguments,'')}":";")+a+"return __p}",t=Ff(function(){return Ju(o,l+"return "+a).apply(T,f)}),t.source=a,pu(t))throw t;return t},An.times=function(n,t){if(n=Eu(n),1>n||9007199254740991<n)return[];var r=4294967295,e=Ci(n,4294967295);for(t=ye(t),n-=4294967295,e=A(e,t);++r<n;)t(r);return e},An.toFinite=Au,
+An.toInteger=Eu,An.toLength=ku,An.toLower=function(n){return Iu(n).toLowerCase()},An.toNumber=Su,An.toSafeInteger=function(n){return n?pt(Eu(n),-9007199254740991,9007199254740991):0===n?n:0},An.toString=Iu,An.toUpper=function(n){return Iu(n).toUpperCase()},An.trim=function(n,t,r){return(n=Iu(n))&&(r||t===T)?n.replace(un,""):n&&(t=yr(t))?(n=M(n),r=M(t),t=I(n,r),r=R(n,r)+1,Or(n,t,r).join("")):n},An.trimEnd=function(n,t,r){return(n=Iu(n))&&(r||t===T)?n.replace(fn,""):n&&(t=yr(t))?(n=M(n),t=R(n,M(t))+1,
+Or(n,0,t).join("")):n},An.trimStart=function(n,t,r){return(n=Iu(n))&&(r||t===T)?n.replace(on,""):n&&(t=yr(t))?(n=M(n),t=I(n,M(t)),Or(n,t).join("")):n},An.truncate=function(n,t){var r=30,e="...";if(du(t))var u="separator"in t?t.separator:u,r="length"in t?Eu(t.length):r,e="omission"in t?yr(t.omission):e;n=Iu(n);var i=n.length;if(Rn.test(n))var o=M(n),i=o.length;if(r>=i)return n;if(i=r-D(e),1>i)return e;if(r=o?Or(o,0,i).join(""):n.slice(0,i),u===T)return r+e;if(o&&(i+=r.length-i),hf(u)){if(n.slice(i).search(u)){
+var f=r;for(u.global||(u=Xu(u.source,Iu(_n.exec(u))+"g")),u.lastIndex=0;o=u.exec(f);)var c=o.index;r=r.slice(0,c===T?i:c)}}else n.indexOf(yr(u),i)!=i&&(u=r.lastIndexOf(u),-1<u&&(r=r.slice(0,u)));return r+e},An.unescape=function(n){return(n=Iu(n))&&G.test(n)?n.replace(V,tt):n},An.uniqueId=function(n){var t=++fi;return Iu(n)+t},An.upperCase=Tf,An.upperFirst=$f,An.each=nu,An.eachRight=tu,An.first=qe,Nu(An,function(){var n={};return mt(An,function(t,r){oi.call(An.prototype,r)||(n[r]=t)}),n}(),{chain:false
+}),An.VERSION="4.17.15",r("bind bindKey curry curryRight partial partialRight".split(" "),function(n){An[n].placeholder=An}),r(["drop","take"],function(n,t){Un.prototype[n]=function(r){r=r===T?1:Ui(Eu(r),0);var e=this.__filtered__&&!t?new Un(this):this.clone();return e.__filtered__?e.__takeCount__=Ci(r,e.__takeCount__):e.__views__.push({size:Ci(r,4294967295),type:n+(0>e.__dir__?"Right":"")}),e},Un.prototype[n+"Right"]=function(t){return this.reverse()[n](t).reverse()}}),r(["filter","map","takeWhile"],function(n,t){
+var r=t+1,e=1==r||3==r;Un.prototype[n]=function(n){var t=this.clone();return t.__iteratees__.push({iteratee:ye(n,3),type:r}),t.__filtered__=t.__filtered__||e,t}}),r(["head","last"],function(n,t){var r="take"+(t?"Right":"");Un.prototype[n]=function(){return this[r](1).value()[0]}}),r(["initial","tail"],function(n,t){var r="drop"+(t?"":"Right");Un.prototype[n]=function(){return this.__filtered__?new Un(this):this[r](1)}}),Un.prototype.compact=function(){return this.filter($u)},Un.prototype.find=function(n){
+return this.filter(n).head()},Un.prototype.findLast=function(n){return this.reverse().find(n)},Un.prototype.invokeMap=fr(function(n,t){return typeof n=="function"?new Un(this):this.map(function(r){return Lt(r,n,t)})}),Un.prototype.reject=function(n){return this.filter(au(ye(n)))},Un.prototype.slice=function(n,t){n=Eu(n);var r=this;return r.__filtered__&&(0<n||0>t)?new Un(r):(0>n?r=r.takeRight(-n):n&&(r=r.drop(n)),t!==T&&(t=Eu(t),r=0>t?r.dropRight(-t):r.take(t-n)),r)},Un.prototype.takeRightWhile=function(n){
+return this.reverse().takeWhile(n).reverse()},Un.prototype.toArray=function(){return this.take(4294967295)},mt(Un.prototype,function(n,t){var r=/^(?:filter|find|map|reject)|While$/.test(t),e=/^(?:head|last)$/.test(t),u=An[e?"take"+("last"==t?"Right":""):t],i=e||/^find/.test(t);u&&(An.prototype[t]=function(){function t(n){return n=u.apply(An,a([n],f)),e&&h?n[0]:n}var o=this.__wrapped__,f=e?[1]:arguments,c=o instanceof Un,l=f[0],s=c||ff(o);s&&r&&typeof l=="function"&&1!=l.length&&(c=s=false);var h=this.__chain__,p=!!this.__actions__.length,l=i&&!h,c=c&&!p;
+return!i&&s?(o=c?o:new Un(this),o=n.apply(o,f),o.__actions__.push({func:Qe,args:[t],thisArg:T}),new On(o,h)):l&&c?n.apply(this,f):(o=this.thru(t),l?e?o.value()[0]:o.value():o)})}),r("pop push shift sort splice unshift".split(" "),function(n){var t=ri[n],r=/^(?:push|sort|unshift)$/.test(n)?"tap":"thru",e=/^(?:pop|shift)$/.test(n);An.prototype[n]=function(){var n=arguments;if(e&&!this.__chain__){var u=this.value();return t.apply(ff(u)?u:[],n)}return this[r](function(r){return t.apply(ff(r)?r:[],n)});
+}}),mt(Un.prototype,function(n,t){var r=An[t];if(r){var e=r.name+"";oi.call(Gi,e)||(Gi[e]=[]),Gi[e].push({name:t,func:r})}}),Gi[Jr(T,2).name]=[{name:"wrapper",func:T}],Un.prototype.clone=function(){var n=new Un(this.__wrapped__);return n.__actions__=Ur(this.__actions__),n.__dir__=this.__dir__,n.__filtered__=this.__filtered__,n.__iteratees__=Ur(this.__iteratees__),n.__takeCount__=this.__takeCount__,n.__views__=Ur(this.__views__),n},Un.prototype.reverse=function(){if(this.__filtered__){var n=new Un(this);
+n.__dir__=-1,n.__filtered__=true}else n=this.clone(),n.__dir__*=-1;return n},Un.prototype.value=function(){var n,t=this.__wrapped__.value(),r=this.__dir__,e=ff(t),u=0>r,i=e?t.length:0;n=i;for(var o=this.__views__,f=0,c=-1,a=o.length;++c<a;){var l=o[c],s=l.size;switch(l.type){case"drop":f+=s;break;case"dropRight":n-=s;break;case"take":n=Ci(n,f+s);break;case"takeRight":f=Ui(f,n-s)}}if(n={start:f,end:n},o=n.start,f=n.end,n=f-o,o=u?f:o-1,f=this.__iteratees__,c=f.length,a=0,l=Ci(n,this.__takeCount__),!e||!u&&i==n&&l==n)return wr(t,this.__actions__);
+e=[];n:for(;n--&&a<l;){for(o+=r,u=-1,i=t[o];++u<c;){var h=f[u],s=h.type,h=(0,h.iteratee)(i);if(2==s)i=h;else if(!h){if(1==s)continue n;break n}}e[a++]=i}return e},An.prototype.at=To,An.prototype.chain=function(){return Ye(this)},An.prototype.commit=function(){return new On(this.value(),this.__chain__)},An.prototype.next=function(){this.__values__===T&&(this.__values__=mu(this.value()));var n=this.__index__>=this.__values__.length;return{done:n,value:n?T:this.__values__[this.__index__++]}},An.prototype.plant=function(n){
+for(var t,r=this;r instanceof En;){var e=Fe(r);e.__index__=0,e.__values__=T,t?u.__wrapped__=e:t=e;var u=e,r=r.__wrapped__}return u.__wrapped__=n,t},An.prototype.reverse=function(){var n=this.__wrapped__;return n instanceof Un?(this.__actions__.length&&(n=new Un(this)),n=n.reverse(),n.__actions__.push({func:Qe,args:[Ge],thisArg:T}),new On(n,this.__chain__)):this.thru(Ge)},An.prototype.toJSON=An.prototype.valueOf=An.prototype.value=function(){return wr(this.__wrapped__,this.__actions__)},An.prototype.first=An.prototype.head,
+wi&&(An.prototype[wi]=Xe),An}();typeof define=="function"&&typeof define.amd=="object"&&define.amd?($n._=rt, define(function(){return rt})):Nn?((Nn.exports=rt)._=rt,Fn._=rt):$n._=rt}).call(this);

web/js/dom.js

@@ -0,0 +1,285 @@
+/**
+ * Enable gif loading on hover
+ */
+function gifOver(thumbnail, hit) {
+    let callee = arguments.callee;
+
+    thumbnail.addEventListener("mouseover", function () {
+
+        thumbnail.mouseStayedOver = true;
+
+        window.setTimeout(function () {
+            if (thumbnail.mouseStayedOver) {
+                thumbnail.removeEventListener('mouseover', callee, false);
+
+                //Load gif
+                thumbnail.setAttribute("src", "f/" + hit["_id"]);
+            }
+        }, 600);
+
+    });
+
+    thumbnail.addEventListener("mouseout", function () {
+        //Reset timer
+        thumbnail.mouseStayedOver = false;
+        thumbnail.setAttribute("src", `t/${hit["_source"]["index"]}/${hit["_id"]}`);
+    })
+}
+
+function getContentHighlight(hit) {
+    const re = RegExp(/<mark>/g);
+
+    const sortByMathCount = (a, b) => {
+        return b.match(re).length - a.match(re).length;
+    };
+
+    if (hit.hasOwnProperty("highlight")) {
+        if (hit["highlight"].hasOwnProperty("content")) {
+            return hit["highlight"]["content"].sort(sortByMathCount)[0];
+
+        } else if (hit["highlight"].hasOwnProperty("content.nGram")) {
+            return hit["highlight"]["content.nGram"].sort(sortByMathCount)[0];
+        }
+    }
+
+    return undefined;
+}
+
+function applyNameToTitle(hit, title, extension) {
+    if (hit.hasOwnProperty("highlight")) {
+        if (hit["highlight"].hasOwnProperty("name")) {
+            title.insertAdjacentHTML('afterbegin', hit["highlight"]["name"] + extension);
+            return;
+        } else if (hit["highlight"].hasOwnProperty("name.nGram")) {
+            title.insertAdjacentHTML('afterbegin', hit["highlight"]["name.nGram"] + extension);
+            return;
+        }
+    }
+
+    title.appendChild(document.createTextNode(hit["_source"]["name"] + extension));
+}
+
+function addVidSrc(url, mime, video) {
+    let vidSource = document.createElement("source");
+    vidSource.setAttribute("src", url);
+    if (video.canPlayType(mime)) {
+        vidSource.setAttribute("type", mime);
+    } else {
+        vidSource.setAttribute("type", "video/webm");
+    }
+    video.appendChild(vidSource);
+}
+
+function shouldPlayVideo(hit) {
+    const videoc = hit["_source"]["videoc"];
+    return videoc !== "hevc" && videoc !== "mpeg2video" && videoc !== "wmv3";
+}
+
+/**
+ *
+ * @param hit
+ * @returns {Element}
+ */
+function createDocCard(hit) {
+    let docCard = document.createElement("div");
+    docCard.setAttribute("class", "card shadow-sm");
+
+    let docCardBody = document.createElement("div");
+    docCardBody.setAttribute("class", "card-body document");
+
+    let link = document.createElement("a");
+    link.setAttribute("href", "f/" + hit["_id"]);
+    link.setAttribute("target", "_blank");
+
+    //Title
+    let title = document.createElement("p");
+    title.setAttribute("class", "file-title");
+    let extension = hit["_source"].hasOwnProperty("extension") && hit["_source"]["extension"] !== "" ? "." + hit["_source"]["extension"] : "";
+
+    applyNameToTitle(hit, title, extension);
+
+    title.setAttribute("title", hit["_source"]["path"] + "/" + hit["_source"]["name"] + extension);
+    docCard.appendChild(title);
+
+    let tagContainer = document.createElement("div");
+    tagContainer.setAttribute("class", "card-text");
+
+    if (hit["_source"].hasOwnProperty("mime") && hit["_source"]["mime"] !== null) {
+
+        let tags = [];
+        let thumbnail = null;
+        let thumbnailOverlay = null;
+        let imgWrapper = document.createElement("div");
+        imgWrapper.setAttribute("style", "position: relative");
+
+        let mimeCategory = hit["_source"]["mime"].split("/")[0];
+
+        //Thumbnail
+        if (mimeCategory === "video" && shouldPlayVideo(hit)) {
+            thumbnail = document.createElement("video");
+            addVidSrc("f/" + hit["_id"], hit["_source"]["mime"], thumbnail);
+
+            thumbnail.setAttribute("class", "fit");
+            thumbnail.setAttribute("loop", "");
+            thumbnail.setAttribute("controls", "");
+            thumbnail.setAttribute("preload", "none");
+            thumbnail.setAttribute("poster", `t/${hit["_source"]["index"]}/${hit["_id"]}`);
+            thumbnail.addEventListener("dblclick", function () {
+                thumbnail.webkitRequestFullScreen();
+            });
+        } else if ((hit["_source"].hasOwnProperty("width") && hit["_source"]["width"] > 20 && hit["_source"]["height"] > 20)
+            || hit["_source"]["mime"] === "application/pdf"
+            || hit["_source"].hasOwnProperty("font_name")
+        ) {
+            thumbnail = document.createElement("img");
+            thumbnail.setAttribute("class", "card-img-top fit");
+            thumbnail.setAttribute("src", `t/${hit["_source"]["index"]}/${hit["_id"]}`);
+        }
+
+        //Thumbnail overlay
+        switch (mimeCategory) {
+
+            case "image":
+                thumbnailOverlay = document.createElement("div");
+                thumbnailOverlay.setAttribute("class", "card-img-overlay");
+
+                //Resolution
+                let resolutionBadge = document.createElement("span");
+                resolutionBadge.setAttribute("class", "badge badge-resolution");
+                if (hit["_source"].hasOwnProperty("width")) {
+                    resolutionBadge.appendChild(document.createTextNode(hit["_source"]["width"] + "x" + hit["_source"]["height"]));
+                }
+                thumbnailOverlay.appendChild(resolutionBadge);
+
+                // Hover
+                if (thumbnail && hit["_source"]["videoc"] === "gif") {
+                    gifOver(thumbnail, hit);
+                }
+                break;
+
+            case "video":
+                //Duration
+                if (hit["_source"].hasOwnProperty("duration")) {
+                    thumbnailOverlay = document.createElement("div");
+                    thumbnailOverlay.setAttribute("class", "card-img-overlay");
+                    let durationBadge = document.createElement("span");
+                    durationBadge.setAttribute("class", "badge badge-resolution");
+                    durationBadge.appendChild(document.createTextNode(humanTime(hit["_source"]["duration"])));
+                    thumbnailOverlay.appendChild(durationBadge);
+                }
+        }
+
+        //Tags
+        //todo: handle new tags
+        switch (mimeCategory) {
+            case "video":
+            case "image":
+                if (hit.hasOwnProperty("videoc")) {
+                    let formatTag = document.createElement("span");
+                    formatTag.setAttribute("class", "badge badge-pill badge-video");
+                    formatTag.appendChild(document.createTextNode(hit["_source"]["videoc"].replace(" ", "")));
+                    tags.push(formatTag);
+                }
+                break;
+            case "audio": {
+                if (hit.hasOwnProperty("audioc")) {
+                    let formatTag = document.createElement("span");
+                    formatTag.setAttribute("class", "badge badge-pill badge-audio");
+                    formatTag.appendChild(document.createTextNode(hit["_source"]["audioc"]));
+                    tags.push(formatTag);
+                }
+            }
+                break;
+        }
+
+        //Content
+        let contentHl = getContentHighlight(hit);
+        if (contentHl !== undefined) {
+            let contentDiv = document.createElement("div");
+            contentDiv.setAttribute("class", "content-div bg-light");
+            contentDiv.insertAdjacentHTML('afterbegin', contentHl);
+            docCard.appendChild(contentDiv);
+        }
+
+        if (thumbnail !== null) {
+            imgWrapper.appendChild(thumbnail);
+            docCard.appendChild(imgWrapper);
+        }
+
+        //Audio
+        if (mimeCategory === "audio" && hit["_source"].hasOwnProperty("audioc")) {
+
+            let audio = document.createElement("audio");
+            audio.setAttribute("preload", "none");
+            audio.setAttribute("class", "audio-fit fit");
+            audio.setAttribute("controls", "");
+            audio.setAttribute("type", hit["_source"]["mime"]);
+            audio.setAttribute("src", "f/" + hit["_id"]);
+
+            docCard.appendChild(audio)
+        }
+
+        if (thumbnailOverlay !== null) {
+            imgWrapper.appendChild(thumbnailOverlay);
+        }
+
+        for (let i = 0; i < tags.length; i++) {
+            tagContainer.appendChild(tags[i]);
+        }
+    }
+
+    //Size tag
+    let sizeTag = document.createElement("small");
+    sizeTag.appendChild(document.createTextNode(humanFileSize(hit["_source"]["size"])));
+    sizeTag.setAttribute("class", "text-muted");
+    tagContainer.appendChild(sizeTag);
+
+    docCardBody.appendChild(link);
+    docCard.appendChild(docCardBody);
+
+    link.appendChild(title);
+    docCardBody.appendChild(tagContainer);
+
+    return docCard;
+}
+
+function makePageIndicator(searchResult) {
+    let pageIndicator = document.createElement("div");
+    pageIndicator.setAttribute("class", "page-indicator shadow-sm bg-light font-weight-light");
+    const totalHits = searchResult["hits"]["total"].hasOwnProperty("value")
+        ? searchResult["hits"]["total"]["value"] : searchResult["hits"]["total"];
+    pageIndicator.appendChild(document.createTextNode(docCount + " / " + totalHits));
+    return pageIndicator;
+}
+
+
+function makeStatsCard(searchResult) {
+
+    let statsCard = document.createElement("div");
+    statsCard.setAttribute("class", "card");
+    let statsCardBody = document.createElement("div");
+    statsCardBody.setAttribute("class", "card-body");
+
+    let stat = document.createElement("p");
+    const totalHits = searchResult["hits"]["total"].hasOwnProperty("value")
+        ? searchResult["hits"]["total"]["value"] : searchResult["hits"]["total"];
+    stat.appendChild(document.createTextNode(totalHits + " results in " + searchResult["took"] + "ms"));
+    statsCardBody.appendChild(stat);
+
+    if (totalHits !== 0) {
+        let sizeStat = document.createElement("span");
+        sizeStat.appendChild(document.createTextNode(humanFileSize(searchResult["aggregations"]["total_size"]["value"])));
+        statsCardBody.appendChild(sizeStat);
+    }
+
+    statsCard.appendChild(statsCardBody);
+
+    return statsCard;
+}
+
+function makeResultContainer() {
+    let resultContainer = document.createElement("div");
+    resultContainer.setAttribute("class", "card-columns");
+
+    return resultContainer;
+}

web/js/ion.rangeSlider.min.js

@@ -0,0 +1,81 @@
+(function(f){"function"===typeof define&&define.amd?define(["jquery"],function(n){return f(n,document,window,navigator)}):"object"===typeof exports?f(require("jquery"),document,window,navigator):f(jQuery,document,window,navigator)})(function(f,n,k,r,p){var t=0,m=function(){var a=r.userAgent,b=/msie\s\d+/i;return 0<a.search(b)&&(a=b.exec(a).toString(),a=a.split(" ")[1],9>a)?(f("html").addClass("lt-ie9"),!0):!1}();Function.prototype.bind||(Function.prototype.bind=function(a){var b=this,d=[].slice;if("function"!=
+typeof b)throw new TypeError;var c=d.call(arguments,1),e=function(){if(this instanceof e){var g=function(){};g.prototype=b.prototype;var g=new g,l=b.apply(g,c.concat(d.call(arguments)));return Object(l)===l?l:g}return b.apply(a,c.concat(d.call(arguments)))};return e});Array.prototype.indexOf||(Array.prototype.indexOf=function(a,b){if(null==this)throw new TypeError('"this" is null or not defined');var d=Object(this),c=d.length>>>0;if(0===c)return-1;var e=+b||0;Infinity===Math.abs(e)&&(e=0);if(e>=c)return-1;
+for(e=Math.max(0<=e?e:c-Math.abs(e),0);e<c;){if(e in d&&d[e]===a)return e;e++}return-1});var q=function(a,b,d){this.VERSION="2.2.0";this.input=a;this.plugin_count=d;this.old_to=this.old_from=this.update_tm=this.calc_count=this.current_plugin=0;this.raf_id=this.old_min_interval=null;this.no_diapason=this.force_redraw=this.dragging=!1;this.has_tab_index=!0;this.is_update=this.is_key=!1;this.is_start=!0;this.is_click=this.is_resize=this.is_active=this.is_finish=!1;b=b||{};this.$cache={win:f(k),body:f(n.body),
+input:f(a),cont:null,rs:null,min:null,max:null,from:null,to:null,single:null,bar:null,line:null,s_single:null,s_from:null,s_to:null,shad_single:null,shad_from:null,shad_to:null,edge:null,grid:null,grid_labels:[]};this.coords={x_gap:0,x_pointer:0,w_rs:0,w_rs_old:0,w_handle:0,p_gap:0,p_gap_left:0,p_gap_right:0,p_step:0,p_pointer:0,p_handle:0,p_single_fake:0,p_single_real:0,p_from_fake:0,p_from_real:0,p_to_fake:0,p_to_real:0,p_bar_x:0,p_bar_w:0,grid_gap:0,big_num:0,big:[],big_w:[],big_p:[],big_x:[]};
+this.labels={w_min:0,w_max:0,w_from:0,w_to:0,w_single:0,p_min:0,p_max:0,p_from_fake:0,p_from_left:0,p_to_fake:0,p_to_left:0,p_single_fake:0,p_single_left:0};var c=this.$cache.input;a=c.prop("value");var e;d={type:"single",min:10,max:100,from:null,to:null,step:1,min_interval:0,max_interval:0,drag_interval:!1,values:[],p_values:[],from_fixed:!1,from_min:null,from_max:null,from_shadow:!1,to_fixed:!1,to_min:null,to_max:null,to_shadow:!1,prettify_enabled:!0,prettify_separator:" ",prettify:null,force_edges:!1,
+keyboard:!0,grid:!1,grid_margin:!0,grid_num:4,grid_snap:!1,hide_min_max:!1,hide_from_to:!1,prefix:"",postfix:"",max_postfix:"",decorate_both:!0,values_separator:" \u2014 ",input_values_separator:";",disable:!1,block:!1,extra_classes:"",scope:null,onStart:null,onChange:null,onFinish:null,onUpdate:null};"INPUT"!==c[0].nodeName&&console&&console.warn&&console.warn("Base element should be <input>!",c[0]);c={type:c.data("type"),min:c.data("min"),max:c.data("max"),from:c.data("from"),to:c.data("to"),step:c.data("step"),
+min_interval:c.data("minInterval"),max_interval:c.data("maxInterval"),drag_interval:c.data("dragInterval"),values:c.data("values"),from_fixed:c.data("fromFixed"),from_min:c.data("fromMin"),from_max:c.data("fromMax"),from_shadow:c.data("fromShadow"),to_fixed:c.data("toFixed"),to_min:c.data("toMin"),to_max:c.data("toMax"),to_shadow:c.data("toShadow"),prettify_enabled:c.data("prettifyEnabled"),prettify_separator:c.data("prettifySeparator"),force_edges:c.data("forceEdges"),keyboard:c.data("keyboard"),
+grid:c.data("grid"),grid_margin:c.data("gridMargin"),grid_num:c.data("gridNum"),grid_snap:c.data("gridSnap"),hide_min_max:c.data("hideMinMax"),hide_from_to:c.data("hideFromTo"),prefix:c.data("prefix"),postfix:c.data("postfix"),max_postfix:c.data("maxPostfix"),decorate_both:c.data("decorateBoth"),values_separator:c.data("valuesSeparator"),input_values_separator:c.data("inputValuesSeparator"),disable:c.data("disable"),block:c.data("block"),extra_classes:c.data("extraClasses")};c.values=c.values&&c.values.split(",");
+for(e in c)c.hasOwnProperty(e)&&(c[e]!==p&&""!==c[e]||delete c[e]);a!==p&&""!==a&&(a=a.split(c.input_values_separator||b.input_values_separator||";"),a[0]&&a[0]==+a[0]&&(a[0]=+a[0]),a[1]&&a[1]==+a[1]&&(a[1]=+a[1]),b&&b.values&&b.values.length?(d.from=a[0]&&b.values.indexOf(a[0]),d.to=a[1]&&b.values.indexOf(a[1])):(d.from=a[0]&&+a[0],d.to=a[1]&&+a[1]));f.extend(d,b);f.extend(d,c);this.options=d;this.update_check={};this.validate();this.result={input:this.$cache.input,slider:null,min:this.options.min,
+max:this.options.max,from:this.options.from,from_percent:0,from_value:null,to:this.options.to,to_percent:0,to_value:null};this.init()};q.prototype={init:function(a){this.no_diapason=!1;this.coords.p_step=this.convertToPercent(this.options.step,!0);this.target="base";this.toggleInput();this.append();this.setMinMax();a?(this.force_redraw=!0,this.calc(!0),this.callOnUpdate()):(this.force_redraw=!0,this.calc(!0),this.callOnStart());this.updateScene()},append:function(){this.$cache.input.before('<span class="irs js-irs-'+
+this.plugin_count+" "+this.options.extra_classes+'"></span>');this.$cache.input.prop("readonly",!0);this.$cache.cont=this.$cache.input.prev();this.result.slider=this.$cache.cont;this.$cache.cont.html('<span class="irs"><span class="irs-line" tabindex="0"><span class="irs-line-left"></span><span class="irs-line-mid"></span><span class="irs-line-right"></span></span><span class="irs-min">0</span><span class="irs-max">1</span><span class="irs-from">0</span><span class="irs-to">0</span><span class="irs-single">0</span></span><span class="irs-grid"></span><span class="irs-bar"></span>');
+this.$cache.rs=this.$cache.cont.find(".irs");this.$cache.min=this.$cache.cont.find(".irs-min");this.$cache.max=this.$cache.cont.find(".irs-max");this.$cache.from=this.$cache.cont.find(".irs-from");this.$cache.to=this.$cache.cont.find(".irs-to");this.$cache.single=this.$cache.cont.find(".irs-single");this.$cache.bar=this.$cache.cont.find(".irs-bar");this.$cache.line=this.$cache.cont.find(".irs-line");this.$cache.grid=this.$cache.cont.find(".irs-grid");"single"===this.options.type?(this.$cache.cont.append('<span class="irs-bar-edge"></span><span class="irs-shadow shadow-single"></span><span class="irs-slider single"></span>'),
+this.$cache.edge=this.$cache.cont.find(".irs-bar-edge"),this.$cache.s_single=this.$cache.cont.find(".single"),this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility="hidden",this.$cache.shad_single=this.$cache.cont.find(".shadow-single")):(this.$cache.cont.append('<span class="irs-shadow shadow-from"></span><span class="irs-shadow shadow-to"></span><span class="irs-slider from"></span><span class="irs-slider to"></span>'),this.$cache.s_from=this.$cache.cont.find(".from"),
+this.$cache.s_to=this.$cache.cont.find(".to"),this.$cache.shad_from=this.$cache.cont.find(".shadow-from"),this.$cache.shad_to=this.$cache.cont.find(".shadow-to"),this.setTopHandler());this.options.hide_from_to&&(this.$cache.from[0].style.display="none",this.$cache.to[0].style.display="none",this.$cache.single[0].style.display="none");this.appendGrid();this.options.disable?(this.appendDisableMask(),this.$cache.input[0].disabled=!0):(this.$cache.input[0].disabled=!1,this.removeDisableMask(),this.bindEvents());
+this.options.disable||(this.options.block?this.appendDisableMask():this.removeDisableMask());this.options.drag_interval&&(this.$cache.bar[0].style.cursor="move")},setTopHandler:function(){var a=this.options.max,b=this.options.to;this.options.from>this.options.min&&b===a?this.$cache.s_from.addClass("type_last"):b<a&&this.$cache.s_to.addClass("type_last")},changeLevel:function(a){switch(a){case "single":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_single_fake);this.$cache.s_single.addClass("state_hover");
+break;case "from":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_from_fake);this.$cache.s_from.addClass("state_hover");this.$cache.s_from.addClass("type_last");this.$cache.s_to.removeClass("type_last");break;case "to":this.coords.p_gap=this.toFixed(this.coords.p_pointer-this.coords.p_to_fake);this.$cache.s_to.addClass("state_hover");this.$cache.s_to.addClass("type_last");this.$cache.s_from.removeClass("type_last");break;case "both":this.coords.p_gap_left=this.toFixed(this.coords.p_pointer-
+this.coords.p_from_fake),this.coords.p_gap_right=this.toFixed(this.coords.p_to_fake-this.coords.p_pointer),this.$cache.s_to.removeClass("type_last"),this.$cache.s_from.removeClass("type_last")}},appendDisableMask:function(){this.$cache.cont.append('<span class="irs-disable-mask"></span>');this.$cache.cont.addClass("irs-disabled")},removeDisableMask:function(){this.$cache.cont.remove(".irs-disable-mask");this.$cache.cont.removeClass("irs-disabled")},remove:function(){this.$cache.cont.remove();this.$cache.cont=
+null;this.$cache.line.off("keydown.irs_"+this.plugin_count);this.$cache.body.off("touchmove.irs_"+this.plugin_count);this.$cache.body.off("mousemove.irs_"+this.plugin_count);this.$cache.win.off("touchend.irs_"+this.plugin_count);this.$cache.win.off("mouseup.irs_"+this.plugin_count);m&&(this.$cache.body.off("mouseup.irs_"+this.plugin_count),this.$cache.body.off("mouseleave.irs_"+this.plugin_count));this.$cache.grid_labels=[];this.coords.big=[];this.coords.big_w=[];this.coords.big_p=[];this.coords.big_x=
+[];cancelAnimationFrame(this.raf_id)},bindEvents:function(){if(!this.no_diapason){this.$cache.body.on("touchmove.irs_"+this.plugin_count,this.pointerMove.bind(this));this.$cache.body.on("mousemove.irs_"+this.plugin_count,this.pointerMove.bind(this));this.$cache.win.on("touchend.irs_"+this.plugin_count,this.pointerUp.bind(this));this.$cache.win.on("mouseup.irs_"+this.plugin_count,this.pointerUp.bind(this));this.$cache.line.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"));
+this.$cache.line.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"));this.$cache.line.on("focus.irs_"+this.plugin_count,this.pointerFocus.bind(this));this.options.drag_interval&&"double"===this.options.type?(this.$cache.bar.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"both")),this.$cache.bar.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"both"))):(this.$cache.bar.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),
+this.$cache.bar.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")));"single"===this.options.type?(this.$cache.single.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.s_single.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.shad_single.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,
+"single")),this.$cache.s_single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"single")),this.$cache.edge.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_single.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click"))):(this.$cache.single.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,null)),this.$cache.single.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,null)),this.$cache.from.on("touchstart.irs_"+
+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.s_from.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.to.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.s_to.on("touchstart.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.shad_from.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_to.on("touchstart.irs_"+this.plugin_count,this.pointerClick.bind(this,
+"click")),this.$cache.from.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.s_from.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"from")),this.$cache.to.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.s_to.on("mousedown.irs_"+this.plugin_count,this.pointerDown.bind(this,"to")),this.$cache.shad_from.on("mousedown.irs_"+this.plugin_count,this.pointerClick.bind(this,"click")),this.$cache.shad_to.on("mousedown.irs_"+
+this.plugin_count,this.pointerClick.bind(this,"click")));if(this.options.keyboard)this.$cache.line.on("keydown.irs_"+this.plugin_count,this.key.bind(this,"keyboard"));m&&(this.$cache.body.on("mouseup.irs_"+this.plugin_count,this.pointerUp.bind(this)),this.$cache.body.on("mouseleave.irs_"+this.plugin_count,this.pointerUp.bind(this)))}},pointerFocus:function(a){if(!this.target){var b="single"===this.options.type?this.$cache.single:this.$cache.from;a=b.offset().left;a+=b.width()/2-1;this.pointerClick("single",
+{preventDefault:function(){},pageX:a})}},pointerMove:function(a){this.dragging&&(this.coords.x_pointer=(a.pageX||a.originalEvent.touches&&a.originalEvent.touches[0].pageX)-this.coords.x_gap,this.calc())},pointerUp:function(a){this.current_plugin===this.plugin_count&&this.is_active&&(this.is_active=!1,this.$cache.cont.find(".state_hover").removeClass("state_hover"),this.force_redraw=!0,m&&f("*").prop("unselectable",!1),this.updateScene(),this.restoreOriginalMinInterval(),(f.contains(this.$cache.cont[0],
+a.target)||this.dragging)&&this.callOnFinish(),this.dragging=!1)},pointerDown:function(a,b){b.preventDefault();var d=b.pageX||b.originalEvent.touches&&b.originalEvent.touches[0].pageX;2!==b.button&&("both"===a&&this.setTempMinInterval(),a||(a=this.target||"from"),this.current_plugin=this.plugin_count,this.target=a,this.dragging=this.is_active=!0,this.coords.x_gap=this.$cache.rs.offset().left,this.coords.x_pointer=d-this.coords.x_gap,this.calcPointerPercent(),this.changeLevel(a),m&&f("*").prop("unselectable",
+!0),this.$cache.line.trigger("focus"),this.updateScene())},pointerClick:function(a,b){b.preventDefault();var d=b.pageX||b.originalEvent.touches&&b.originalEvent.touches[0].pageX;2!==b.button&&(this.current_plugin=this.plugin_count,this.target=a,this.is_click=!0,this.coords.x_gap=this.$cache.rs.offset().left,this.coords.x_pointer=+(d-this.coords.x_gap).toFixed(),this.force_redraw=!0,this.calc(),this.$cache.line.trigger("focus"))},key:function(a,b){if(!(this.current_plugin!==this.plugin_count||b.altKey||
+b.ctrlKey||b.shiftKey||b.metaKey)){switch(b.which){case 83:case 65:case 40:case 37:b.preventDefault();this.moveByKey(!1);break;case 87:case 68:case 38:case 39:b.preventDefault(),this.moveByKey(!0)}return!0}},moveByKey:function(a){var b=this.coords.p_pointer,d=(this.options.max-this.options.min)/100,d=this.options.step/d;this.coords.x_pointer=this.toFixed(this.coords.w_rs/100*(a?b+d:b-d));this.is_key=!0;this.calc()},setMinMax:function(){if(this.options)if(this.options.hide_min_max)this.$cache.min[0].style.display=
+"none",this.$cache.max[0].style.display="none";else{if(this.options.values.length)this.$cache.min.html(this.decorate(this.options.p_values[this.options.min])),this.$cache.max.html(this.decorate(this.options.p_values[this.options.max]));else{var a=this._prettify(this.options.min),b=this._prettify(this.options.max);this.result.min_pretty=a;this.result.max_pretty=b;this.$cache.min.html(this.decorate(a,this.options.min));this.$cache.max.html(this.decorate(b,this.options.max))}this.labels.w_min=this.$cache.min.outerWidth(!1);
+this.labels.w_max=this.$cache.max.outerWidth(!1)}},setTempMinInterval:function(){var a=this.result.to-this.result.from;null===this.old_min_interval&&(this.old_min_interval=this.options.min_interval);this.options.min_interval=a},restoreOriginalMinInterval:function(){null!==this.old_min_interval&&(this.options.min_interval=this.old_min_interval,this.old_min_interval=null)},calc:function(a){if(this.options){this.calc_count++;if(10===this.calc_count||a)this.calc_count=0,this.coords.w_rs=this.$cache.rs.outerWidth(!1),
+this.calcHandlePercent();if(this.coords.w_rs){this.calcPointerPercent();a=this.getHandleX();"both"===this.target&&(this.coords.p_gap=0,a=this.getHandleX());"click"===this.target&&(this.coords.p_gap=this.coords.p_handle/2,a=this.getHandleX(),this.target=this.options.drag_interval?"both_one":this.chooseHandle(a));switch(this.target){case "base":var b=(this.options.max-this.options.min)/100;a=(this.result.from-this.options.min)/b;b=(this.result.to-this.options.min)/b;this.coords.p_single_real=this.toFixed(a);
+this.coords.p_from_real=this.toFixed(a);this.coords.p_to_real=this.toFixed(b);this.coords.p_single_real=this.checkDiapason(this.coords.p_single_real,this.options.from_min,this.options.from_max);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_single_fake=this.convertToFakePercent(this.coords.p_single_real);this.coords.p_from_fake=
+this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);this.target=null;break;case "single":if(this.options.from_fixed)break;this.coords.p_single_real=this.convertToRealPercent(a);this.coords.p_single_real=this.calcWithStep(this.coords.p_single_real);this.coords.p_single_real=this.checkDiapason(this.coords.p_single_real,this.options.from_min,this.options.from_max);this.coords.p_single_fake=this.convertToFakePercent(this.coords.p_single_real);
+break;case "from":if(this.options.from_fixed)break;this.coords.p_from_real=this.convertToRealPercent(a);this.coords.p_from_real=this.calcWithStep(this.coords.p_from_real);this.coords.p_from_real>this.coords.p_to_real&&(this.coords.p_from_real=this.coords.p_to_real);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_from_real=this.checkMinInterval(this.coords.p_from_real,this.coords.p_to_real,"from");this.coords.p_from_real=
+this.checkMaxInterval(this.coords.p_from_real,this.coords.p_to_real,"from");this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);break;case "to":if(this.options.to_fixed)break;this.coords.p_to_real=this.convertToRealPercent(a);this.coords.p_to_real=this.calcWithStep(this.coords.p_to_real);this.coords.p_to_real<this.coords.p_from_real&&(this.coords.p_to_real=this.coords.p_from_real);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);
+this.coords.p_to_real=this.checkMinInterval(this.coords.p_to_real,this.coords.p_from_real,"to");this.coords.p_to_real=this.checkMaxInterval(this.coords.p_to_real,this.coords.p_from_real,"to");this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);break;case "both":if(this.options.from_fixed||this.options.to_fixed)break;a=this.toFixed(a+.001*this.coords.p_handle);this.coords.p_from_real=this.convertToRealPercent(a)-this.coords.p_gap_left;this.coords.p_from_real=this.calcWithStep(this.coords.p_from_real);
+this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,this.options.from_min,this.options.from_max);this.coords.p_from_real=this.checkMinInterval(this.coords.p_from_real,this.coords.p_to_real,"from");this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_real=this.convertToRealPercent(a)+this.coords.p_gap_right;this.coords.p_to_real=this.calcWithStep(this.coords.p_to_real);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,
+this.options.to_max);this.coords.p_to_real=this.checkMinInterval(this.coords.p_to_real,this.coords.p_from_real,"to");this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real);break;case "both_one":if(!this.options.from_fixed&&!this.options.to_fixed){var d=this.convertToRealPercent(a);a=this.result.to_percent-this.result.from_percent;var c=a/2,b=d-c,d=d+c;0>b&&(b=0,d=b+a);100<d&&(d=100,b=d-a);this.coords.p_from_real=this.calcWithStep(b);this.coords.p_from_real=this.checkDiapason(this.coords.p_from_real,
+this.options.from_min,this.options.from_max);this.coords.p_from_fake=this.convertToFakePercent(this.coords.p_from_real);this.coords.p_to_real=this.calcWithStep(d);this.coords.p_to_real=this.checkDiapason(this.coords.p_to_real,this.options.to_min,this.options.to_max);this.coords.p_to_fake=this.convertToFakePercent(this.coords.p_to_real)}}"single"===this.options.type?(this.coords.p_bar_x=this.coords.p_handle/2,this.coords.p_bar_w=this.coords.p_single_fake,this.result.from_percent=this.coords.p_single_real,
+this.result.from=this.convertToValue(this.coords.p_single_real),this.result.from_pretty=this._prettify(this.result.from),this.options.values.length&&(this.result.from_value=this.options.values[this.result.from])):(this.coords.p_bar_x=this.toFixed(this.coords.p_from_fake+this.coords.p_handle/2),this.coords.p_bar_w=this.toFixed(this.coords.p_to_fake-this.coords.p_from_fake),this.result.from_percent=this.coords.p_from_real,this.result.from=this.convertToValue(this.coords.p_from_real),this.result.from_pretty=
+this._prettify(this.result.from),this.result.to_percent=this.coords.p_to_real,this.result.to=this.convertToValue(this.coords.p_to_real),this.result.to_pretty=this._prettify(this.result.to),this.options.values.length&&(this.result.from_value=this.options.values[this.result.from],this.result.to_value=this.options.values[this.result.to]));this.calcMinMax();this.calcLabels()}}},calcPointerPercent:function(){this.coords.w_rs?(0>this.coords.x_pointer||isNaN(this.coords.x_pointer)?this.coords.x_pointer=
+0:this.coords.x_pointer>this.coords.w_rs&&(this.coords.x_pointer=this.coords.w_rs),this.coords.p_pointer=this.toFixed(this.coords.x_pointer/this.coords.w_rs*100)):this.coords.p_pointer=0},convertToRealPercent:function(a){return a/(100-this.coords.p_handle)*100},convertToFakePercent:function(a){return a/100*(100-this.coords.p_handle)},getHandleX:function(){var a=100-this.coords.p_handle,b=this.toFixed(this.coords.p_pointer-this.coords.p_gap);0>b?b=0:b>a&&(b=a);return b},calcHandlePercent:function(){this.coords.w_handle=
+"single"===this.options.type?this.$cache.s_single.outerWidth(!1):this.$cache.s_from.outerWidth(!1);this.coords.p_handle=this.toFixed(this.coords.w_handle/this.coords.w_rs*100)},chooseHandle:function(a){return"single"===this.options.type?"single":a>=this.coords.p_from_real+(this.coords.p_to_real-this.coords.p_from_real)/2?this.options.to_fixed?"from":"to":this.options.from_fixed?"to":"from"},calcMinMax:function(){this.coords.w_rs&&(this.labels.p_min=this.labels.w_min/this.coords.w_rs*100,this.labels.p_max=
+this.labels.w_max/this.coords.w_rs*100)},calcLabels:function(){this.coords.w_rs&&!this.options.hide_from_to&&("single"===this.options.type?(this.labels.w_single=this.$cache.single.outerWidth(!1),this.labels.p_single_fake=this.labels.w_single/this.coords.w_rs*100,this.labels.p_single_left=this.coords.p_single_fake+this.coords.p_handle/2-this.labels.p_single_fake/2):(this.labels.w_from=this.$cache.from.outerWidth(!1),this.labels.p_from_fake=this.labels.w_from/this.coords.w_rs*100,this.labels.p_from_left=
+this.coords.p_from_fake+this.coords.p_handle/2-this.labels.p_from_fake/2,this.labels.p_from_left=this.toFixed(this.labels.p_from_left),this.labels.p_from_left=this.checkEdges(this.labels.p_from_left,this.labels.p_from_fake),this.labels.w_to=this.$cache.to.outerWidth(!1),this.labels.p_to_fake=this.labels.w_to/this.coords.w_rs*100,this.labels.p_to_left=this.coords.p_to_fake+this.coords.p_handle/2-this.labels.p_to_fake/2,this.labels.p_to_left=this.toFixed(this.labels.p_to_left),this.labels.p_to_left=
+this.checkEdges(this.labels.p_to_left,this.labels.p_to_fake),this.labels.w_single=this.$cache.single.outerWidth(!1),this.labels.p_single_fake=this.labels.w_single/this.coords.w_rs*100,this.labels.p_single_left=(this.labels.p_from_left+this.labels.p_to_left+this.labels.p_to_fake)/2-this.labels.p_single_fake/2,this.labels.p_single_left=this.toFixed(this.labels.p_single_left)),this.labels.p_single_left=this.checkEdges(this.labels.p_single_left,this.labels.p_single_fake))},updateScene:function(){this.raf_id&&
+(cancelAnimationFrame(this.raf_id),this.raf_id=null);clearTimeout(this.update_tm);this.update_tm=null;this.options&&(this.drawHandles(),this.is_active?this.raf_id=requestAnimationFrame(this.updateScene.bind(this)):this.update_tm=setTimeout(this.updateScene.bind(this),300))},drawHandles:function(){this.coords.w_rs=this.$cache.rs.outerWidth(!1);if(this.coords.w_rs){this.coords.w_rs!==this.coords.w_rs_old&&(this.target="base",this.is_resize=!0);if(this.coords.w_rs!==this.coords.w_rs_old||this.force_redraw)this.setMinMax(),
+this.calc(!0),this.drawLabels(),this.options.grid&&(this.calcGridMargin(),this.calcGridLabels()),this.force_redraw=!0,this.coords.w_rs_old=this.coords.w_rs,this.drawShadow();if(this.coords.w_rs&&(this.dragging||this.force_redraw||this.is_key)){if(this.old_from!==this.result.from||this.old_to!==this.result.to||this.force_redraw||this.is_key){this.drawLabels();this.$cache.bar[0].style.left=this.coords.p_bar_x+"%";this.$cache.bar[0].style.width=this.coords.p_bar_w+"%";if("single"===this.options.type)this.$cache.s_single[0].style.left=
+this.coords.p_single_fake+"%";else{this.$cache.s_from[0].style.left=this.coords.p_from_fake+"%";this.$cache.s_to[0].style.left=this.coords.p_to_fake+"%";if(this.old_from!==this.result.from||this.force_redraw)this.$cache.from[0].style.left=this.labels.p_from_left+"%";if(this.old_to!==this.result.to||this.force_redraw)this.$cache.to[0].style.left=this.labels.p_to_left+"%"}this.$cache.single[0].style.left=this.labels.p_single_left+"%";this.writeToInput();this.old_from===this.result.from&&this.old_to===
+this.result.to||this.is_start||(this.$cache.input.trigger("change"),this.$cache.input.trigger("input"));this.old_from=this.result.from;this.old_to=this.result.to;this.is_resize||this.is_update||this.is_start||this.is_finish||this.callOnChange();if(this.is_key||this.is_click)this.is_click=this.is_key=!1,this.callOnFinish();this.is_finish=this.is_resize=this.is_update=!1}this.force_redraw=this.is_click=this.is_key=this.is_start=!1}}},drawLabels:function(){if(this.options){var a=this.options.values.length,
+b=this.options.p_values;if(!this.options.hide_from_to)if("single"===this.options.type){if(a)a=this.decorate(b[this.result.from]);else{var d=this._prettify(this.result.from);a=this.decorate(d,this.result.from)}this.$cache.single.html(a);this.calcLabels();this.$cache.min[0].style.visibility=this.labels.p_single_left<this.labels.p_min+1?"hidden":"visible";this.$cache.max[0].style.visibility=this.labels.p_single_left+this.labels.p_single_fake>100-this.labels.p_max-1?"hidden":"visible"}else{a?(this.options.decorate_both?
+(a=this.decorate(b[this.result.from]),a+=this.options.values_separator,a+=this.decorate(b[this.result.to])):a=this.decorate(b[this.result.from]+this.options.values_separator+b[this.result.to]),d=this.decorate(b[this.result.from]),b=this.decorate(b[this.result.to])):(d=this._prettify(this.result.from),b=this._prettify(this.result.to),this.options.decorate_both?(a=this.decorate(d,this.result.from),a+=this.options.values_separator,a+=this.decorate(b,this.result.to)):a=this.decorate(d+this.options.values_separator+
+b,this.result.to),d=this.decorate(d,this.result.from),b=this.decorate(b,this.result.to));this.$cache.single.html(a);this.$cache.from.html(d);this.$cache.to.html(b);this.calcLabels();a=Math.min(this.labels.p_single_left,this.labels.p_from_left);d=this.labels.p_single_left+this.labels.p_single_fake;var b=this.labels.p_to_left+this.labels.p_to_fake,c=Math.max(d,b);this.labels.p_from_left+this.labels.p_from_fake>=this.labels.p_to_left?(this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility=
+"hidden",this.$cache.single[0].style.visibility="visible",this.result.from===this.result.to?("from"===this.target?this.$cache.from[0].style.visibility="visible":"to"===this.target?this.$cache.to[0].style.visibility="visible":this.target||(this.$cache.from[0].style.visibility="visible"),this.$cache.single[0].style.visibility="hidden",c=b):(this.$cache.from[0].style.visibility="hidden",this.$cache.to[0].style.visibility="hidden",this.$cache.single[0].style.visibility="visible",c=Math.max(d,b))):(this.$cache.from[0].style.visibility=
+"visible",this.$cache.to[0].style.visibility="visible",this.$cache.single[0].style.visibility="hidden");this.$cache.min[0].style.visibility=a<this.labels.p_min+1?"hidden":"visible";this.$cache.max[0].style.visibility=c>100-this.labels.p_max-1?"hidden":"visible"}}},drawShadow:function(){var a=this.options,b=this.$cache,d="number"===typeof a.from_min&&!isNaN(a.from_min),c="number"===typeof a.from_max&&!isNaN(a.from_max),e="number"===typeof a.to_min&&!isNaN(a.to_min),g="number"===typeof a.to_max&&!isNaN(a.to_max);
+"single"===a.type?a.from_shadow&&(d||c)?(d=this.convertToPercent(d?a.from_min:a.min),c=this.convertToPercent(c?a.from_max:a.max)-d,d=this.toFixed(d-this.coords.p_handle/100*d),c=this.toFixed(c-this.coords.p_handle/100*c),d+=this.coords.p_handle/2,b.shad_single[0].style.display="block",b.shad_single[0].style.left=d+"%",b.shad_single[0].style.width=c+"%"):b.shad_single[0].style.display="none":(a.from_shadow&&(d||c)?(d=this.convertToPercent(d?a.from_min:a.min),c=this.convertToPercent(c?a.from_max:a.max)-
+d,d=this.toFixed(d-this.coords.p_handle/100*d),c=this.toFixed(c-this.coords.p_handle/100*c),d+=this.coords.p_handle/2,b.shad_from[0].style.display="block",b.shad_from[0].style.left=d+"%",b.shad_from[0].style.width=c+"%"):b.shad_from[0].style.display="none",a.to_shadow&&(e||g)?(e=this.convertToPercent(e?a.to_min:a.min),a=this.convertToPercent(g?a.to_max:a.max)-e,e=this.toFixed(e-this.coords.p_handle/100*e),a=this.toFixed(a-this.coords.p_handle/100*a),e+=this.coords.p_handle/2,b.shad_to[0].style.display=
+"block",b.shad_to[0].style.left=e+"%",b.shad_to[0].style.width=a+"%"):b.shad_to[0].style.display="none")},writeToInput:function(){"single"===this.options.type?(this.options.values.length?this.$cache.input.prop("value",this.result.from_value):this.$cache.input.prop("value",this.result.from),this.$cache.input.data("from",this.result.from)):(this.options.values.length?this.$cache.input.prop("value",this.result.from_value+this.options.input_values_separator+this.result.to_value):this.$cache.input.prop("value",
+this.result.from+this.options.input_values_separator+this.result.to),this.$cache.input.data("from",this.result.from),this.$cache.input.data("to",this.result.to))},callOnStart:function(){this.writeToInput();if(this.options.onStart&&"function"===typeof this.options.onStart)if(this.options.scope)this.options.onStart.call(this.options.scope,this.result);else this.options.onStart(this.result)},callOnChange:function(){this.writeToInput();if(this.options.onChange&&"function"===typeof this.options.onChange)if(this.options.scope)this.options.onChange.call(this.options.scope,
+this.result);else this.options.onChange(this.result)},callOnFinish:function(){this.writeToInput();if(this.options.onFinish&&"function"===typeof this.options.onFinish)if(this.options.scope)this.options.onFinish.call(this.options.scope,this.result);else this.options.onFinish(this.result)},callOnUpdate:function(){this.writeToInput();if(this.options.onUpdate&&"function"===typeof this.options.onUpdate)if(this.options.scope)this.options.onUpdate.call(this.options.scope,this.result);else this.options.onUpdate(this.result)},
+toggleInput:function(){this.$cache.input.toggleClass("irs-hidden-input");this.has_tab_index?this.$cache.input.prop("tabindex",-1):this.$cache.input.removeProp("tabindex");this.has_tab_index=!this.has_tab_index},convertToPercent:function(a,b){var d=this.options.max-this.options.min;return d?this.toFixed((b?a:a-this.options.min)/(d/100)):(this.no_diapason=!0,0)},convertToValue:function(a){var b=this.options.min,d=this.options.max,c=b.toString().split(".")[1],e=d.toString().split(".")[1],g,l,f=0,h=0;
+if(0===a)return this.options.min;if(100===a)return this.options.max;c&&(f=g=c.length);e&&(f=l=e.length);g&&l&&(f=g>=l?g:l);0>b&&(h=Math.abs(b),b=+(b+h).toFixed(f),d=+(d+h).toFixed(f));a=(d-b)/100*a+b;(b=this.options.step.toString().split(".")[1])?a=+a.toFixed(b.length):(a/=this.options.step,a*=this.options.step,a=+a.toFixed(0));h&&(a-=h);h=b?+a.toFixed(b.length):this.toFixed(a);h<this.options.min?h=this.options.min:h>this.options.max&&(h=this.options.max);return h},calcWithStep:function(a){var b=
+Math.round(a/this.coords.p_step)*this.coords.p_step;100<b&&(b=100);100===a&&(b=100);return this.toFixed(b)},checkMinInterval:function(a,b,d){var c=this.options;if(!c.min_interval)return a;a=this.convertToValue(a);b=this.convertToValue(b);"from"===d?b-a<c.min_interval&&(a=b-c.min_interval):a-b<c.min_interval&&(a=b+c.min_interval);return this.convertToPercent(a)},checkMaxInterval:function(a,b,d){var c=this.options;if(!c.max_interval)return a;a=this.convertToValue(a);b=this.convertToValue(b);"from"===
+d?b-a>c.max_interval&&(a=b-c.max_interval):a-b>c.max_interval&&(a=b+c.max_interval);return this.convertToPercent(a)},checkDiapason:function(a,b,d){a=this.convertToValue(a);var c=this.options;"number"!==typeof b&&(b=c.min);"number"!==typeof d&&(d=c.max);a<b&&(a=b);a>d&&(a=d);return this.convertToPercent(a)},toFixed:function(a){a=a.toFixed(20);return+a},_prettify:function(a){return this.options.prettify_enabled?this.options.prettify&&"function"===typeof this.options.prettify?this.options.prettify(a):
+this.prettify(a):a},prettify:function(a){return a.toString().replace(/(\d{1,3}(?=(?:\d\d\d)+(?!\d)))/g,"$1"+this.options.prettify_separator)},checkEdges:function(a,b){if(!this.options.force_edges)return this.toFixed(a);0>a?a=0:a>100-b&&(a=100-b);return this.toFixed(a)},validate:function(){var a=this.options,b=this.result,d=a.values,c=d.length,e;"string"===typeof a.min&&(a.min=+a.min);"string"===typeof a.max&&(a.max=+a.max);"string"===typeof a.from&&(a.from=+a.from);"string"===typeof a.to&&(a.to=+a.to);
+"string"===typeof a.step&&(a.step=+a.step);"string"===typeof a.from_min&&(a.from_min=+a.from_min);"string"===typeof a.from_max&&(a.from_max=+a.from_max);"string"===typeof a.to_min&&(a.to_min=+a.to_min);"string"===typeof a.to_max&&(a.to_max=+a.to_max);"string"===typeof a.grid_num&&(a.grid_num=+a.grid_num);a.max<a.min&&(a.max=a.min);if(c)for(a.p_values=[],a.min=0,a.max=c-1,a.step=1,a.grid_num=a.max,a.grid_snap=!0,e=0;e<c;e++){var g=+d[e];isNaN(g)?g=d[e]:(d[e]=g,g=this._prettify(g));a.p_values.push(g)}if("number"!==
+typeof a.from||isNaN(a.from))a.from=a.min;if("number"!==typeof a.to||isNaN(a.to))a.to=a.max;"single"===a.type?(a.from<a.min&&(a.from=a.min),a.from>a.max&&(a.from=a.max)):(a.from<a.min&&(a.from=a.min),a.from>a.max&&(a.from=a.max),a.to<a.min&&(a.to=a.min),a.to>a.max&&(a.to=a.max),this.update_check.from&&(this.update_check.from!==a.from&&a.from>a.to&&(a.from=a.to),this.update_check.to!==a.to&&a.to<a.from&&(a.to=a.from)),a.from>a.to&&(a.from=a.to),a.to<a.from&&(a.to=a.from));if("number"!==typeof a.step||
+isNaN(a.step)||!a.step||0>a.step)a.step=1;"number"===typeof a.from_min&&a.from<a.from_min&&(a.from=a.from_min);"number"===typeof a.from_max&&a.from>a.from_max&&(a.from=a.from_max);"number"===typeof a.to_min&&a.to<a.to_min&&(a.to=a.to_min);"number"===typeof a.to_max&&a.from>a.to_max&&(a.to=a.to_max);if(b){b.min!==a.min&&(b.min=a.min);b.max!==a.max&&(b.max=a.max);if(b.from<b.min||b.from>b.max)b.from=a.from;if(b.to<b.min||b.to>b.max)b.to=a.to}if("number"!==typeof a.min_interval||isNaN(a.min_interval)||
+!a.min_interval||0>a.min_interval)a.min_interval=0;if("number"!==typeof a.max_interval||isNaN(a.max_interval)||!a.max_interval||0>a.max_interval)a.max_interval=0;a.min_interval&&a.min_interval>a.max-a.min&&(a.min_interval=a.max-a.min);a.max_interval&&a.max_interval>a.max-a.min&&(a.max_interval=a.max-a.min)},decorate:function(a,b){var d="",c=this.options;c.prefix&&(d+=c.prefix);d+=a;c.max_postfix&&(c.values.length&&a===c.p_values[c.max]?(d+=c.max_postfix,c.postfix&&(d+=" ")):b===c.max&&(d+=c.max_postfix,
+c.postfix&&(d+=" ")));c.postfix&&(d+=c.postfix);return d},updateFrom:function(){this.result.from=this.options.from;this.result.from_percent=this.convertToPercent(this.result.from);this.result.from_pretty=this._prettify(this.result.from);this.options.values&&(this.result.from_value=this.options.values[this.result.from])},updateTo:function(){this.result.to=this.options.to;this.result.to_percent=this.convertToPercent(this.result.to);this.result.to_pretty=this._prettify(this.result.to);this.options.values&&
+(this.result.to_value=this.options.values[this.result.to])},updateResult:function(){this.result.min=this.options.min;this.result.max=this.options.max;this.updateFrom();this.updateTo()},appendGrid:function(){if(this.options.grid){var a=this.options,b;var d=a.max-a.min;var c=a.grid_num,e=4,g="";this.calcGridMargin();if(a.grid_snap)if(50<d){c=50/a.step;var f=this.toFixed(a.step/.5)}else c=d/a.step,f=this.toFixed(a.step/(d/100));else f=this.toFixed(100/c);4<c&&(e=3);7<c&&(e=2);14<c&&(e=1);28<c&&(e=0);
+for(d=0;d<c+1;d++){var k=e;var h=this.toFixed(f*d);100<h&&(h=100);this.coords.big[d]=h;var m=(h-f*(d-1))/(k+1);for(b=1;b<=k&&0!==h;b++){var n=this.toFixed(h-m*b);g+='<span class="irs-grid-pol small" style="left: '+n+'%"></span>'}g+='<span class="irs-grid-pol" style="left: '+h+'%"></span>';b=this.convertToValue(h);b=a.values.length?a.p_values[b]:this._prettify(b);g+='<span class="irs-grid-text js-grid-text-'+d+'" style="left: '+h+'%">'+b+"</span>"}this.coords.big_num=Math.ceil(c+1);this.$cache.cont.addClass("irs-with-grid");
+this.$cache.grid.html(g);this.cacheGridLabels()}},cacheGridLabels:function(){var a,b=this.coords.big_num;for(a=0;a<b;a++){var d=this.$cache.grid.find(".js-grid-text-"+a);this.$cache.grid_labels.push(d)}this.calcGridLabels()},calcGridLabels:function(){var a;var b=[];var d=[],c=this.coords.big_num;for(a=0;a<c;a++)this.coords.big_w[a]=this.$cache.grid_labels[a].outerWidth(!1),this.coords.big_p[a]=this.toFixed(this.coords.big_w[a]/this.coords.w_rs*100),this.coords.big_x[a]=this.toFixed(this.coords.big_p[a]/
+2),b[a]=this.toFixed(this.coords.big[a]-this.coords.big_x[a]),d[a]=this.toFixed(b[a]+this.coords.big_p[a]);this.options.force_edges&&(b[0]<-this.coords.grid_gap&&(b[0]=-this.coords.grid_gap,d[0]=this.toFixed(b[0]+this.coords.big_p[0]),this.coords.big_x[0]=this.coords.grid_gap),d[c-1]>100+this.coords.grid_gap&&(d[c-1]=100+this.coords.grid_gap,b[c-1]=this.toFixed(d[c-1]-this.coords.big_p[c-1]),this.coords.big_x[c-1]=this.toFixed(this.coords.big_p[c-1]-this.coords.grid_gap)));this.calcGridCollision(2,
+b,d);this.calcGridCollision(4,b,d);for(a=0;a<c;a++)b=this.$cache.grid_labels[a][0],this.coords.big_x[a]!==Number.POSITIVE_INFINITY&&(b.style.marginLeft=-this.coords.big_x[a]+"%")},calcGridCollision:function(a,b,d){var c,e=this.coords.big_num;for(c=0;c<e;c+=a){var g=c+a/2;if(g>=e)break;var f=this.$cache.grid_labels[g][0];f.style.visibility=d[c]<=b[g]?"visible":"hidden"}},calcGridMargin:function(){this.options.grid_margin&&(this.coords.w_rs=this.$cache.rs.outerWidth(!1),this.coords.w_rs&&(this.coords.w_handle=
+"single"===this.options.type?this.$cache.s_single.outerWidth(!1):this.$cache.s_from.outerWidth(!1),this.coords.p_handle=this.toFixed(this.coords.w_handle/this.coords.w_rs*100),this.coords.grid_gap=this.toFixed(this.coords.p_handle/2-.1),this.$cache.grid[0].style.width=this.toFixed(100-this.coords.p_handle)+"%",this.$cache.grid[0].style.left=this.coords.grid_gap+"%"))},update:function(a){this.input&&(this.is_update=!0,this.options.from=this.result.from,this.options.to=this.result.to,this.update_check.from=
+this.result.from,this.update_check.to=this.result.to,this.options=f.extend(this.options,a),this.validate(),this.updateResult(a),this.toggleInput(),this.remove(),this.init(!0))},reset:function(){this.input&&(this.updateResult(),this.update())},destroy:function(){this.input&&(this.toggleInput(),this.$cache.input.prop("readonly",!1),f.data(this.input,"ionRangeSlider",null),this.remove(),this.options=this.input=null)}};f.fn.ionRangeSlider=function(a){return this.each(function(){f.data(this,"ionRangeSlider")||
+f.data(this,"ionRangeSlider",new q(this,a,t++))})};(function(){for(var a=0,b=["ms","moz","webkit","o"],d=0;d<b.length&&!k.requestAnimationFrame;++d)k.requestAnimationFrame=k[b[d]+"RequestAnimationFrame"],k.cancelAnimationFrame=k[b[d]+"CancelAnimationFrame"]||k[b[d]+"CancelRequestAnimationFrame"];k.requestAnimationFrame||(k.requestAnimationFrame=function(b,d){var c=(new Date).getTime(),e=Math.max(0,16-(c-a)),f=k.setTimeout(function(){b(c+e)},e);a=c+e;return f});k.cancelAnimationFrame||(k.cancelAnimationFrame=
+function(a){clearTimeout(a)})})()});
+

web/js/search.js

@@ -0,0 +1,353 @@
+const SIZE = 20;
+let mimeMap = [];
+let tree;
+
+let searchBar = document.getElementById("searchBar");
+let pathBar = document.getElementById("pathBar");
+let scroll_id = null;
+let docCount = 0;
+let coolingDown = false;
+let searchBusy = true;
+let selectedIndices = [];
+
+jQuery["jsonPost"] = function (url, data) {
+    return jQuery.ajax({
+        url: url,
+        type: "post",
+        data: JSON.stringify(data),
+        contentType: "application/json"
+    }).fail(err => {
+        console.log(err);
+    });
+};
+
+function toggleSearchBar() {
+    searchDebounced();
+}
+
+$.jsonPost("i").then(resp => {
+    resp["indices"].forEach(idx => {
+        $("#indices").append($("<option>")
+            .attr("value", idx.id)
+            .attr("selected", true)
+            .append(idx.name)
+        );
+        selectedIndices.push(idx.id);
+    });
+});
+
+$.jsonPost("es", {
+    aggs: {
+        mimeTypes: {
+            terms: {
+                field: "mime",
+                size: 10000
+            }
+        }
+    },
+    size: 0,
+}).then(resp => {
+    resp["aggregations"]["mimeTypes"]["buckets"].forEach(bucket => {
+        let tmp = bucket["key"].split("/");
+        let category = tmp[0];
+        let mime = tmp[1];
+
+        let category_exists = false;
+
+        let child = {
+            "id": bucket["key"],
+            "text": `${mime} (${bucket["doc_count"]})`
+        };
+
+        mimeMap.forEach(node => {
+            if (node.text === category) {
+                node.children.push(child);
+                category_exists = true;
+            }
+        });
+
+        if (!category_exists) {
+            mimeMap.push({"text": category, children: [child]});
+        }
+    });
+    mimeMap.push({"text": "All", "id": "any"});
+
+    tree = new InspireTree({
+        selection: {
+            mode: 'checkbox'
+        },
+        data: mimeMap
+    });
+    new InspireTreeDOM(tree, {
+        target: '.tree'
+    });
+    tree.on("node.click", function (event, node, handler) {
+        event.preventTreeDefault();
+
+        if (node.id === "any") {
+            if (!node.itree.state.checked) {
+                tree.deselect();
+            }
+        } else {
+            tree.node("any").deselect();
+        }
+
+        handler();
+        searchDebounced();
+    });
+    tree.select();
+    tree.node("any").deselect();
+    searchBusy = false;
+});
+
+new autoComplete({
+    selector: '#pathBar',
+    minChars: 1,
+    delay: 75,
+    renderItem: function (item) {
+        return '<div class="autocomplete-suggestion" data-val="' + item + '">' + item + '</div>';
+    },
+    source: async function (term, suggest) {
+        term = term.toLowerCase();
+
+        const choices = await getPathChoices();
+
+        let matches = [];
+        for (let i = 0; i < choices.length; i++) {
+            if (~choices[i].toLowerCase().indexOf(term)) {
+                matches.push(choices[i]);
+            }
+        }
+        suggest(matches);
+    },
+    onSelect: function () {
+        searchDebounced();
+    }
+});
+
+function insertHits(resultContainer, hits) {
+    for (let i = 0; i < hits.length; i++) {
+        resultContainer.appendChild(createDocCard(hits[i]));
+        docCount++;
+    }
+}
+
+window.addEventListener("scroll", function () {
+    if (!coolingDown && !searchBusy) {
+        let threshold = 400;
+
+        if ((window.innerHeight + window.scrollY) >= document.body.offsetHeight - threshold) {
+            coolingDown = true;
+            doScroll();
+        }
+    }
+});
+
+function doScroll() {
+    $.get("scroll", {scroll_id: scroll_id})
+        .then(searchResult => {
+            let searchResults = document.getElementById("searchResults");
+            let hits = searchResult["hits"]["hits"];
+
+            //Page indicator
+            let pageIndicator = makePageIndicator(searchResult);
+            searchResults.appendChild(pageIndicator);
+
+            //Result container
+            let resultContainer = makeResultContainer();
+            searchResults.appendChild(resultContainer);
+
+            insertHits(resultContainer, hits);
+
+            if (hits.length === SIZE) {
+                coolingDown = false;
+            }
+        })
+        .fail(() => {
+            window.location.reload();
+        })
+}
+
+function getSelectedMimeTypes() {
+    let mimeTypes = [];
+
+    let selected = tree.selected();
+
+    for (let i = 0; i < selected.length; i++) {
+
+        if (selected[i].id === "any") {
+            return ["any"]
+        }
+
+        //Only get children
+        if (selected[i].text.indexOf("(") !== -1) {
+            mimeTypes.push(selected[i].id);
+        }
+    }
+
+    return mimeTypes
+}
+
+function search() {
+    if (searchBusy) {
+        return;
+    }
+    searchBusy = true;
+    //Clear old search results
+    let searchResults = document.getElementById("searchResults");
+    while (searchResults.firstChild) {
+        searchResults.removeChild(searchResults.firstChild);
+    }
+
+    let query = searchBar.value;
+    let condition = $("#barToggle").prop("checked") ? "must" : "should";
+    let filters = [
+        {range: {size: {gte: size_min, lte: size_max}}},
+        {terms: {index: selectedIndices}}
+    ];
+
+    let path = pathBar.value.replace(/\/$/, "").toLowerCase(); //remove trailing slashes
+    if (path !== "") {
+        filters.push([{term: {path: path}}])
+    }
+    let mimeTypes = getSelectedMimeTypes();
+    if (!mimeTypes.includes("any")) {
+        filters.push([{terms: {"mime": mimeTypes}}]);
+    }
+
+    $.jsonPost("es?scroll=1", {
+        "_source": {
+            excludes: ["content"]
+        },
+        query: {
+            bool: {
+                [condition]: {
+                    multi_match: {
+                        query: query,
+                        type: "most_fields",
+                        fields: [
+                            "name^8", "name.nGram^3", "content^3",
+                            "content.nGram",
+                            "album^8", "artist^8", "title^8", "genre^2", "album_artist^8",
+                            "font_name^6"
+                        ],
+                        operator: "and"
+                    }
+                },
+                filter: filters
+            }
+        },
+        sort: [
+            "_score"
+        ],
+        highlight: {
+            pre_tags: ["<mark>"],
+            post_tags: ["</mark>"],
+            fields: {
+                content: {},
+                name: {},
+                "name.nGram": {},
+                // font_name: {},
+            }
+        },
+        aggs: {
+            total_size: {"sum": {"field": "size"}}
+        },
+        size: SIZE,
+    }).then(searchResult => {
+        scroll_id = searchResult["_scroll_id"];
+
+        //Search stats
+        searchResults.appendChild(makeStatsCard(searchResult));
+
+        //Autocomplete
+        if (searchResult.hasOwnProperty("suggest") && searchResult["suggest"].hasOwnProperty("path")) {
+            pathAutoComplete = [];
+            for (let i = 0; i < searchResult["suggest"]["path"][0]["options"].length; i++) {
+                pathAutoComplete.push(searchResult["suggest"]["path"][0]["options"][i].text)
+            }
+        }
+
+        //Setup page
+        let resultContainer = makeResultContainer();
+        searchResults.appendChild(resultContainer);
+
+        docCount = 0;
+        insertHits(resultContainer, searchResult["hits"]["hits"]);
+
+        searchBusy = false;
+    });
+}
+
+let pathAutoComplete = [];
+let size_min = 0;
+let size_max = 10000000000000;
+
+let searchDebounced = _.debounce(function () {
+    coolingDown = false;
+    search()
+}, 500);
+searchBar.addEventListener("keyup", searchDebounced);
+document.getElementById("pathBar").addEventListener("keyup", searchDebounced);
+
+//Size slider
+$("#sizeSlider").ionRangeSlider({
+    type: "double",
+    grid: false,
+    force_edges: true,
+    min: 0,
+    max: 3684.03149864,
+    from: 0,
+    to: 3684.03149864,
+    min_interval: 5,
+    drag_interval: true,
+    prettify: function (num) {
+
+        if (num === 0) {
+            return "0 B"
+        } else if (num >= 3684) {
+            return humanFileSize(num * num * num) + "+";
+        }
+
+        return humanFileSize(num * num * num)
+    },
+    onChange: function (e) {
+        size_min = (e.from * e.from * e.from);
+        size_max = (e.to * e.to * e.to);
+
+        if (e.to >= 3684) {
+            size_max = 10000000000000;
+        }
+
+        searchDebounced();
+    }
+});
+
+function updateIndices() {
+    let selected = $('#indices').find('option:selected');
+    selectedIndices = [];
+    $(selected).each(function () {
+        selectedIndices.push($(this).val());
+    });
+
+    searchDebounced();
+}
+
+document.getElementById("indices").addEventListener("change", updateIndices);
+updateIndices();
+
+//Suggest
+function getPathChoices() {
+    return new Promise(getPaths => {
+
+        let xhttp = new XMLHttpRequest();
+        xhttp.onreadystatechange = function () {
+            if (this.readyState === 4 && this.status === 200) {
+                getPaths(JSON.parse(xhttp.responseText))
+            }
+        };
+        xhttp.open("GET", "suggest?prefix=" + pathBar.value, true);
+        xhttp.send();
+    });
+}
+

web/js/util.js

@@ -0,0 +1,56 @@
+/**
+ * https://stackoverflow.com/questions/10420352
+ */
+function humanFileSize(bytes) {
+    if (bytes === 0) {
+        return "? B"
+    }
+
+    let thresh = 1000;
+    if (Math.abs(bytes) < thresh) {
+        return bytes + ' B';
+    }
+    let units = ['k', 'M', 'G', 'T', 'P', 'E', 'Z', 'Y'];
+    let u = -1;
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.abs(bytes) >= thresh && u < units.length - 1);
+
+    return bytes.toFixed(1) + units[u];
+}
+
+/**
+ * https://stackoverflow.com/questions/6312993
+ */
+function humanTime(sec_num) {
+    sec_num = Math.floor(sec_num);
+    let hours = Math.floor(sec_num / 3600);
+    let minutes = Math.floor((sec_num - (hours * 3600)) / 60);
+    let seconds = sec_num - (hours * 3600) - (minutes * 60);
+
+    if (hours < 10) {
+        hours = "0" + hours;
+    }
+    if (minutes < 10) {
+        minutes = "0" + minutes;
+    }
+    if (seconds < 10) {
+        seconds = "0" + seconds;
+    }
+    return hours + ":" + minutes + ":" + seconds;
+}
+
+function debounce(func, wait) {
+    let timeout;
+    return function() {
+        let context = this, args = arguments;
+        let later = function() {
+            timeout = null;
+            func.apply(context, args);
+        };
+        clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        func.apply(context, args);
+    };
+}

web/search.html

@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="utf-8">
+    <title>sist2 - Search</title>
+    <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no'/>
+
+    <link href="css" rel="stylesheet" type="text/css">
+</head>
+<body>
+
+<nav class="navbar navbar-expand-lg navbar-light">
+    <a class="navbar-brand" href="/">sist2</a>
+    <span class="tagline">Lightning-fast file system indexer and search tool </span>
+</nav>
+
+<div class="container">
+    <div class="card">
+        <div class="card-body">
+            <div class="form-group">
+                <input id="pathBar" type="search" class="form-control" placeholder="Filter path">
+            </div>
+            <div class="input-group">
+                <div class="input-group-prepend">
+                    <div class="input-group-text">
+                        <span onclick="document.getElementById('barToggle').click()">Must match&nbsp</span>
+                        <input title="Toggle between 'Should' and 'Must' match mode" type="checkbox" id="barToggle"
+                               onclick="toggleSearchBar()" checked>
+                    </div>
+                </div>
+                <input id="searchBar" type="search" class="form-control" placeholder="Search">
+
+            </div>
+
+            <input title="File size" id="sizeSlider" name="size">
+
+            <div class="row">
+                <div class="col">
+                    <label for="indices">Search in indices</label>
+                    <select class="custom-select" id="indices" multiple size="6"></select>
+                </div>
+
+                <div class="col">
+                    <label>Mime types</label>
+
+                    <div class="tree"></div>
+                </div>
+            </div>
+        </div>
+    </div>
+
+    <div id="searchResults"></div>
+</div>
+
+<script src="js" type="text/javascript"></script>
+</body>
+</html>