@daniel156161/prism 0.2.60 → 0.2.78

package/node_modules/@earendil-works/pi-tui/native/win32/build.mjs

@@ -0,0 +1,229 @@
+import { spawnSync } from "node:child_process";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const sourceFile = path.join(scriptDir, "src", "win32-console-mode.c");
+const temporaryDir = mkdtempSync(path.join(tmpdir(), "pi-tui-win32-"));
+
+const targets = [
+	{
+		arch: "x64",
+		msvcArch: "x64",
+		mingwTarget: "x86_64-w64-windows-gnu",
+		prefixedCompilers: ["x86_64-w64-mingw32-gcc", "x86_64-w64-mingw32-clang"],
+		envCompiler: "CC_X64",
+	},
+	{
+		arch: "arm64",
+		msvcArch: "arm64",
+		mingwTarget: "aarch64-w64-windows-gnu",
+		prefixedCompilers: ["aarch64-w64-mingw32-gcc", "aarch64-w64-mingw32-clang"],
+		envCompiler: "CC_ARM64",
+	},
+];
+
+function removeTemporaryDir() {
+	rmSync(temporaryDir, { recursive: true, force: true, maxRetries: 5, retryDelay: 100 });
+}
+
+process.on("exit", removeTemporaryDir);
+process.on("SIGINT", () => {
+	removeTemporaryDir();
+	process.exit(130);
+});
+
+function commandExists(command) {
+	const result = spawnSync(command, ["--version"], { stdio: "ignore" });
+	return !result.error || result.error.code !== "ENOENT";
+}
+
+function run(command, args, options = {}) {
+	const result = spawnSync(command, args, { stdio: "inherit", ...options });
+	if (result.error) throw result.error;
+	if (result.status !== 0) throw new Error(`${command} failed with exit code ${result.status ?? 1}`);
+}
+
+function quoteBatch(value) {
+	return `"${value.replaceAll('"', '""')}"`;
+}
+
+function msvcHostArch() {
+	return process.arch === "arm64" ? "arm64" : "x64";
+}
+
+function findVisualStudioDevCmd() {
+	const candidates = [];
+	const programFilesX86 = process.env["ProgramFiles(x86)"];
+	if (programFilesX86) {
+		const vswhere = path.join(programFilesX86, "Microsoft Visual Studio", "Installer", "vswhere.exe");
+		if (existsSync(vswhere)) {
+			const result = spawnSync(
+				vswhere,
+				[
+					"-latest",
+					"-products",
+					"*",
+					"-requires",
+					"Microsoft.VisualStudio.Component.VC.Tools.x86.x64",
+					"-property",
+					"installationPath",
+				],
+				{ encoding: "utf8" },
+			);
+			for (const line of result.stdout.split(/\r?\n/)) {
+				const installationPath = line.trim();
+				if (installationPath) candidates.push(path.join(installationPath, "Common7", "Tools", "VsDevCmd.bat"));
+			}
+		}
+	}
+
+	for (const base of [process.env.ProgramFiles, programFilesX86]) {
+		if (!base) continue;
+		for (const edition of ["BuildTools", "Community", "Professional", "Enterprise"]) {
+			candidates.push(path.join(base, "Microsoft Visual Studio", "2022", edition, "Common7", "Tools", "VsDevCmd.bat"));
+		}
+	}
+
+	return candidates.find((candidate) => existsSync(candidate));
+}
+
+function canUseMsvc(vsDevCmd) {
+	const probeDir = path.join(temporaryDir, "msvc-probe");
+	mkdirSync(probeDir, { recursive: true });
+	const batchFile = path.join(probeDir, "probe.cmd");
+	writeFileSync(
+		batchFile,
+		[
+			"@echo off",
+			`call ${quoteBatch(vsDevCmd)} -no_logo -arch=x64 -host_arch=${msvcHostArch()} >nul`,
+			"if errorlevel 1 exit /b %errorlevel%",
+			"where cl.exe >nul 2>nul",
+		].join("\r\n"),
+	);
+	const result = spawnSync("cmd.exe", ["/d", "/s", "/c", batchFile], { cwd: probeDir, stdio: "ignore" });
+	return !result.error && result.status === 0;
+}
+
+function resolveMingwCompiler(target) {
+	const envCompiler = process.env[target.envCompiler];
+	if (envCompiler) return { command: envCompiler, useTargetFlag: false };
+	if (process.env.CC) return { command: process.env.CC, useTargetFlag: true };
+	for (const command of target.prefixedCompilers) {
+		if (commandExists(command)) return { command, useTargetFlag: false };
+	}
+	if (commandExists("clang")) return { command: "clang", useTargetFlag: true };
+	return undefined;
+}
+
+function installOutput(temporaryOutput, target) {
+	const outputDir = path.join(scriptDir, "prebuilds", `win32-${target.arch}`);
+	mkdirSync(outputDir, { recursive: true });
+	const output = path.join(outputDir, "win32-console-mode.node");
+	copyFileSync(temporaryOutput, output);
+	chmodSync(output, 0o755);
+	console.log(`Built ${path.relative(process.cwd(), output)}`);
+}
+
+function buildWithMsvc(target, vsDevCmd) {
+	const buildDir = path.join(temporaryDir, `msvc-${target.arch}`);
+	const temporaryOutput = path.join(buildDir, "win32-console-mode.node");
+	mkdirSync(buildDir, { recursive: true });
+
+	const batchFile = path.join(buildDir, "build.cmd");
+	writeFileSync(
+		batchFile,
+		[
+			"@echo off",
+			`call ${quoteBatch(vsDevCmd)} -no_logo -arch=${target.msvcArch} -host_arch=${msvcHostArch()}`,
+			"if errorlevel 1 exit /b %errorlevel%",
+			[
+				"cl",
+				"/nologo",
+				"/TC",
+				"/std:c11",
+				"/W4",
+				"/O1",
+				"/GS-",
+				"/LD",
+				`/Fe:${quoteBatch(temporaryOutput)}`,
+				quoteBatch(sourceFile),
+				"/link",
+				"/NOENTRY",
+				"/NODEFAULTLIB",
+				"kernel32.lib",
+				"/OPT:REF",
+				"/OPT:ICF",
+			].join(" "),
+			"if errorlevel 1 exit /b %errorlevel%",
+		].join("\r\n"),
+	);
+
+	run("cmd.exe", ["/d", "/s", "/c", batchFile], { cwd: buildDir });
+	installOutput(temporaryOutput, target);
+}
+
+function buildWithMingw(target) {
+	const compiler = resolveMingwCompiler(target);
+	if (!compiler) {
+		throw new Error(
+			`No Windows cross-compiler found for ${target.arch}. Install Microsoft C++ Build Tools on Windows, or set ${target.envCompiler} to a MinGW-compatible compiler.`,
+		);
+	}
+
+	const buildDir = path.join(temporaryDir, `mingw-${target.arch}`);
+	const temporaryOutput = path.join(buildDir, "win32-console-mode.node");
+	mkdirSync(buildDir, { recursive: true });
+
+	const args = [
+		...(compiler.useTargetFlag ? [`--target=${target.mingwTarget}`] : []),
+		"-std=c11",
+		"-Wall",
+		"-Wextra",
+		"-Oz",
+		"-shared",
+		"-nostdlib",
+		"-Wl,--no-entry",
+		"-Wl,--strip-all",
+		sourceFile,
+		"-lkernel32",
+		"-o",
+		temporaryOutput,
+	];
+
+	run(compiler.command, args, { cwd: buildDir });
+	installOutput(temporaryOutput, target);
+}
+
+if (process.argv.includes("--help") || process.argv.includes("-h")) {
+	console.log(`Usage: npm --prefix packages/tui run build:native:win32
+
+Builds win32-x64 and win32-arm64 native prebuilds.
+
+Environment:
+  PI_TUI_WIN32_TOOLCHAIN=msvc|mingw
+  CC_X64=/path/to/x86_64-w64-mingw32-gcc
+  CC_ARM64=/path/to/aarch64-w64-mingw32-gcc
+  CC=/path/to/clang`);
+	process.exit(0);
+}
+
+const requestedToolchain = process.env.PI_TUI_WIN32_TOOLCHAIN;
+if (requestedToolchain && requestedToolchain !== "msvc" && requestedToolchain !== "mingw") {
+	throw new Error("PI_TUI_WIN32_TOOLCHAIN must be either 'msvc' or 'mingw'");
+}
+
+const vsDevCmd = findVisualStudioDevCmd();
+const hasMsvc = vsDevCmd ? canUseMsvc(vsDevCmd) : false;
+const toolchain = requestedToolchain ?? (process.platform === "win32" && vsDevCmd ? "msvc" : "mingw");
+
+if (toolchain === "msvc") {
+	if (!vsDevCmd || !hasMsvc) {
+		throw new Error("Microsoft C++ Build Tools not found. Install the Visual Studio C++ workload or set PI_TUI_WIN32_TOOLCHAIN=mingw.");
+	}
+	for (const target of targets) buildWithMsvc(target, vsDevCmd);
+} else {
+	for (const target of targets) buildWithMingw(target);
+}

