@elixir-playground/git 0.0.0-stage → 1.0.0

package/licenses/wasi-libc-2e6fb9d8ee0c/musl-fts-COPYING

@@ -0,0 +1,26 @@
+Copyright (c) 1989, 1993
+   The Regents of the University of California.  All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+3. Neither the name of the University nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

package/licenses/zlib-1.3.2/LICENSE

@@ -0,0 +1,22 @@
+Copyright notice:
+
+ (C) 1995-2026 Jean-loup Gailly and Mark Adler
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely, subject to the following restrictions:
+
+  1. The origin of this software must not be misrepresented; you must not
+     claim that you wrote the original software. If you use this software
+     in a product, an acknowledgment in the product documentation would be
+     appreciated but is not required.
+  2. Altered source versions must be plainly marked as such, and must not be
+     misrepresented as being the original software.
+  3. This notice may not be removed or altered from any source distribution.
+
+  Jean-loup Gailly        Mark Adler
+  jloup@gzip.org          madler@alumni.caltech.edu

package/package.json

@@ -1,6 +1,46 @@
 {
   "name": "@elixir-playground/git",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.0",
+  "license": "(Apache-2.0 OR Apache-2.0 WITH LLVM-exception OR MIT) AND BSD-2-Clause AND BSD-3-Clause AND GPL-2.0-only AND MIT AND Zlib",
+  "files": [
+    "NOTICE.md",
+    "fs",
+    "git.wasm",
+    "index.d.ts",
+    "index.js",
+    "licenses",
+    "source"
+  ],
+  "type": "module",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "peerDependencies": {
+    "@elixir-playground/runtime": "^1.0.0"
+  },
+  "playground": {
+    "abi": {
+      "wasi": 1,
+      "processes": 1
+    },
+    "programs": {
+      "git": {
+        "module": "git.wasm"
+      }
+    },
+    "fs": {
+      "format": 3,
+      "root": "/usr/libexec/git-core",
+      "manifest": "fs/manifest.json",
+      "bundles": "fs/bundles/",
+      "count": 1,
+      "version": "14ca27ec67928487"
+    }
+  },
+  "playgroundDigest": "a1d07507e15e"
+}

package/source/git/README.md

@@ -0,0 +1,17 @@
+# git 2.56.0: corresponding source
+
+The source of the WebAssembly build of git 2.56.0 in this package,
+under GPL-2.0-only (its COPYING): what the build is made from, as the
+playground's repository has it.
+
+- `git-2.56.0.tar.xz`
+- `tools/git/build.py`
+- `tools/git/config.mak`
+- `tools/git/patches`
+- `tools/wasi-compat`
+- `zlib-1.3.2.tar.gz`
+
+The build applies `patches/` to the release, links `wasi-compat/` (MIT)
+and wasi-libc, and compiles with the wasi-sdk Docker image its script
+names by digest. From a checkout of the playground's repository, with
+these files in their places there, `python3 -I tools/git/build.py` builds it.

package/source/git/tools/git/build.py

