Add decaf webui

webui/node_modules/sourcemap-codec/dist/sourcemap-codec.es.js

@@ -0,0 +1,124 @@
+var charToInteger = {};
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i = 0; i < chars.length; i++) {
+    charToInteger[chars.charCodeAt(i)] = i;
+}
+function decode(mappings) {
+    var decoded = [];
+    var line = [];
+    var segment = [
+        0,
+        0,
+        0,
+        0,
+        0,
+    ];
+    var j = 0;
+    for (var i = 0, shift = 0, value = 0; i < mappings.length; i++) {
+        var c = mappings.charCodeAt(i);
+        if (c === 44) { // ","
+            segmentify(line, segment, j);
+            j = 0;
+        }
+        else if (c === 59) { // ";"
+            segmentify(line, segment, j);
+            j = 0;
+            decoded.push(line);
+            line = [];
+            segment[0] = 0;
+        }
+        else {
+            var integer = charToInteger[c];
+            if (integer === undefined) {
+                throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
+            }
+            var hasContinuationBit = integer & 32;
+            integer &= 31;
+            value += integer << shift;
+            if (hasContinuationBit) {
+                shift += 5;
+            }
+            else {
+                var shouldNegate = value & 1;
+                value >>>= 1;
+                if (shouldNegate) {
+                    value = value === 0 ? -0x80000000 : -value;
+                }
+                segment[j] += value;
+                j++;
+                value = shift = 0; // reset
+            }
+        }
+    }
+    segmentify(line, segment, j);
+    decoded.push(line);
+    return decoded;
+}
+function segmentify(line, segment, j) {
+    // This looks ugly, but we're creating specialized arrays with a specific
+    // length. This is much faster than creating a new array (which v8 expands to
+    // a capacity of 17 after pushing the first item), or slicing out a subarray
+    // (which is slow). Length 4 is assumed to be the most frequent, followed by
+    // length 5 (since not everything will have an associated name), followed by
+    // length 1 (it's probably rare for a source substring to not have an
+    // associated segment data).
+    if (j === 4)
+        line.push([segment[0], segment[1], segment[2], segment[3]]);
+    else if (j === 5)
+        line.push([segment[0], segment[1], segment[2], segment[3], segment[4]]);
+    else if (j === 1)
+        line.push([segment[0]]);
+}
+function encode(decoded) {
+    var sourceFileIndex = 0; // second field
+    var sourceCodeLine = 0; // third field
+    var sourceCodeColumn = 0; // fourth field
+    var nameIndex = 0; // fifth field
+    var mappings = '';
+    for (var i = 0; i < decoded.length; i++) {
+        var line = decoded[i];
+        if (i > 0)
+            mappings += ';';
+        if (line.length === 0)
+            continue;
+        var generatedCodeColumn = 0; // first field
+        var lineMappings = [];
+        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
+            var segment = line_1[_i];
+            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
+            generatedCodeColumn = segment[0];
+            if (segment.length > 1) {
+                segmentMappings +=
+                    encodeInteger(segment[1] - sourceFileIndex) +
+                        encodeInteger(segment[2] - sourceCodeLine) +
+                        encodeInteger(segment[3] - sourceCodeColumn);
+                sourceFileIndex = segment[1];
+                sourceCodeLine = segment[2];
+                sourceCodeColumn = segment[3];
+            }
+            if (segment.length === 5) {
+                segmentMappings += encodeInteger(segment[4] - nameIndex);
+                nameIndex = segment[4];
+            }
+            lineMappings.push(segmentMappings);
+        }
+        mappings += lineMappings.join(',');
+    }
+    return mappings;
+}
+function encodeInteger(num) {
+    var result = '';
+    num = num < 0 ? (-num << 1) | 1 : num << 1;
+    do {
+        var clamped = num & 31;
+        num >>>= 5;
+        if (num > 0) {
+            clamped |= 32;
+        }
+        result += chars[clamped];
+    } while (num > 0);
+    return result;
+}
+
+export { decode, encode };
+//# sourceMappingURL=sourcemap-codec.es.js.map

webui/node_modules/sourcemap-codec/dist/sourcemap-codec.umd.js