package/node_modules/@earendil-works/pi-tui/native/win32/src/win32-console-mode.c

@@ -0,0 +1,119 @@
+#include <windows.h>
+
+#ifndef ENABLE_VIRTUAL_TERMINAL_INPUT
+#define ENABLE_VIRTUAL_TERMINAL_INPUT 0x0200
+#endif
+
+#define NAPI_AUTO_LENGTH ((unsigned long long)-1)
+#define KEY_PRESSED_MASK 0x8000
+
+typedef void* napi_env;
+typedef void* napi_value;
+typedef void* napi_callback_info;
+typedef napi_value (__cdecl *napi_callback)(napi_env, napi_callback_info);
+typedef int (__cdecl *napi_create_function_fn)(napi_env, const char*, unsigned long long, napi_callback, void*, napi_value*);
+typedef int (__cdecl *napi_set_named_property_fn)(napi_env, napi_value, const char*, napi_value);
+typedef int (__cdecl *napi_get_boolean_fn)(napi_env, int, napi_value*);
+typedef int (__cdecl *napi_get_cb_info_fn)(napi_env, napi_callback_info, unsigned long long*, napi_value*, napi_value*, void**);
+typedef int (__cdecl *napi_get_value_string_utf8_fn)(napi_env, napi_value, char*, unsigned long long, unsigned long long*);
+typedef SHORT (WINAPI *get_async_key_state_fn)(int);
+
+static void* node_symbol(const char* name) {
+    HMODULE module = GetModuleHandleA(0);
+    void* proc = module ? (void*)GetProcAddress(module, name) : 0;
+    if (proc) return proc;
+
+    module = GetModuleHandleA("node.dll");
+    return module ? (void*)GetProcAddress(module, name) : 0;
+}
+
+static int string_equals(const char* left, const char* right) {
+    while (*left && *right && *left == *right) {
+        left++;
+        right++;
+    }
+    return *left == 0 && *right == 0;
+}
+
+static get_async_key_state_fn get_async_key_state_symbol(void) {
+    static int loaded = 0;
+    static get_async_key_state_fn get_async_key_state = 0;
+
+    if (!loaded) {
+        HMODULE module = GetModuleHandleA("user32.dll");
+        if (!module) module = LoadLibraryA("user32.dll");
+        get_async_key_state = module ? (get_async_key_state_fn)GetProcAddress(module, "GetAsyncKeyState") : 0;
+        loaded = 1;
+    }
+
+    return get_async_key_state;
+}
+
+static int is_key_pressed(int virtual_key) {
+    get_async_key_state_fn get_async_key_state = get_async_key_state_symbol();
+    return get_async_key_state && (((unsigned short)get_async_key_state(virtual_key)) & KEY_PRESSED_MASK) != 0;
+}
+
+static int is_modifier_name_pressed(const char* name) {
+    if (string_equals(name, "shift")) return is_key_pressed(VK_SHIFT) || is_key_pressed(VK_LSHIFT) || is_key_pressed(VK_RSHIFT);
+    if (string_equals(name, "control")) return is_key_pressed(VK_CONTROL) || is_key_pressed(VK_LCONTROL) || is_key_pressed(VK_RCONTROL);
+    if (string_equals(name, "option") || string_equals(name, "alt")) return is_key_pressed(VK_MENU) || is_key_pressed(VK_LMENU) || is_key_pressed(VK_RMENU);
+    if (string_equals(name, "command") || string_equals(name, "super") || string_equals(name, "win")) return is_key_pressed(VK_LWIN) || is_key_pressed(VK_RWIN);
+    return 0;
+}
+
+static napi_value __cdecl enable_virtual_terminal_input(napi_env env, napi_callback_info info) {
+    (void)info;
+
+    HANDLE handle = GetStdHandle(STD_INPUT_HANDLE);
+    DWORD mode = 0;
+    int enabled = handle != INVALID_HANDLE_VALUE &&
+        GetConsoleMode(handle, &mode) &&
+        SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_INPUT);
+
+    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
+    napi_value result = 0;
+    if (napi_get_boolean) napi_get_boolean(env, enabled, &result);
+    return result;
+}
+
+static napi_value __cdecl is_modifier_pressed(napi_env env, napi_callback_info info) {
+    napi_get_cb_info_fn napi_get_cb_info = (napi_get_cb_info_fn)node_symbol("napi_get_cb_info");
+    napi_get_value_string_utf8_fn napi_get_value_string_utf8 = (napi_get_value_string_utf8_fn)node_symbol("napi_get_value_string_utf8");
+    napi_get_boolean_fn napi_get_boolean = (napi_get_boolean_fn)node_symbol("napi_get_boolean");
+
+    int pressed = 0;
+    if (napi_get_cb_info && napi_get_value_string_utf8) {
+        unsigned long long argc = 1;
+        napi_value args[1] = {0};
+        if (napi_get_cb_info(env, info, &argc, args, 0, 0) == 0 && argc >= 1 && args[0]) {
+            char name[16] = {0};
+            unsigned long long copied = 0;
+            if (napi_get_value_string_utf8(env, args[0], name, sizeof(name), &copied) == 0) {
+                pressed = is_modifier_name_pressed(name);
+            }
+        }
+    }
+
+    napi_value result = 0;
+    if (napi_get_boolean) napi_get_boolean(env, pressed, &result);
+    return result;
+}
+
+static void set_function_export(napi_env env, napi_value exports, const char* name, napi_callback callback) {
+    napi_create_function_fn napi_create_function = (napi_create_function_fn)node_symbol("napi_create_function");
+    napi_set_named_property_fn napi_set_named_property = (napi_set_named_property_fn)node_symbol("napi_set_named_property");
+
+    napi_value fn = 0;
+    if (napi_create_function &&
+        napi_set_named_property &&
+        napi_create_function(env, name, NAPI_AUTO_LENGTH, callback, 0, &fn) == 0) {
+        napi_set_named_property(env, exports, name, fn);
+    }
+}
+
+__declspec(dllexport) napi_value __cdecl napi_register_module_v1(napi_env env, napi_value exports) {
+    set_function_export(env, exports, "enableVirtualTerminalInput", enable_virtual_terminal_input);
+    set_function_export(env, exports, "isModifierPressed", is_modifier_pressed);
+    return exports;
+}