@@ -0,0 +1,168 @@
+"""git built to WebAssembly (wasm32-wasip1): the git CLI itself, for the
+shell and the nodes (docs/git.md).
+
+    python3 -I tools/git/build.py   # → target/git/git.wasm
+
+git's release with patches/ applied, and zlib, built with wasi-sdk in
+Docker (backend/Dockerfile's wasi-sdk). WASI preview 1 lacks processes, users,
+modes, terminals and sockets: tools/wasi-compat/ (every C tool's) declares what
+git asks of them and stubs it (stubs.c), its processes the playground's
+host's (the `processes` imports, app/src/runtime/processes.ts:
+run-command.c spawns instead of forking), and config.mak turns off the
+rest.
+"""
+
+import hashlib
+import importlib.util
+import os
+import shutil
+import subprocess
+import tarfile
+import urllib.request
+
+# The repository (this file is tools/NAME/build.py).
+ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+HERE = os.path.dirname(os.path.abspath(__file__))
+# What WASI lacks, for every C tool (wasi-compat.h, stubs.c).
+COMPAT = os.path.join(ROOT, "tools", "wasi-compat")
+OUT = os.path.join(ROOT, "target", "git")
+DOCKER = os.environ.get("DOCKER", "sudo -n docker").split()
+# wasi-sdk 33 (clang 23), as the backend's NIF toolchain (backend/Dockerfile).
+IMAGE = "ghcr.io/webassembly/wasi-sdk@sha256:52595085a0ffbaf574d8d678a9aa81305f0b3af81c639291f15bc7713e42848e"
+GIT = ("2.56.0", "https://mirrors.edge.kernel.org/pub/software/scm/git/git-2.56.0.tar.xz",
+       "26c56c296b38c0695b26fa95f475f1d01704d2d38e73465ca30b0b2f5dc789d3")
+ZLIB = ("1.3.2", "https://github.com/madler/zlib/releases/download/v1.3.2/zlib-1.3.2.tar.gz",
+        "bb329a0a2cd0274d05519d61c667c062e06990d72e125ee2dfa8de64f0119d16")
+# git's Makefile reads `uname` before config.mak: on the command line, so
+# that the host's (Linux) settings stay out.
+UNAME = "uname_S=WASI uname_M=wasm32 uname_O=WASI uname_R=1 uname_V=1"
+
+
+def fetch(source, sha256, path):
+    if not os.path.exists(path):
+        urllib.request.urlretrieve(source, path + ".part")
+        with open(path + ".part", "rb") as f:
+            got = hashlib.sha256(f.read()).hexdigest()
+        if got != sha256:
+            raise SystemExit(f"{source}: sha256 {got}, not {sha256}")
+        os.rename(path + ".part", path)
+
+
+def stamp():
+    """What the build is made from: the image, the sources, our files."""
+    hashed = hashlib.sha256(f"{IMAGE}\0{GIT[2]}\0{ZLIB[2]}\0".encode())
+    for top in (HERE, COMPAT):
+        for directory, _, names in sorted(os.walk(top)):
+            for name in sorted(names):
+                if name.endswith(".py"):
+                    continue
+                path = os.path.join(directory, name)
+                with open(path, "rb") as f:
+                    hashed.update(os.path.relpath(path, ROOT).encode() + b"\0" + f.read())
+    return hashed.hexdigest()
+
+
+def licensed(git_archive, zlib_archive):
+    """target/git/licenses (tools/licenses.py) and target/git/source: git is
+    GPL-2.0, so its source goes with it: the releases, the patches and the
+    build's files, zlib's too (git links it)."""
+    spec = importlib.util.spec_from_file_location("licenses", os.path.join(ROOT, "tools", "licenses.py"))
+    licenses = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(licenses)
+    if licenses.current(OUT, stamp()):
+        return
+    fetch(GIT[1], GIT[2], git_archive)
+    fetch(ZLIB[1], ZLIB[2], zlib_archive)
+    zlib = licenses.Inventory().add("zlib", ZLIB[0], "Zlib", "https://zlib.net",
+                                    licenses.archive_texts(zlib_archive, f"zlib-{ZLIB[0]}", ["LICENSE"]))
+    sources = {os.path.basename(git_archive): git_archive, os.path.basename(zlib_archive): zlib_archive,
+               "tools/git/build.py": os.path.join(HERE, "build.py"),
+               "tools/git/config.mak": os.path.join(HERE, "config.mak"),
+               "tools/git/patches": os.path.join(HERE, "patches"), "tools/wasi-compat": COMPAT}
+    inventory = licenses.c_tool(OUT, "git", GIT[0], "GPL-2.0-only", "https://git-scm.com", git_archive,
+                                ["COPYING", "LGPL-2.1"], sources, "tools/git/build.py", [zlib])
+    licenses.finish(inventory, OUT, stamp())
+
+
+def unpack(archive, name, into):
+    shutil.rmtree(into, ignore_errors=True)
+    with tarfile.open(archive) as tar:
+        tar.extractall(OUT, filter="data")
+    os.rename(os.path.join(OUT, name), into)
+
+
+# git's commands that are shell scripts (its SCRIPT_SH and SCRIPT_LIB), which
+# the playground's sh runs from git's exec path.
+SCRIPTS = [
+    "git-difftool--helper", "git-filter-branch", "git-merge-octopus", "git-merge-one-file",
+    "git-merge-resolve", "git-mergetool", "git-quiltimport", "git-request-pull", "git-submodule",
+    "git-web--browse", "git-mergetool--lib", "git-sh-i18n", "git-sh-setup",
+]
+
+
+def main():
+    os.makedirs(OUT, exist_ok=True)
+    built = os.path.join(OUT, "stamp")
+    git_archive = os.path.join(OUT, f"git-{GIT[0]}.tar.xz")
+    zlib_archive = os.path.join(OUT, f"zlib-{ZLIB[0]}.tar.gz")
+    if os.path.exists(os.path.join(OUT, "git.wasm")) and os.path.exists(built):
+        with open(built) as f:
+            if f.read() == stamp():
+                return licensed(git_archive, zlib_archive)
+    fetch(GIT[1], GIT[2], git_archive)
+    fetch(ZLIB[1], ZLIB[2], zlib_archive)
+    src = os.path.join(OUT, "src")
+    zlib = os.path.join(OUT, "zlib-src")
+    unpack(git_archive, f"git-{GIT[0]}", src)
+    for name in sorted(os.listdir(os.path.join(HERE, "patches"))):
+        subprocess.run(["patch", "-p1", "-s", "-d", src, "-i", os.path.join(HERE, "patches", name)],
+                       check=True)
+    unpack(zlib_archive, f"zlib-{ZLIB[0]}", zlib)
+    shutil.copy(os.path.join(HERE, "config.mak"), os.path.join(src, "config.mak"))
+    wasi = os.path.join(OUT, "wasi")
+    shutil.rmtree(wasi, ignore_errors=True)
+    shutil.copytree(COMPAT, wasi)
+    cc = "/opt/wasi-sdk/bin/clang --target=wasm32-wasip1 --sysroot=/opt/wasi-sdk/share/wasi-sysroot"
+    script = (
+        # zlib's configure runs what it builds: its files by hand instead.
+        "cd /zlib-src\n"
+        "mkdir -p /zlib/include /zlib/lib\n"
+        f"for c in adler32 compress crc32 deflate gzclose gzlib gzread gzwrite infback inffast "
+        f"inflate inftrees trees uncompr zutil; do {cc} -Oz -DHAVE_UNISTD_H -DHAVE_STDARG_H -c $c.c -o $c.o; done\n"
+        "/opt/wasi-sdk/bin/llvm-ar rcs /zlib/lib/libz.a *.o\n"
+        "cp zlib.h zconf.h /zlib/include/\n"
+        "cd /src\n"
+        # test-tool, GIT-BUILD-OPTIONS and templates/blt: for git's own tests
+        # (app/test/git).
+        f"make -s -j$(nproc) {UNAME} git {' '.join(SCRIPTS)} t/helper/test-tool GIT-BUILD-OPTIONS >/dev/null\n"
+        "make -s -C templates >/dev/null\n"
+        f"chown -R {os.getuid()}:{os.getgid()} /src /zlib-src /zlib /wasi\n"
+    )
+    zlib_out = os.path.join(OUT, "zlib")
+    os.makedirs(zlib_out, exist_ok=True)
+    subprocess.run(DOCKER + [
+        "run", "--rm", "-v", f"{src}:/src", "-v", f"{zlib}:/zlib-src", "-v", f"{zlib_out}:/zlib",
+        "-v", f"{wasi}:/wasi", IMAGE, "sh", "-ec", script,
+    ], check=True)
+    shutil.copy(os.path.join(src, "git"), os.path.join(OUT, "git.wasm"))
+    shutil.copy(os.path.join(src, "t", "helper", "test-tool"), os.path.join(OUT, "test-tool.wasm"))
+    # The scripts, for the site's /usr/libexec/git-core (runtime/build.py).
+    libexec = os.path.join(OUT, "libexec")
+    shutil.rmtree(libexec, ignore_errors=True)
+    os.makedirs(libexec)
+    for name in SCRIPTS:
+        shutil.copy(os.path.join(src, name), os.path.join(libexec, name))
+    # The build's paths, as the tests on the host see them (not Docker's /src).
+    options = os.path.join(src, "GIT-BUILD-OPTIONS")
+    with open(options) as f:
+        text = f.read().replace("='/src", f"='{src}")
+    with open(options, "w") as f:
+        f.write(text)
+    with open(built, "w") as f:
+        f.write(stamp())
+    licensed(git_archive, zlib_archive)
+    print(f"{OUT}/git.wasm: {os.path.getsize(os.path.join(OUT, 'git.wasm')) / 1e6:.1f} MB")
+
+
+if __name__ == "__main__":
+    main()