@@ -0,0 +1,135 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.sourcemapCodec = {}));
+}(this, function (exports) { 'use strict';
+
+	var charToInteger = {};
+	var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+	for (var i = 0; i < chars.length; i++) {
+	    charToInteger[chars.charCodeAt(i)] = i;
+	}
+	function decode(mappings) {
+	    var decoded = [];
+	    var line = [];
+	    var segment = [
+	        0,
+	        0,
+	        0,
+	        0,
+	        0,
+	    ];
+	    var j = 0;
+	    for (var i = 0, shift = 0, value = 0; i < mappings.length; i++) {
+	        var c = mappings.charCodeAt(i);
+	        if (c === 44) { // ","
+	            segmentify(line, segment, j);
+	            j = 0;
+	        }
+	        else if (c === 59) { // ";"
+	            segmentify(line, segment, j);
+	            j = 0;
+	            decoded.push(line);
+	            line = [];
+	            segment[0] = 0;
+	        }
+	        else {
+	            var integer = charToInteger[c];
+	            if (integer === undefined) {
+	                throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
+	            }
+	            var hasContinuationBit = integer & 32;
+	            integer &= 31;
+	            value += integer << shift;
+	            if (hasContinuationBit) {
+	                shift += 5;
+	            }
+	            else {
+	                var shouldNegate = value & 1;
+	                value >>>= 1;
+	                if (shouldNegate) {
+	                    value = value === 0 ? -0x80000000 : -value;
+	                }
+	                segment[j] += value;
+	                j++;
+	                value = shift = 0; // reset
+	            }
+	        }
+	    }
+	    segmentify(line, segment, j);
+	    decoded.push(line);
+	    return decoded;
+	}
+	function segmentify(line, segment, j) {
+	    // This looks ugly, but we're creating specialized arrays with a specific
+	    // length. This is much faster than creating a new array (which v8 expands to
+	    // a capacity of 17 after pushing the first item), or slicing out a subarray
+	    // (which is slow). Length 4 is assumed to be the most frequent, followed by
+	    // length 5 (since not everything will have an associated name), followed by
+	    // length 1 (it's probably rare for a source substring to not have an
+	    // associated segment data).
+	    if (j === 4)
+	        line.push([segment[0], segment[1], segment[2], segment[3]]);
+	    else if (j === 5)
+	        line.push([segment[0], segment[1], segment[2], segment[3], segment[4]]);
+	    else if (j === 1)
+	        line.push([segment[0]]);
+	}
+	function encode(decoded) {
+	    var sourceFileIndex = 0; // second field
+	    var sourceCodeLine = 0; // third field
+	    var sourceCodeColumn = 0; // fourth field
+	    var nameIndex = 0; // fifth field
+	    var mappings = '';
+	    for (var i = 0; i < decoded.length; i++) {
+	        var line = decoded[i];
+	        if (i > 0)
+	            mappings += ';';
+	        if (line.length === 0)
+	            continue;
+	        var generatedCodeColumn = 0; // first field
+	        var lineMappings = [];
+	        for (var _i = 0, line_1 = line; _i < line_1.length; _i++) {
+	            var segment = line_1[_i];
+	            var segmentMappings = encodeInteger(segment[0] - generatedCodeColumn);
+	            generatedCodeColumn = segment[0];
+	            if (segment.length > 1) {
+	                segmentMappings +=
+	                    encodeInteger(segment[1] - sourceFileIndex) +
+	                        encodeInteger(segment[2] - sourceCodeLine) +
+	                        encodeInteger(segment[3] - sourceCodeColumn);
+	                sourceFileIndex = segment[1];
+	                sourceCodeLine = segment[2];
+	                sourceCodeColumn = segment[3];
+	            }
+	            if (segment.length === 5) {
+	                segmentMappings += encodeInteger(segment[4] - nameIndex);
+	                nameIndex = segment[4];
+	            }
+	            lineMappings.push(segmentMappings);
+	        }
+	        mappings += lineMappings.join(',');
+	    }
+	    return mappings;
+	}
+	function encodeInteger(num) {
+	    var result = '';
+	    num = num < 0 ? (-num << 1) | 1 : num << 1;
+	    do {
+	        var clamped = num & 31;
+	        num >>>= 5;
+	        if (num > 0) {
+	            clamped |= 32;
+	        }
+	        result += chars[clamped];
+	    } while (num > 0);
+	    return result;
+	}
+
+	exports.decode = decode;
+	exports.encode = encode;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));
+//# sourceMappingURL=sourcemap-codec.umd.js.map

webui/node_modules/sourcemap-codec/dist/types/sourcemap-codec.d.ts

@@ -0,0 +1,5 @@
+export declare type SourceMapSegment = [number] | [number, number, number, number] | [number, number, number, number, number];
+export declare type SourceMapLine = SourceMapSegment[];
+export declare type SourceMapMappings = SourceMapLine[];
+export declare function decode(mappings: string): SourceMapMappings;
+export declare function encode(decoded: SourceMapMappings): string;