utn-mcp 0.1.0 → 0.2.0

package/build/shared/documents/office.js

@@ -0,0 +1,118 @@
+import { deTexto, fragmentar } from "./index.js";
+import { leerEntrada, listarZip } from "./zip.js";
+/** Tope por entrada descomprimida: un XML de texto de más que esto es un zip malicioso o no es un documento. */
+const MAX_ENTRADA = 50 * 1024 * 1024;
+const MARCAS = {
+    docx: "word/document.xml",
+    pptx: "ppt/presentation.xml",
+    xlsx: "xl/workbook.xml",
+};
+/** Mira la lista de entradas del zip sin descomprimir nada. */
+export function formatoOffice(bytes) {
+    const nombres = new Set(listarZip(bytes).map((e) => e.nombre));
+    return Object.keys(MARCAS).find((f) => nombres.has(MARCAS[f])) ?? null;
+}
+export function abrirOffice(bytes, formato) {
+    const texto = new TextDecoder();
+    const zip = Object.fromEntries(listarZip(bytes)
+        .filter((e) => necesaria(formato, e.nombre))
+        .map((e) => [e.nombre, texto.decode(leerEntrada(bytes, e, MAX_ENTRADA))]));
+    switch (formato) {
+        case "docx":
+            return deTexto("docx", "fragmento", fragmentar(xmlTexto(leer(zip, "word/document.xml"), "w")).map((texto) => ({ texto })));
+        case "pptx":
+            return deTexto("pptx", "diapositiva", Object.keys(zip)
+                .filter((p) => /^ppt\/slides\/slide\d+\.xml$/.test(p))
+                .sort((a, b) => numero(a) - numero(b))
+                .map((p) => ({ texto: xmlTexto(leer(zip, p), "a") || "(diapositiva sin texto)" })));
+        case "xlsx":
+            return deTexto("xlsx", "fragmento", hojas(zip).flatMap(({ nombre, texto }) => {
+                const partes = fragmentar(texto);
+                return partes.map((t, i) => ({
+                    titulo: partes.length > 1 ? `hoja "${nombre}" (${i + 1}/${partes.length})` : `hoja "${nombre}"`,
+                    texto: t,
+                }));
+            }));
+    }
+}
+function necesaria(formato, nombre) {
+    switch (formato) {
+        case "docx":
+            return nombre === "word/document.xml";
+        case "pptx":
+            return /^ppt\/slides\/slide\d+\.xml$/.test(nombre);
+        case "xlsx":
+            return nombre === "xl/workbook.xml" || nombre === "xl/sharedStrings.xml" ||
+                nombre === "xl/_rels/workbook.xml.rels" || nombre.startsWith("xl/worksheets/");
+    }
+}
+const leer = (zip, ruta) => zip[ruta] ?? "";
+const numero = (ruta) => Number(ruta.match(/(\d+)\.xml$/)?.[1]);
+const ENTIDADES = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+const decodificar = (s) => s.replace(/&(#x[0-9a-f]+|#\d+|\w+);/gi, (m, e) => e[0] !== "#" ? (ENTIDADES[e] ?? m) : String.fromCodePoint(e[1].toLowerCase() === "x" ? parseInt(e.slice(2), 16) : Number(e.slice(1))));
+/**
+ * Texto de un XML de Word (`w`) o PowerPoint (`a`), recorriendo los tags en orden: texto de los nodos
+ * de texto, salto de línea al cerrar un párrafo, y las tablas como filas con celdas separadas por " | ".
+ */
+function xmlTexto(xml, ns) {
+    let out = "";
+    let enTexto = false;
+    let enCelda = 0;
+    for (const [, cierre, tag, , autocierre, chars] of xml.matchAll(/<(\/?)([\w:]+)((?:[^>"]|"[^"]*")*?)(\/?)>|([^<]+)/g)) {
+        if (chars !== undefined) {
+            if (enTexto)
+                out += decodificar(chars);
+        }
+        else if (tag === `${ns}:t`) {
+            enTexto = !cierre && !autocierre;
+        }
+        else if (tag === `${ns}:tc` && !autocierre) {
+            enCelda += cierre ? -1 : 1;
+            if (cierre)
+                out += " | ";
+        }
+        else if (tag === `${ns}:tr` && cierre) {
+            out += "\n";
+        }
+        else if (tag === `${ns}:p` && cierre) {
+            out += enCelda ? " " : "\n";
+        }
+        else if (tag === `${ns}:tab`) {
+            out += " ";
+        }
+        else if (tag === `${ns}:br`) {
+            out += enCelda ? " " : "\n";
+        }
+    }
+    return out
+        .split("\n")
+        .map((l) => l.replace(/\s+/g, " ").replace(/\s*\|\s*$/, "").trim())
+        .filter((l, i, todas) => l !== "|" && (l !== "" || todas[i - 1] !== ""))
+        .join("\n")
+        .trim();
+}
+/** Cada hoja como filas de celdas separadas por tabs, en el orden del libro. */
+function hojas(zip) {
+    const compartidas = [...leer(zip, "xl/sharedStrings.xml").matchAll(/<si>([\s\S]*?)<\/si>/g)].map((m) => decodificar([...m[1].matchAll(/<t[^>]*>([\s\S]*?)<\/t>/g)].map((t) => t[1]).join("")));
+    const rels = Object.fromEntries([...leer(zip, "xl/_rels/workbook.xml.rels").matchAll(/<Relationship [^>]*>/g)].map(([tag]) => [
+        tag.match(/Id="([^"]+)"/)?.[1],
+        tag.match(/Target="([^"]+)"/)?.[1],
+    ]));
+    return [...leer(zip, "xl/workbook.xml").matchAll(/<sheet [^>]*>/g)].map(([tag]) => {
+        const nombre = decodificar(tag.match(/name="([^"]*)"/)?.[1] ?? "");
+        const destino = rels[tag.match(/r:id="([^"]+)"/)?.[1] ?? ""] ?? "";
+        const ruta = destino.replace(/^\//, "").replace(/^(xl\/)?/, "xl/");
+        const filas = [...leer(zip, ruta).matchAll(/<row[^>]*>([\s\S]*?)<\/row>/g)].map((fila) => [...fila[1].matchAll(/<c ([^>]*?)(?:\/>|>([\s\S]*?)<\/c>)/g)]
+            .map(([, attrs, cuerpo = ""]) => {
+            const tipo = attrs.match(/\bt="(\w+)"/)?.[1];
+            if (tipo === "s")
+                return compartidas[Number(cuerpo.match(/<v>(\d+)<\/v>/)?.[1])] ?? "";
+            if (tipo === "inlineStr")
+                return decodificar(cuerpo.match(/<t[^>]*>([\s\S]*?)<\/t>/)?.[1] ?? "");
+            return decodificar(cuerpo.match(/<v>([\s\S]*?)<\/v>/)?.[1] ?? "");
+        })
+            .join("\t")
+            .replace(/\t+$/, ""));
+        return { nombre, texto: filas.filter(Boolean).join("\n") || "(hoja vacía)" };
+    });
+}

package/build/shared/documents/pdf.js

@@ -0,0 +1,164 @@
+import { pngGris } from "./png.js";
+/**
+ * pdf.js no es una dependencia: scripts/vendor-pdfjs.mjs copia a vendor/pdfjs los pocos archivos que
+ * usamos. Está a la misma altura desde src/ y desde build/, así que la ruta sirve en dev y publicado.
+ */
+const VENDOR = new URL("../../../vendor/pdfjs/", import.meta.url);
+/** Al arrancar en Node, pdf.js avisa que le falta canvas para renderizar. No renderizamos: son ruido en el log. */
+const AVISOS_DE_CANVAS = /@napi-rs\/canvas|Cannot polyfill/;
+let pdfjsCargado;
+/** Se carga recién al primer PDF: son 3 MB que el servidor no necesita para arrancar. */
+function pdfjs() {
+    pdfjsCargado ??= (async () => {
+        const warn = console.warn;
+        console.warn = (...args) => {
+            if (!AVISOS_DE_CANVAS.test(String(args[0])))
+                warn(...args);
+        };
+        try {
+            return (await import(new URL("pdf.mjs", VENDOR).href));
+        }
+        finally {
+            console.warn = warn;
+        }
+    })();
+    return pdfjsCargado;
+}
+/** Menos texto que esto en una página la tratamos como escaneada. */
+const MIN_TEXTO = 20;
+/** Lado largo de la imagen de una página: el tamaño que Claude procesa sin reescalar. */
+const LADO_IMAGEN = 1568;
+/** Muestras por eje y por píxel al reducir la imagen; suaviza los bordes y mejora la lectura. */
+const MUESTREO = 2;
+export async function abrirPdf(bytes) {
+    const lib = await pdfjs();
+    const carga = lib.getDocument({
+        data: bytes,
+        verbosity: 0,
+        isOffscreenCanvasSupported: false,
+        // Directo a los decodificadores JS de vendor/pdfjs/wasm: en Node los .wasm no cargan igual.
+        useWasm: false,
+        wasmUrl: new URL("wasm/", VENDOR).href,
+    });
+    const pdf = await carga.promise;
+    return {
+        formato: "pdf",
+        unidad: "página",
+        total: pdf.numPages,
+        parte: async (n) => leerPagina(lib, await pdf.getPage(n)),
+        cerrar: () => carga.destroy(),
+    };
+}
+async function leerPagina(lib, pagina) {
+    const contenido = await pagina.getTextContent();
+    let texto = "";
+    for (const item of contenido.items) {
+        if (!("str" in item))
+            continue;
+        texto += item.str + (item.hasEOL ? "\n" : "");
+    }
+    texto = texto.replace(/[ \t]+/g, " ").replace(/ ?\n ?/g, "\n").trim();
+    if (texto.length >= MIN_TEXTO)
+        return { texto };
+    const escaneo = await rasterizarImagenes(lib, pagina);
+    if (escaneo)
+        return { titulo: "escaneada, como imagen", imagen: escaneo, mimeType: "image/png" };
+    return { texto: texto || "(página sin texto)" };
+}
+/**
+ * Reconstruye la página dibujando solo sus imágenes, con la posición y rotación con que el PDF
+ * las ubica. Una página escaneada es eso: una imagen. Así se evita un renderizador completo, que
+ * en Node necesita un canvas nativo.
+ */
+async function rasterizarImagenes({ OPS, Util }, pagina) {
+    const base = pagina.getViewport({ scale: 1 });
+    const vista = pagina.getViewport({ scale: LADO_IMAGEN / Math.max(base.width, base.height) });
+    const ancho = Math.round(vista.width);
+    const alto = Math.round(vista.height);
+    const lienzo = new Uint8Array(ancho * alto).fill(255);
+    const ops = await pagina.getOperatorList();
+    let ctm = [1, 0, 0, 1, 0, 0];
+    const pila = [];
+    let pintadas = 0;
+    for (let i = 0; i < ops.fnArray.length; i++) {
+        const args = ops.argsArray[i];
+        switch (ops.fnArray[i]) {
+            case OPS.save:
+                pila.push(ctm);
+                break;
+            case OPS.restore:
+                ctm = pila.pop() ?? ctm;
+                break;
+            case OPS.transform:
+                ctm = Util.transform(ctm, args);
+                break;
+            case OPS.paintFormXObjectBegin:
+                pila.push(ctm);
+                if (args[0])
+                    ctm = Util.transform(ctm, args[0]);
+                break;
+            case OPS.paintFormXObjectEnd:
+                ctm = pila.pop() ?? ctm;
+                break;
+            case OPS.paintImageXObject:
+            case OPS.paintInlineImageXObject: {
+                const imagen = typeof args[0] === "string" ? await new Promise((res) => pagina.objs.get(args[0], res)) : args[0];
+                if (imagen?.data && pintar(lienzo, ancho, alto, imagen, Util.transform(vista.transform, ctm))) {
+                    pintadas++;
+                }
+                break;
+            }
+        }
+    }
+    return pintadas ? pngGris(ancho, alto, lienzo) : null;
+}
+/**
+ * Pinta una imagen en el lienzo. La imagen ocupa el cuadrado unitario transformado por `m`; por cada
+ * píxel del lienzo se busca el píxel de origen con la transformación inversa, así cualquier rotación
+ * o espejado sale bien sin casos especiales.
+ */
+function pintar(lienzo, ancho, alto, img, m) {
+    const [a, b, c, d, e, f] = m;
+    const det = a * d - b * c;
+    if (!det)
+        return false;
+    const inv = [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+    const xs = [e, a + e, c + e, a + c + e];
+    const ys = [f, b + f, d + f, b + d + f];
+    const x0 = Math.max(0, Math.floor(Math.min(...xs)));
+    const x1 = Math.min(ancho, Math.ceil(Math.max(...xs)));
+    const y0 = Math.max(0, Math.floor(Math.min(...ys)));
+    const y1 = Math.min(alto, Math.ceil(Math.max(...ys)));
+    const { width: w, height: h, kind } = img;
+    const data = img.data;
+    const bytesPorFila = (w + 7) >> 3;
+    const canales = kind === 2 ? 3 : 4;
+    const gris = (col, fila) => {
+        if (kind === 1)
+            return ((data[fila * bytesPorFila + (col >> 3)] >> (7 - (col & 7))) & 1) * 255;
+        const i = (fila * w + col) * canales;
+        return data[i] * 0.3 + data[i + 1] * 0.59 + data[i + 2] * 0.11;
+    };
+    for (let y = y0; y < y1; y++) {
+        for (let x = x0; x < x1; x++) {
+            let suma = 0;
+            let n = 0;
+            for (let sy = 0; sy < MUESTREO; sy++) {
+                for (let sx = 0; sx < MUESTREO; sx++) {
+                    const px = x + (sx + 0.5) / MUESTREO;
+                    const py = y + (sy + 0.5) / MUESTREO;
+                    const u = inv[0] * px + inv[2] * py + inv[4];
+                    const v = inv[1] * px + inv[3] * py + inv[5];
+                    if (u < 0 || u >= 1 || v < 0 || v >= 1)
+                        continue;
+                    // En el espacio de la imagen v crece hacia arriba; las filas de datos, hacia abajo.
+                    suma += gris(Math.floor(u * w), Math.floor((1 - v) * h));
+                    n++;
+                }
+            }
+            if (n)
+                lienzo[y * ancho + x] = suma / n;
+        }
+    }
+    return true;
+}

package/build/shared/documents/png.js

@@ -0,0 +1,51 @@
+import { deflateSync } from "node:zlib";
+/** PNG en escala de grises, 8 bits. Alcanza para páginas escaneadas y evita una dependencia de imágenes. */
+export function pngGris(ancho, alto, pixeles) {
+    // Cada fila va precedida por el byte de filtro (0 = sin filtro).
+    const filas = new Uint8Array(alto * (ancho + 1));
+    for (let y = 0; y < alto; y++)
+        filas.set(pixeles.subarray(y * ancho, (y + 1) * ancho), y * (ancho + 1) + 1);
+    const ihdr = new Uint8Array(13);
+    const vista = new DataView(ihdr.buffer);
+    vista.setUint32(0, ancho);
+    vista.setUint32(4, alto);
+    ihdr[8] = 8; // bits por canal
+    ihdr[9] = 0; // escala de grises
+    return concat([
+        new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]),
+        chunk("IHDR", ihdr),
+        chunk("IDAT", deflateSync(filas, { level: 6 })),
+        chunk("IEND", new Uint8Array()),
+    ]);
+}
+function chunk(tipo, datos) {
+    const out = new Uint8Array(12 + datos.length);
+    const vista = new DataView(out.buffer);
+    vista.setUint32(0, datos.length);
+    for (let i = 0; i < 4; i++)
+        out[4 + i] = tipo.charCodeAt(i);
+    out.set(datos, 8);
+    vista.setUint32(8 + datos.length, crc32(out.subarray(4, 8 + datos.length)));
+    return out;
+}
+const TABLA_CRC = Int32Array.from({ length: 256 }, (_, n) => {
+    let c = n;
+    for (let k = 0; k < 8; k++)
+        c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+    return c;
+});
+function crc32(bytes) {
+    let c = -1;
+    for (const b of bytes)
+        c = TABLA_CRC[(c ^ b) & 0xff] ^ (c >>> 8);
+    return ~c >>> 0;
+}
+function concat(partes) {
+    const out = new Uint8Array(partes.reduce((n, p) => n + p.length, 0));
+    let i = 0;
+    for (const p of partes) {
+        out.set(p, i);
+        i += p.length;
+    }
+    return out;
+}

package/build/shared/documents/zip.js

@@ -0,0 +1,72 @@
+import { inflateRawSync } from "node:zlib";
+const FIN_DIRECTORIO = 0x06054b50;
+const DIRECTORIO = 0x02014b50;
+const ENCABEZADO_LOCAL = 0x04034b50;
+const SIN_COMPRESION = 0;
+const DEFLATE = 8;
+class ZipInvalido extends Error {
+    constructor(detalle) {
+        super(`El archivo no es un zip válido: ${detalle}.`);
+        this.name = "ZipInvalido";
+    }
+}
+export function listarZip(bytes) {
+    const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    // El fin del directorio está al final, seguido de un comentario opcional de hasta 64 KB.
+    let fin = -1;
+    for (let i = bytes.length - 22; i >= Math.max(0, bytes.length - 22 - 0xffff); i--) {
+        if (vista.getUint32(i, true) === FIN_DIRECTORIO) {
+            fin = i;
+            break;
+        }
+    }
+    if (fin < 0)
+        throw new ZipInvalido("no tiene índice");
+    const cantidad = vista.getUint16(fin + 10, true);
+    let p = vista.getUint32(fin + 16, true);
+    if (cantidad === 0xffff || p === 0xffffffff)
+        throw new ZipInvalido("usa zip64");
+    const entradas = [];
+    const nombres = new TextDecoder();
+    for (let i = 0; i < cantidad; i++) {
+        if (p + 46 > bytes.length || vista.getUint32(p, true) !== DIRECTORIO)
+            throw new ZipInvalido("índice corrupto");
+        const largoNombre = vista.getUint16(p + 28, true);
+        entradas.push({
+            nombre: nombres.decode(bytes.subarray(p + 46, p + 46 + largoNombre)),
+            metodo: vista.getUint16(p + 10, true),
+            comprimido: vista.getUint32(p + 20, true),
+            tamanio: vista.getUint32(p + 24, true),
+            offset: vista.getUint32(p + 42, true),
+        });
+        p += 46 + largoNombre + vista.getUint16(p + 30, true) + vista.getUint16(p + 32, true);
+    }
+    return entradas;
+}
+/**
+ * Descomprime una entrada. `max` corta aunque el índice mienta sobre el tamaño: un zip chico que se
+ * infla a gigas es un ataque conocido.
+ */
+export function leerEntrada(bytes, entrada, max) {
+    if (entrada.tamanio > max)
+        throw new ZipInvalido(`"${entrada.nombre}" descomprimido pesa demasiado`);
+    const vista = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const p = entrada.offset;
+    if (vista.getUint32(p, true) !== ENCABEZADO_LOCAL)
+        throw new ZipInvalido(`falta el encabezado de "${entrada.nombre}"`);
+    const inicio = p + 30 + vista.getUint16(p + 26, true) + vista.getUint16(p + 28, true);
+    const datos = bytes.subarray(inicio, inicio + entrada.comprimido);
+    switch (entrada.metodo) {
+        case SIN_COMPRESION:
+            return datos;
+        case DEFLATE:
+            try {
+                return inflateRawSync(datos, { maxOutputLength: max });
+            }
+            catch (e) {
+                throw new ZipInvalido(`no se pudo descomprimir "${entrada.nombre}" (${e.message})`);
+            }
+        default:
+            throw new ZipInvalido(`"${entrada.nombre}" usa una compresión no soportada (${entrada.metodo})`);
+    }
+}

package/build/shared/html.js

@@ -0,0 +1,19 @@
+const ENTITIES = { nbsp: " ", amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+/** HTML de Moodle a texto plano: alcanza para que el modelo lo lea, no es un parser. */
+export function htmlToText(html) {
+    if (!html)
+        return "";
+    return html
+        .replace(/<(script|style)[\s\S]*?<\/\1>/gi, "")
+        .replace(/<br\s*\/?>|<\/(p|div|li|h\d|tr)>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&(#\d+|[a-z]+);/gi, (m, e) => e.startsWith("#") ? String.fromCodePoint(Number(e.slice(1))) : (ENTITIES[e.toLowerCase()] ?? m))
+        .replace(/[ \t ]+/g, " ")
+        .replace(/\s*\n\s*/g, "\n")
+        .trim();
+}
+/** Como htmlToText pero recortado: para índices, donde solo hace falta decidir si entrar. */
+export function htmlToSnippet(html, max = 200) {
+    const texto = htmlToText(html);
+    return texto.length > max ? `${texto.slice(0, max).trimEnd()}…` : texto;
+}

package/package.json

@@ -1,18 +1,20 @@
 {
   "name": "utn-mcp",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Este es el Model Context Protocol server NO OFICIAL de la UTN para buscar informacion o archivos en el aula virtual.",
   "main": "build/index.js",
   "bin": {
     "utn-mcp": "build/index.js"
   },
   "files": [
-    "build"
+    "build",
+    "vendor"
   ],
   "scripts": {
     "prebuild": "node -e \"require('fs').rmSync('build',{recursive:true,force:true})\"",
     "build": "tsc",
     "prepublishOnly": "npm run build",
+    "prepare": "node scripts/vendor-pdfjs.mjs",
     "start": "node build/index.js",
     "dev": "tsx src/index.ts",
     "test": "echo \"Error: no test specified\" && exit 1",
@@ -46,6 +48,7 @@
   "devDependencies": {
     "@types/express": "^5.0.6",
     "@types/node": "^26.6.4",
+    "pdfjs-dist": "^6.4.299",
     "tsx": "^4.23.15",
     "typescript": "^7.0.2"
   },

package/vendor/pdfjs/LICENSE

@@ -0,0 +1,177 @@
+
+                                 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