package/source/git/tools/git/config.mak

@@ -0,0 +1,42 @@
+# git's build for wasm32-wasip1 (tools/git/build.py copies this into the source
+# as config.mak). WASI preview 1 has no processes, threads, users, modes,
+# terminals or sockets: what git would ask of them, tools/wasi-compat/ declares and
+# stubs; what has a compat fallback in git (regex, mmap, poll) uses it.
+CC = /opt/wasi-sdk/bin/clang --target=wasm32-wasip1 --sysroot=/opt/wasi-sdk/share/wasi-sysroot
+AR = /opt/wasi-sdk/bin/llvm-ar
+CFLAGS = -Oz -Wno-macro-redefined -I/zlib/include -I/wasi/include -include /wasi/include/wasi-compat.h \
+	-Dchmod=wasi_chmod -Dfchmod=wasi_fchmod \
+	-D_WASI_EMULATED_SIGNAL -D_WASI_EMULATED_PROCESS_CLOCKS -D_WASI_EMULATED_GETPID -D_WASI_EMULATED_MMAN
+# A stack of 1 MiB (wasm-ld's default is 64 KiB): history walks recurse.
+# The stack pointer exported: the host switches it between git and an
+# async's coroutine (stubs.c wasi_async_start).
+LDFLAGS = -L/zlib/lib -Wl,-z,stack-size=1048576 -Wl,--export=__stack_pointer \
+	-lwasi-emulated-signal -lwasi-emulated-process-clocks -lwasi-emulated-getpid -lwasi-emulated-mman
+LIB_OBJS += /wasi/stubs.o
+
+prefix = /usr
+NO_RUST = YesPlease
+NO_PTHREADS = YesPlease
+NO_CURL = YesPlease
+NO_EXPAT = YesPlease
+NO_GETTEXT = YesPlease
+NO_ICONV = YesPlease
+NO_OPENSSL = YesPlease
+NO_PERL = YesPlease
+NO_PYTHON = YesPlease
+NO_TCLTK = YesPlease
+NO_REGEX = YesPlease
+NO_MMAP = YesPlease
+NO_UNIX_SOCKETS = YesPlease
+NO_IPV6 = YesPlease
+NO_SETITIMER = YesPlease
+NO_STRUCT_ITIMERVAL = YesPlease
+NO_INITGROUPS = YesPlease
+NO_GECOS_IN_PWENT = YesPlease
+NO_TRUSTABLE_FILEMODE = YesPlease
+NO_SYMLINK_HEAD = YesPlease
+NO_INSTALL_HARDLINKS = YesPlease
+NO_POSIX_GOODIES = UnfortunatelyYes
+SKIP_DASHED_BUILT_INS = YesPlease
+CSPRNG_METHOD = getentropy
+HAVE_DEV_TTY =