package/node_modules/@earendil-works/pi-tui/package.json

@@ -1,19 +1,27 @@
 {
 	"name": "@earendil-works/pi-tui",
-	"version": "0.82.1",
+	"version": "0.84.0",
 	"description": "Terminal User Interface library with differential rendering for efficient text-based applications",
 	"type": "module",
 	"main": "dist/index.js",
 	"scripts": {
 		"clean": "shx rm -rf dist",
 		"build": "tsgo -p tsconfig.build.json",
+		"build:native:darwin": "native/darwin/build.sh",
+		"build:native:win32": "node native/win32/build.mjs",
 		"test": "node --test --test-reporter=dot --test-reporter-destination=stdout test/*.test.ts",
 		"prepublishOnly": "npm run clean && npm run build"
 	},
 	"files": [
 		"dist/**/*",
 		"native/win32/prebuilds/**/*.node",
+		"native/win32/src/**/*.c",
+		"native/win32/build.mjs",
+		"native/win32/README.md",
 		"native/darwin/prebuilds/**/*.node",
+		"native/darwin/src/**/*.c",
+		"native/darwin/build.sh",
+		"native/darwin/README.md",
 		"README.md"
 	],
 	"keywords": [

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Wed, 08 Jul 2026 06:47:45 GMT
+ * Last updated: Mon, 27 Jul 2026 17:32:10 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

package/node_modules/@types/node/crypto.d.ts

@@ -1185,7 +1185,7 @@ declare module "node:crypto" {
      * and it will be impossible to extract the private key from the returned object.
      * @since v11.6.0
      */
-    function createPublicKey(key: PublicKeyInput | RawPublicKeyInput | JsonWebKeyInput | BinaryLike): KeyObject;
+    function createPublicKey(key: PublicKeyInput | RawPublicKeyInput | JsonWebKeyInput | KeyLike): KeyObject;
     /**
      * Creates and returns a new key object containing a secret key for symmetric
      * encryption or `Hmac`.

package/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "26.1.1",
+    "version": "26.1.2",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~8.3.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "a59119b073061829bc67a5bf6bc2b8ecb0a5a6196058e3c73172a00440f4e16d",
+    "typesPublisherContentHash": "359a01a58cecf5a30fb7b7a7b10c4f5c332339421ef5cbc9932fc492f472a5b4",
     "typeScriptVersion": "5.6"
 }

package/node_modules/grok-mermaid/CHANGELOG.md

@@ -0,0 +1,40 @@
+# Changelog
+
+## [Unreleased]
+
+## [0.2.2] - 2026-08-04
+
+### Removed
+
+- Removed the `NOTICE` file. Upstream ships none, so Apache-2.0 §4(d) never applied; keeping one only pushed a propagation obligation onto redistributors. Attribution now lives in `README.md` and `LICENSE`.
+
+## [0.2.1] - 2026-08-01
+
+### Added
+
+- Added npm trusted publishing with build provenance. Releases are now built, signed and published by CI from a matching `v*` tag.
+
+### Fixed
+
+- Fixed leading and trailing empty rows around rendered diagrams.
+
+## [0.2.0] - 2026-07-28
+
+### Breaking Changes
+
+- Changed `render()` to return natural-width art with a reported `width`; removed `maxWidth` and automatic source fallback. Callers can use `sourceBox()` when needed.
+
+### Added
+
+- Added `diagramKind()` and advisory parse warnings so callers can distinguish unsupported diagrams from malformed or partially rendered input.
+- Added best-effort recovery for strict grammars by dropping and reporting one unreadable final line.
+
+## [0.1.1] - 2026-07-28
+
+## [0.1.0] - 2026-07-28
+
+Initial public release.
+
+### Added
+
+- Added Unicode terminal rendering for flowchart, state, class, ER, and sequence diagrams with semantic styled spans and ANSI themes.

package/node_modules/grok-mermaid/LICENSE

@@ -0,0 +1,205 @@
+Copyright 2023-2026 SpaceXAI
+Copyright 2026 Alexey Zaytsev
+
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.