package/source/git/tools/git/patches/0001-wasi-spawn.patch

@@ -0,0 +1,76 @@
+--- a/run-command.c
++++ b/run-command.c
+@@ -745,7 +745,7 @@
+ 	if (cmd->odb_to_close)
+ 		odb_close(cmd->odb_to_close);
+ 
+-#ifndef GIT_WINDOWS_NATIVE
++#if !defined(GIT_WINDOWS_NATIVE) && !defined(__wasi__)
+ {
+ 	int notify_pipe[2];
+ 	int null_fd = -1;
+@@ -908,6 +908,64 @@
+ }
+ end_of_spawn:
+ 
++#elif defined(__wasi__)
++/*
++ * WASI has no fork: the host starts the child with three of our
++ * descriptors as its standard streams (wasi_spawn), as Windows does.
++ */
++{
++	int fhin = 0, fhout = 1, fherr = 2;
++	const char **sargv = cmd->args.v;
++	struct strvec nargv = STRVEC_INIT;
++	char **childenv;
++
++	if (cmd->no_stdin)
++		fhin = open("/dev/null", O_RDWR);
++	else if (need_in)
++		fhin = dup(fdin[0]);
++	else if (cmd->in)
++		fhin = dup(cmd->in);
++
++	if (cmd->no_stderr)
++		fherr = open("/dev/null", O_RDWR);
++	else if (need_err)
++		fherr = dup(fderr[1]);
++	else if (cmd->err > 2)
++		fherr = dup(cmd->err);
++
++	if (cmd->no_stdout)
++		fhout = open("/dev/null", O_RDWR);
++	else if (cmd->stdout_to_stderr)
++		fhout = dup(fherr);
++	else if (need_out)
++		fhout = dup(fdout[1]);
++	else if (cmd->out > 1)
++		fhout = dup(cmd->out);
++
++	if (cmd->git_cmd)
++		cmd->args.v = prepare_git_cmd(&nargv, sargv);
++	else if (cmd->use_shell)
++		cmd->args.v = prepare_shell_cmd(&nargv, sargv);
++
++	trace_argv_printf(cmd->args.v, "trace: start_command:");
++	childenv = prep_childenv(cmd->env.v);
++	cmd->pid = wasi_spawn(cmd->args.v, childenv, cmd->dir, fhin, fhout, fherr);
++	failed_errno = errno;
++	if (cmd->pid < 0 && (!cmd->silent_exec_failure || errno != ENOENT))
++		error_errno("cannot run %s", cmd->args.v[0]);
++	if (cmd->clean_on_exit && cmd->pid >= 0)
++		mark_child_for_cleanup(cmd->pid, cmd);
++
++	free(childenv);
++	strvec_clear(&nargv);
++	cmd->args.v = sargv;
++	if (fhin != 0)
++		close(fhin);
++	if (fhout != 1)
++		close(fhout);
++	if (fherr != 2)
++		close(fherr);
++}
+ #else
+ {
+ 	int fhin = 0, fhout = 1, fherr = 2;

package/source/git/tools/git/patches/0002-wasi-async.patch

@@ -0,0 +1,124 @@
+diff --git a/run-command.c b/run-command.c
+index 99e18d2..37d909b 100644
+--- a/run-command.c
++++ b/run-command.c
+@@ -1192,6 +1192,48 @@ int git_atexit(void (*handler)(void))
+ }
+ #define atexit git_atexit
+ 
++#ifdef __wasi__
++/*
++ * WASI: an async function runs beside git as a coroutine of the host's,
++ * on a stack of its own (wasi_async_start, tools/wasi-compat/stubs.c). It shares
++ * git's descriptors and memory as a thread would; the host says which
++ * runs, and ends one that dies.
++ */
++int in_async(void)
++{
++	return wasi_async_current() != NULL;
++}
++
++static void NORETURN async_exit(int code)
++{
++	wasi_async_exit(code);
++}
++
++static NORETURN void die_async(const char *err, va_list params)
++{
++	report_fn die_message_fn = get_die_message_routine();
++
++	die_message_fn(err, params);
++
++	if (in_async()) {
++		struct async *async = wasi_async_current();
++		if (async->proc_in >= 0)
++			close(async->proc_in);
++		if (async->proc_out >= 0)
++			close(async->proc_out);
++		async_exit(128);
++	}
++
++	exit(128);
++}
++
++/* What the host's coroutine runs: the exit status, as a forked one's. */
++__attribute__((export_name("wasi_run_async")))
++int wasi_run_async(struct async *async)
++{
++	return !!async->proc(async->proc_in, async->proc_out, async->data);
++}
++#else
+ static int process_is_async;
+ int in_async(void)
+ {
+@@ -1202,6 +1244,7 @@ static void NORETURN async_exit(int code)
+ {
+ 	exit(code);
+ }
++#endif
+ 
+ #endif
+ 
+@@ -1260,7 +1303,22 @@ int start_async(struct async *async)
+ 	else
+ 		proc_out = -1;
+ 
+-#ifdef NO_PTHREADS
++#if defined(__wasi__)
++	{
++		static int started;
++		if (!started) {
++			started = 1;
++			set_die_routine(die_async);
++		}
++	}
++	async->proc_in = proc_in;
++	async->proc_out = proc_out;
++	async->pid = wasi_async_start(async, &async->stack);
++	if (async->pid < 0) {
++		error_errno("cannot start async");
++		goto error;
++	}
++#elif defined(NO_PTHREADS)
+ 	/* Flush stdio before fork() to avoid cloning buffers */
+ 	fflush(NULL);
+ 
+@@ -1339,6 +1397,10 @@ int finish_async(struct async *async)
+ 	int ret = wait_or_whine(async->pid, "child process", 0);
+ 
+ 	invalidate_lstat_cache();
++#ifdef __wasi__
++	free(async->stack);
++	async->stack = NULL;
++#endif
+ 
+ 	return ret;
+ #else
+@@ -1354,7 +1416,7 @@ int finish_async(struct async *async)
+ 
+ int async_with_fork(void)
+ {
+-#ifdef NO_PTHREADS
++#if defined(NO_PTHREADS) && !defined(__wasi__)
+ 	return 1;
+ #else
+ 	return 0;
+diff --git a/run-command.h b/run-command.h
+index c2fad4f..754109c 100644
+--- a/run-command.h
++++ b/run-command.h
+@@ -363,7 +363,13 @@ struct async {
+ 	 */
+ 	int in;		/* caller writes here and closes it */
+ 	int out;	/* caller reads from here and closes it */
+-#ifdef NO_PTHREADS
++#if defined(__wasi__)
++	/* A coroutine of the host's beside git's (wasi_async_start). */
++	pid_t pid;
++	int proc_in;
++	int proc_out;
++	void *stack;
++#elif defined(NO_PTHREADS)
+ 	pid_t pid;
+ #else
+ 	pthread_t tid;

package/source/git/tools/wasi-compat/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2026 The Elixir Playground Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+USE OR OTHER DEALINGS IN THE SOFTWARE.