Upload folder using huggingface_hub (part 48)

tools/ui/node_modules/recast/lib/mapping.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+var util_1 = require("./util");
+var Mapping = /** @class */ (function () {
+    function Mapping(sourceLines, sourceLoc, targetLoc) {
+        if (targetLoc === void 0) { targetLoc = sourceLoc; }
+        this.sourceLines = sourceLines;
+        this.sourceLoc = sourceLoc;
+        this.targetLoc = targetLoc;
+    }
+    Mapping.prototype.slice = function (lines, start, end) {
+        if (end === void 0) { end = lines.lastPos(); }
+        var sourceLines = this.sourceLines;
+        var sourceLoc = this.sourceLoc;
+        var targetLoc = this.targetLoc;
+        function skip(name) {
+            var sourceFromPos = sourceLoc[name];
+            var targetFromPos = targetLoc[name];
+            var targetToPos = start;
+            if (name === "end") {
+                targetToPos = end;
+            }
+            else {
+                (0, tiny_invariant_1.default)(name === "start");
+            }
+            return skipChars(sourceLines, sourceFromPos, lines, targetFromPos, targetToPos);
+        }
+        if ((0, util_1.comparePos)(start, targetLoc.start) <= 0) {
+            if ((0, util_1.comparePos)(targetLoc.end, end) <= 0) {
+                targetLoc = {
+                    start: subtractPos(targetLoc.start, start.line, start.column),
+                    end: subtractPos(targetLoc.end, start.line, start.column),
+                };
+                // The sourceLoc can stay the same because the contents of the
+                // targetLoc have not changed.
+            }
+            else if ((0, util_1.comparePos)(end, targetLoc.start) <= 0) {
+                return null;
+            }
+            else {
+                sourceLoc = {
+                    start: sourceLoc.start,
+                    end: skip("end"),
+                };
+                targetLoc = {
+                    start: subtractPos(targetLoc.start, start.line, start.column),
+                    end: subtractPos(end, start.line, start.column),
+                };
+            }
+        }
+        else {
+            if ((0, util_1.comparePos)(targetLoc.end, start) <= 0) {
+                return null;
+            }
+            if ((0, util_1.comparePos)(targetLoc.end, end) <= 0) {
+                sourceLoc = {
+                    start: skip("start"),
+                    end: sourceLoc.end,
+                };
+                targetLoc = {
+                    // Same as subtractPos(start, start.line, start.column):
+                    start: { line: 1, column: 0 },
+                    end: subtractPos(targetLoc.end, start.line, start.column),
+                };
+            }
+            else {
+                sourceLoc = {
+                    start: skip("start"),
+                    end: skip("end"),
+                };
+                targetLoc = {
+                    // Same as subtractPos(start, start.line, start.column):
+                    start: { line: 1, column: 0 },
+                    end: subtractPos(end, start.line, start.column),
+                };
+            }
+        }
+        return new Mapping(this.sourceLines, sourceLoc, targetLoc);
+    };
+    Mapping.prototype.add = function (line, column) {
+        return new Mapping(this.sourceLines, this.sourceLoc, {
+            start: addPos(this.targetLoc.start, line, column),
+            end: addPos(this.targetLoc.end, line, column),
+        });
+    };
+    Mapping.prototype.subtract = function (line, column) {
+        return new Mapping(this.sourceLines, this.sourceLoc, {
+            start: subtractPos(this.targetLoc.start, line, column),
+            end: subtractPos(this.targetLoc.end, line, column),
+        });
+    };
+    Mapping.prototype.indent = function (by, skipFirstLine, noNegativeColumns) {
+        if (skipFirstLine === void 0) { skipFirstLine = false; }
+        if (noNegativeColumns === void 0) { noNegativeColumns = false; }
+        if (by === 0) {
+            return this;
+        }
+        var targetLoc = this.targetLoc;
+        var startLine = targetLoc.start.line;
+        var endLine = targetLoc.end.line;
+        if (skipFirstLine && startLine === 1 && endLine === 1) {
+            return this;
+        }
+        targetLoc = {
+            start: targetLoc.start,
+            end: targetLoc.end,
+        };
+        if (!skipFirstLine || startLine > 1) {
+            var startColumn = targetLoc.start.column + by;
+            targetLoc.start = {
+                line: startLine,
+                column: noNegativeColumns ? Math.max(0, startColumn) : startColumn,
+            };
+        }
+        if (!skipFirstLine || endLine > 1) {
+            var endColumn = targetLoc.end.column + by;
+            targetLoc.end = {
+                line: endLine,
+                column: noNegativeColumns ? Math.max(0, endColumn) : endColumn,
+            };
+        }
+        return new Mapping(this.sourceLines, this.sourceLoc, targetLoc);
+    };
+    return Mapping;
+}());
+exports.default = Mapping;
+function addPos(toPos, line, column) {
+    return {
+        line: toPos.line + line - 1,
+        column: toPos.line === 1 ? toPos.column + column : toPos.column,
+    };
+}
+function subtractPos(fromPos, line, column) {
+    return {
+        line: fromPos.line - line + 1,
+        column: fromPos.line === line ? fromPos.column - column : fromPos.column,
+    };
+}
+function skipChars(sourceLines, sourceFromPos, targetLines, targetFromPos, targetToPos) {
+    var targetComparison = (0, util_1.comparePos)(targetFromPos, targetToPos);
+    if (targetComparison === 0) {
+        // Trivial case: no characters to skip.
+        return sourceFromPos;
+    }
+    var sourceCursor, targetCursor;
+    if (targetComparison < 0) {
+        // Skipping forward.
+        sourceCursor =
+            sourceLines.skipSpaces(sourceFromPos) || sourceLines.lastPos();
+        targetCursor =
+            targetLines.skipSpaces(targetFromPos) || targetLines.lastPos();
+        var lineDiff = targetToPos.line - targetCursor.line;
+        sourceCursor.line += lineDiff;
+        targetCursor.line += lineDiff;
+        if (lineDiff > 0) {
+            // If jumping to later lines, reset columns to the beginnings
+            // of those lines.
+            sourceCursor.column = 0;
+            targetCursor.column = 0;
+        }
+        else {
+            (0, tiny_invariant_1.default)(lineDiff === 0);
+        }
+        while ((0, util_1.comparePos)(targetCursor, targetToPos) < 0 &&
+            targetLines.nextPos(targetCursor, true)) {
+            (0, tiny_invariant_1.default)(sourceLines.nextPos(sourceCursor, true));
+            (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor));
+        }
+    }
+    else {
+        // Skipping backward.
+        sourceCursor =
+            sourceLines.skipSpaces(sourceFromPos, true) || sourceLines.firstPos();
+        targetCursor =
+            targetLines.skipSpaces(targetFromPos, true) || targetLines.firstPos();
+        var lineDiff = targetToPos.line - targetCursor.line;
+        sourceCursor.line += lineDiff;
+        targetCursor.line += lineDiff;
+        if (lineDiff < 0) {
+            // If jumping to earlier lines, reset columns to the ends of
+            // those lines.
+            sourceCursor.column = sourceLines.getLineLength(sourceCursor.line);
+            targetCursor.column = targetLines.getLineLength(targetCursor.line);
+        }
+        else {
+            (0, tiny_invariant_1.default)(lineDiff === 0);
+        }
+        while ((0, util_1.comparePos)(targetToPos, targetCursor) < 0 &&
+            targetLines.prevPos(targetCursor, true)) {
+            (0, tiny_invariant_1.default)(sourceLines.prevPos(sourceCursor, true));
+            (0, tiny_invariant_1.default)(sourceLines.charAt(sourceCursor) === targetLines.charAt(targetCursor));
+        }
+    }
+    return sourceCursor;
+}

tools/ui/node_modules/recast/lib/options.d.ts

@@ -0,0 +1,147 @@
+/**
+ * All Recast API functions take second parameter with configuration options,
+ * documented in options.js
+ */
+export interface Options extends DeprecatedOptions {
+    /**
+     * If you want to use a different branch of esprima, or any other module
+     * that supports a .parse function, pass that module object to
+     * recast.parse as options.parser (legacy synonym: options.esprima).
+     * @default require("recast/parsers/esprima")
+     */
+    parser?: any;
+    /**
+     * Number of spaces the pretty-printer should use per tab for
+     * indentation. If you do not pass this option explicitly, it will be
+     * (quite reliably!) inferred from the original code.
+     * @default 4
+     */
+    tabWidth?: number;
+    /**
+     * If you really want the pretty-printer to use tabs instead of spaces,
+     * make this option true.
+     * @default false
+     */
+    useTabs?: boolean;
+    /**
+     * The reprinting code leaves leading whitespace untouched unless it has
+     * to reindent a line, or you pass false for this option.
+     * @default true
+     */
+    reuseWhitespace?: boolean;
+    /**
+     * Override this option to use a different line terminator, e.g. \r\n.
+     * @default require("os").EOL || "\n"
+     */
+    lineTerminator?: string;
+    /**
+     * Some of the pretty-printer code (such as that for printing function
+     * parameter lists) makes a valiant attempt to prevent really long
+     * lines. You can adjust the limit by changing this option; however,
+     * there is no guarantee that line length will fit inside this limit.
+     * @default 74
+     */
+    wrapColumn?: number;
+    /**
+     * Pass a string as options.sourceFileName to recast.parse to tell the
+     * reprinter to keep track of reused code so that it can construct a
+     * source map automatically.
+     * @default null
+     */
+    sourceFileName?: string | null;
+    /**
+     * Pass a string as options.sourceMapName to recast.print, and (provided
+     * you passed options.sourceFileName earlier) the PrintResult of
+     * recast.print will have a .map property for the generated source map.
+     * @default null
+     */
+    sourceMapName?: string | null;
+    /**
+     * If provided, this option will be passed along to the source map
+     * generator as a root directory for relative source file paths.
+     * @default null
+     */
+    sourceRoot?: string | null;
+    /**
+     * If you provide a source map that was generated from a previous call
+     * to recast.print as options.inputSourceMap, the old source map will be
+     * composed with the new source map.
+     * @default null
+     */
+    inputSourceMap?: string | null;
+    /**
+     * If you want esprima to generate .range information (recast only uses
+     * .loc internally), pass true for this option.
+     * @default false
+     */
+    range?: boolean;
+    /**
+     * If you want esprima not to throw exceptions when it encounters
+     * non-fatal errors, keep this option true.
+     * @default true
+     */
+    tolerant?: boolean;
+    /**
+     * If you want to override the quotes used in string literals, specify
+     * either "single", "double", or "auto" here ("auto" will select the one
+     * which results in the shorter literal) Otherwise, use double quotes.
+     * @default null
+     */
+    quote?: "single" | "double" | "auto" | null;
+    /**
+     * Controls the printing of trailing commas in object literals, array
+     * expressions and function parameters.
+     *
+     * This option could either be:
+     * * Boolean - enable/disable in all contexts (objects, arrays and function params).
+     * * Object - enable/disable per context.
+     *
+     * Example:
+     * trailingComma: {
+     *   objects: true,
+     *   arrays: true,
+     *   parameters: false,
+     * }
+     *
+     * @default false
+     */
+    trailingComma?: boolean;
+    /**
+     * Controls the printing of spaces inside array brackets.
+     * See: http://eslint.org/docs/rules/array-bracket-spacing
+     * @default false
+     */
+    arrayBracketSpacing?: boolean;
+    /**
+     * Controls the printing of spaces inside object literals,
+     * destructuring assignments, and import/export specifiers.
+     * See: http://eslint.org/docs/rules/object-curly-spacing
+     * @default true
+     */
+    objectCurlySpacing?: boolean;
+    /**
+     * If you want parenthesis to wrap single-argument arrow function
+     * parameter lists, pass true for this option.
+     * @default false
+     */
+    arrowParensAlways?: boolean;
+    /**
+     * There are 2 supported syntaxes (`,` and `;`) in Flow Object Types;
+     * The use of commas is in line with the more popular style and matches
+     * how objects are defined in JS, making it a bit more natural to write.
+     * @default true
+     */
+    flowObjectCommas?: boolean;
+    /**
+     * Whether to return an array of .tokens on the root AST node.
+     * @default true
+     */
+    tokens?: boolean;
+}
+interface DeprecatedOptions {
+    /** @deprecated */
+    esprima?: any;
+}
+export type NormalizedOptions = Required<Omit<Options, keyof DeprecatedOptions>>;
+export declare function normalize(opts?: Options): NormalizedOptions;
+export {};

tools/ui/node_modules/recast/lib/options.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalize = void 0;
+var util_1 = require("./util");
+var defaults = {
+    parser: require("../parsers/esprima"),
+    tabWidth: 4,
+    useTabs: false,
+    reuseWhitespace: true,
+    lineTerminator: (0, util_1.getLineTerminator)(),
+    wrapColumn: 74,
+    sourceFileName: null,
+    sourceMapName: null,
+    sourceRoot: null,
+    inputSourceMap: null,
+    range: false,
+    tolerant: true,
+    quote: null,
+    trailingComma: false,
+    arrayBracketSpacing: false,
+    objectCurlySpacing: true,
+    arrowParensAlways: false,
+    flowObjectCommas: true,
+    tokens: true,
+};
+var hasOwn = defaults.hasOwnProperty;
+// Copy options and fill in default values.
+function normalize(opts) {
+    var options = opts || defaults;
+    function get(key) {
+        return hasOwn.call(options, key) ? options[key] : defaults[key];
+    }
+    return {
+        tabWidth: +get("tabWidth"),
+        useTabs: !!get("useTabs"),
+        reuseWhitespace: !!get("reuseWhitespace"),
+        lineTerminator: get("lineTerminator"),
+        wrapColumn: Math.max(get("wrapColumn"), 0),
+        sourceFileName: get("sourceFileName"),
+        sourceMapName: get("sourceMapName"),
+        sourceRoot: get("sourceRoot"),
+        inputSourceMap: get("inputSourceMap"),
+        parser: get("esprima") || get("parser"),
+        range: get("range"),
+        tolerant: get("tolerant"),
+        quote: get("quote"),
+        trailingComma: get("trailingComma"),
+        arrayBracketSpacing: get("arrayBracketSpacing"),
+        objectCurlySpacing: get("objectCurlySpacing"),
+        arrowParensAlways: get("arrowParensAlways"),
+        flowObjectCommas: get("flowObjectCommas"),
+        tokens: !!get("tokens"),
+    };
+}
+exports.normalize = normalize;

tools/ui/node_modules/recast/lib/parser.d.ts

@@ -0,0 +1,2 @@
+import { Options } from "./options";
+export declare function parse(source: string, options?: Partial<Options>): any;

tools/ui/node_modules/recast/lib/parser.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+var tslib_1 = require("tslib");
+var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+var types = tslib_1.__importStar(require("ast-types"));
+var b = types.builders;
+var isObject = types.builtInTypes.object;
+var isArray = types.builtInTypes.array;
+var options_1 = require("./options");
+var lines_1 = require("./lines");
+var comments_1 = require("./comments");
+var util = tslib_1.__importStar(require("./util"));
+function parse(source, options) {
+    options = (0, options_1.normalize)(options);
+    var lines = (0, lines_1.fromString)(source, options);
+    var sourceWithoutTabs = lines.toString({
+        tabWidth: options.tabWidth,
+        reuseWhitespace: false,
+        useTabs: false,
+    });
+    var comments = [];
+    var ast = options.parser.parse(sourceWithoutTabs, {
+        jsx: true,
+        loc: true,
+        locations: true,
+        range: options.range,
+        comment: true,
+        onComment: comments,
+        tolerant: util.getOption(options, "tolerant", true),
+        ecmaVersion: 6,
+        sourceType: util.getOption(options, "sourceType", "module"),
+    });
+    // Use ast.tokens if possible, and otherwise fall back to the Esprima
+    // tokenizer. All the preconfigured ../parsers/* expose ast.tokens
+    // automatically, but custom parsers might need additional configuration
+    // to avoid this fallback.
+    var tokens = Array.isArray(ast.tokens)
+        ? ast.tokens
+        : require("esprima").tokenize(sourceWithoutTabs, {
+            loc: true,
+        });
+    // We will reattach the tokens array to the file object below.
+    delete ast.tokens;
+    // Make sure every token has a token.value string.
+    tokens.forEach(function (token) {
+        if (typeof token.value !== "string") {
+            token.value = lines.sliceString(token.loc.start, token.loc.end);
+        }
+    });
+    if (Array.isArray(ast.comments)) {
+        comments = ast.comments;
+        delete ast.comments;
+    }
+    if (ast.loc) {
+        // If the source was empty, some parsers give loc.{start,end}.line
+        // values of 0, instead of the minimum of 1.
+        util.fixFaultyLocations(ast, lines);
+    }
+    else {
+        ast.loc = {
+            start: lines.firstPos(),
+            end: lines.lastPos(),
+        };
+    }
+    ast.loc.lines = lines;
+    ast.loc.indent = 0;
+    var file;
+    var program;
+    if (ast.type === "Program") {
+        program = ast;
+        // In order to ensure we reprint leading and trailing program
+        // comments, wrap the original Program node with a File node. Only
+        // ESTree parsers (Acorn and Esprima) return a Program as the root AST
+        // node. Most other (Babylon-like) parsers return a File.
+        file = b.file(ast, options.sourceFileName || null);
+        file.loc = {
+            start: lines.firstPos(),
+            end: lines.lastPos(),
+            lines: lines,
+            indent: 0,
+        };
+    }
+    else if (ast.type === "File") {
+        file = ast;
+        program = file.program;
+    }
+    // Expose file.tokens unless the caller passed false for options.tokens.
+    if (options.tokens) {
+        file.tokens = tokens;
+    }
+    // Expand the Program's .loc to include all comments (not just those
+    // attached to the Program node, as its children may have comments as
+    // well), since sometimes program.loc.{start,end} will coincide with the
+    // .loc.{start,end} of the first and last *statements*, mistakenly
+    // excluding comments that fall outside that region.
+    var trueProgramLoc = util.getTrueLoc({
+        type: program.type,
+        loc: program.loc,
+        body: [],
+        comments: comments,
+    }, lines);
+    program.loc.start = trueProgramLoc.start;
+    program.loc.end = trueProgramLoc.end;
+    // Passing file.program here instead of just file means that initial
+    // comments will be attached to program.body[0] instead of program.
+    (0, comments_1.attach)(comments, program.body.length ? file.program : file, lines);
+    // Return a copy of the original AST so that any changes made may be
+    // compared to the original.
+    return new TreeCopier(lines, tokens).copy(file);
+}
+exports.parse = parse;
+var TreeCopier = function TreeCopier(lines, tokens) {
+    (0, tiny_invariant_1.default)(this instanceof TreeCopier);
+    this.lines = lines;
+    this.tokens = tokens;
+    this.startTokenIndex = 0;
+    this.endTokenIndex = tokens.length;
+    this.indent = 0;
+    this.seen = new Map();
+};
+var TCp = TreeCopier.prototype;
+TCp.copy = function (node) {
+    if (this.seen.has(node)) {
+        return this.seen.get(node);
+    }
+    if (isArray.check(node)) {
+        var copy_1 = new Array(node.length);
+        this.seen.set(node, copy_1);
+        node.forEach(function (item, i) {
+            copy_1[i] = this.copy(item);
+        }, this);
+        return copy_1;
+    }
+    if (!isObject.check(node)) {
+        return node;
+    }
+    util.fixFaultyLocations(node, this.lines);
+    var copy = Object.create(Object.getPrototypeOf(node), {
+        original: {
+            // Provide a link from the copy to the original.
+            value: node,
+            configurable: false,
+            enumerable: false,
+            writable: true,
+        },
+    });
+    this.seen.set(node, copy);
+    var loc = node.loc;
+    var oldIndent = this.indent;
+    var newIndent = oldIndent;
+    var oldStartTokenIndex = this.startTokenIndex;
+    var oldEndTokenIndex = this.endTokenIndex;
+    if (loc) {
+        // When node is a comment, we set node.loc.indent to
+        // node.loc.start.column so that, when/if we print the comment by
+        // itself, we can strip that much whitespace from the left margin of
+        // the comment. This only really matters for multiline Block comments,
+        // but it doesn't hurt for Line comments.
+        if (node.type === "Block" ||
+            node.type === "Line" ||
+            node.type === "CommentBlock" ||
+            node.type === "CommentLine" ||
+            this.lines.isPrecededOnlyByWhitespace(loc.start)) {
+            newIndent = this.indent = loc.start.column;
+        }
+        // Every node.loc has a reference to the original source lines as well
+        // as a complete list of source tokens.
+        loc.lines = this.lines;
+        loc.tokens = this.tokens;
+        loc.indent = newIndent;
+        // Set loc.start.token and loc.end.token such that
+        // loc.tokens.slice(loc.start.token, loc.end.token) returns a list of
+        // all the tokens that make up this node.
+        this.findTokenRange(loc);
+    }
+    var keys = Object.keys(node);
+    var keyCount = keys.length;
+    for (var i = 0; i < keyCount; ++i) {
+        var key = keys[i];
+        if (key === "loc") {
+            copy[key] = node[key];
+        }
+        else if (key === "tokens" && node.type === "File") {
+            // Preserve file.tokens (uncopied) in case client code cares about
+            // it, even though Recast ignores it when reprinting.
+            copy[key] = node[key];
+        }
+        else {
+            copy[key] = this.copy(node[key]);
+        }
+    }
+    this.indent = oldIndent;
+    this.startTokenIndex = oldStartTokenIndex;
+    this.endTokenIndex = oldEndTokenIndex;
+    return copy;
+};
+// If we didn't have any idea where in loc.tokens to look for tokens
+// contained by this loc, a binary search would be appropriate, but
+// because we maintain this.startTokenIndex and this.endTokenIndex as we
+// traverse the AST, we only need to make small (linear) adjustments to
+// those indexes with each recursive iteration.
+TCp.findTokenRange = function (loc) {
+    // In the unlikely event that loc.tokens[this.startTokenIndex] starts
+    // *after* loc.start, we need to rewind this.startTokenIndex first.
+    while (this.startTokenIndex > 0) {
+        var token = loc.tokens[this.startTokenIndex];
+        if (util.comparePos(loc.start, token.loc.start) < 0) {
+            --this.startTokenIndex;
+        }
+        else
+            break;
+    }
+    // In the unlikely event that loc.tokens[this.endTokenIndex - 1] ends
+    // *before* loc.end, we need to fast-forward this.endTokenIndex first.
+    while (this.endTokenIndex < loc.tokens.length) {
+        var token = loc.tokens[this.endTokenIndex];
+        if (util.comparePos(token.loc.end, loc.end) < 0) {
+            ++this.endTokenIndex;
+        }
+        else
+            break;
+    }
+    // Increment this.startTokenIndex until we've found the first token
+    // contained by this node.
+    while (this.startTokenIndex < this.endTokenIndex) {
+        var token = loc.tokens[this.startTokenIndex];
+        if (util.comparePos(token.loc.start, loc.start) < 0) {
+            ++this.startTokenIndex;
+        }
+        else
+            break;
+    }
+    // Index into loc.tokens of the first token within this node.
+    loc.start.token = this.startTokenIndex;
+    // Decrement this.endTokenIndex until we've found the first token after
+    // this node (not contained by the node).
+    while (this.endTokenIndex > this.startTokenIndex) {
+        var token = loc.tokens[this.endTokenIndex - 1];
+        if (util.comparePos(loc.end, token.loc.end) < 0) {
+            --this.endTokenIndex;
+        }
+        else
+            break;
+    }
+    // Index into loc.tokens of the first token *after* this node.
+    // If loc.start.token === loc.end.token, the node contains no tokens,
+    // and the index is that of the next token following this node.
+    loc.end.token = this.endTokenIndex;
+};

tools/ui/node_modules/recast/lib/patcher.d.ts

@@ -0,0 +1,12 @@
+interface PatcherType {
+    replace(loc: any, lines: any): any;
+    get(loc?: any): any;
+    tryToReprintComments(newNode: any, oldNode: any, print: any): any;
+    deleteComments(node: any): any;
+}
+interface PatcherConstructor {
+    new (lines: any): PatcherType;
+}
+declare const Patcher: PatcherConstructor;
+export { Patcher };
+export declare function getReprinter(path: any): ((print: any) => any) | undefined;

tools/ui/node_modules/recast/lib/patcher.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReprinter = exports.Patcher = void 0;
+var tslib_1 = require("tslib");
+var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+var linesModule = tslib_1.__importStar(require("./lines"));
+var types = tslib_1.__importStar(require("ast-types"));
+var Printable = types.namedTypes.Printable;
+var Expression = types.namedTypes.Expression;
+var ReturnStatement = types.namedTypes.ReturnStatement;
+var SourceLocation = types.namedTypes.SourceLocation;
+var util_1 = require("./util");
+var fast_path_1 = tslib_1.__importDefault(require("./fast-path"));
+var isObject = types.builtInTypes.object;
+var isArray = types.builtInTypes.array;
+var isString = types.builtInTypes.string;
+var riskyAdjoiningCharExp = /[0-9a-z_$]/i;
+var Patcher = function Patcher(lines) {
+    (0, tiny_invariant_1.default)(this instanceof Patcher);
+    (0, tiny_invariant_1.default)(lines instanceof linesModule.Lines);
+    var self = this, replacements = [];
+    self.replace = function (loc, lines) {
+        if (isString.check(lines))
+            lines = linesModule.fromString(lines);
+        replacements.push({
+            lines: lines,
+            start: loc.start,
+            end: loc.end,
+        });
+    };
+    self.get = function (loc) {
+        // If no location is provided, return the complete Lines object.
+        loc = loc || {
+            start: { line: 1, column: 0 },
+            end: { line: lines.length, column: lines.getLineLength(lines.length) },
+        };
+        var sliceFrom = loc.start, toConcat = [];
+        function pushSlice(from, to) {
+            (0, tiny_invariant_1.default)((0, util_1.comparePos)(from, to) <= 0);
+            toConcat.push(lines.slice(from, to));
+        }
+        replacements
+            .sort(function (a, b) { return (0, util_1.comparePos)(a.start, b.start); })
+            .forEach(function (rep) {
+            if ((0, util_1.comparePos)(sliceFrom, rep.start) > 0) {
+                // Ignore nested replacement ranges.
+            }
+            else {
+                pushSlice(sliceFrom, rep.start);
+                toConcat.push(rep.lines);
+                sliceFrom = rep.end;
+            }
+        });
+        pushSlice(sliceFrom, loc.end);
+        return linesModule.concat(toConcat);
+    };
+};
+exports.Patcher = Patcher;
+var Pp = Patcher.prototype;
+Pp.tryToReprintComments = function (newNode, oldNode, print) {
+    var patcher = this;
+    if (!newNode.comments && !oldNode.comments) {
+        // We were (vacuously) able to reprint all the comments!
+        return true;
+    }
+    var newPath = fast_path_1.default.from(newNode);
+    var oldPath = fast_path_1.default.from(oldNode);
+    newPath.stack.push("comments", getSurroundingComments(newNode));
+    oldPath.stack.push("comments", getSurroundingComments(oldNode));
+    var reprints = [];
+    var ableToReprintComments = findArrayReprints(newPath, oldPath, reprints);
+    // No need to pop anything from newPath.stack or oldPath.stack, since
+    // newPath and oldPath are fresh local variables.
+    if (ableToReprintComments && reprints.length > 0) {
+        reprints.forEach(function (reprint) {
+            var oldComment = reprint.oldPath.getValue();
+            (0, tiny_invariant_1.default)(oldComment.leading || oldComment.trailing);
+            patcher.replace(oldComment.loc, 
+            // Comments can't have .comments, so it doesn't matter whether we
+            // print with comments or without.
+            print(reprint.newPath).indentTail(oldComment.loc.indent));
+        });
+    }
+    return ableToReprintComments;
+};
+// Get all comments that are either leading or trailing, ignoring any
+// comments that occur inside node.loc. Returns an empty array for nodes
+// with no leading or trailing comments.
+function getSurroundingComments(node) {
+    var result = [];
+    if (node.comments && node.comments.length > 0) {
+        node.comments.forEach(function (comment) {
+            if (comment.leading || comment.trailing) {
+                result.push(comment);
+            }
+        });
+    }
+    return result;
+}
+Pp.deleteComments = function (node) {
+    if (!node.comments) {
+        return;
+    }
+    var patcher = this;
+    node.comments.forEach(function (comment) {
+        if (comment.leading) {
+            // Delete leading comments along with any trailing whitespace they
+            // might have.
+            patcher.replace({
+                start: comment.loc.start,
+                end: node.loc.lines.skipSpaces(comment.loc.end, false, false),
+            }, "");
+        }
+        else if (comment.trailing) {
+            // Delete trailing comments along with any leading whitespace they
+            // might have.
+            patcher.replace({
+                start: node.loc.lines.skipSpaces(comment.loc.start, true, false),
+                end: comment.loc.end,
+            }, "");
+        }
+    });
+};
+function getReprinter(path) {
+    (0, tiny_invariant_1.default)(path instanceof fast_path_1.default);
+    // Make sure that this path refers specifically to a Node, rather than
+    // some non-Node subproperty of a Node.
+    var node = path.getValue();
+    if (!Printable.check(node))
+        return;
+    var orig = node.original;
+    var origLoc = orig && orig.loc;
+    var lines = origLoc && origLoc.lines;
+    var reprints = [];
+    if (!lines || !findReprints(path, reprints))
+        return;
+    return function (print) {
+        var patcher = new Patcher(lines);
+        reprints.forEach(function (reprint) {
+            var newNode = reprint.newPath.getValue();
+            var oldNode = reprint.oldPath.getValue();
+            SourceLocation.assert(oldNode.loc, true);
+            var needToPrintNewPathWithComments = !patcher.tryToReprintComments(newNode, oldNode, print);
+            if (needToPrintNewPathWithComments) {
+                // Since we were not able to preserve all leading/trailing
+                // comments, we delete oldNode's comments, print newPath with
+                // comments, and then patch the resulting lines where oldNode used
+                // to be.
+                patcher.deleteComments(oldNode);
+            }
+            var newLines = print(reprint.newPath, {
+                includeComments: needToPrintNewPathWithComments,
+                // If the oldNode we're replacing already had parentheses, we may
+                // not need to print the new node with any extra parentheses,
+                // because the existing parentheses will suffice. However, if the
+                // newNode has a different type than the oldNode, let the printer
+                // decide if reprint.newPath needs parentheses, as usual.
+                avoidRootParens: oldNode.type === newNode.type && reprint.oldPath.hasParens(),
+            }).indentTail(oldNode.loc.indent);
+            var nls = needsLeadingSpace(lines, oldNode.loc, newLines);
+            var nts = needsTrailingSpace(lines, oldNode.loc, newLines);
+            // If we try to replace the argument of a ReturnStatement like
+            // return"asdf" with e.g. a literal null expression, we run the risk
+            // of ending up with returnnull, so we need to add an extra leading
+            // space in situations where that might happen. Likewise for
+            // "asdf"in obj. See #170.
+            if (nls || nts) {
+                var newParts = [];
+                nls && newParts.push(" ");
+                newParts.push(newLines);
+                nts && newParts.push(" ");
+                newLines = linesModule.concat(newParts);
+            }
+            patcher.replace(oldNode.loc, newLines);
+        });
+        // Recall that origLoc is the .loc of an ancestor node that is
+        // guaranteed to contain all the reprinted nodes and comments.
+        var patchedLines = patcher.get(origLoc).indentTail(-orig.loc.indent);
+        if (path.needsParens()) {
+            return linesModule.concat(["(", patchedLines, ")"]);
+        }
+        return patchedLines;
+    };
+}
+exports.getReprinter = getReprinter;
+// If the last character before oldLoc and the first character of newLines
+// are both identifier characters, they must be separated by a space,
+// otherwise they will most likely get fused together into a single token.
+function needsLeadingSpace(oldLines, oldLoc, newLines) {
+    var posBeforeOldLoc = (0, util_1.copyPos)(oldLoc.start);
+    // The character just before the location occupied by oldNode.
+    var charBeforeOldLoc = oldLines.prevPos(posBeforeOldLoc) && oldLines.charAt(posBeforeOldLoc);
+    // First character of the reprinted node.
+    var newFirstChar = newLines.charAt(newLines.firstPos());
+    return (charBeforeOldLoc &&
+        riskyAdjoiningCharExp.test(charBeforeOldLoc) &&
+        newFirstChar &&
+        riskyAdjoiningCharExp.test(newFirstChar));
+}
+// If the last character of newLines and the first character after oldLoc
+// are both identifier characters, they must be separated by a space,
+// otherwise they will most likely get fused together into a single token.
+function needsTrailingSpace(oldLines, oldLoc, newLines) {
+    // The character just after the location occupied by oldNode.
+    var charAfterOldLoc = oldLines.charAt(oldLoc.end);
+    var newLastPos = newLines.lastPos();
+    // Last character of the reprinted node.
+    var newLastChar = newLines.prevPos(newLastPos) && newLines.charAt(newLastPos);
+    return (newLastChar &&
+        riskyAdjoiningCharExp.test(newLastChar) &&
+        charAfterOldLoc &&
+        riskyAdjoiningCharExp.test(charAfterOldLoc));
+}
+function findReprints(newPath, reprints) {
+    var newNode = newPath.getValue();
+    Printable.assert(newNode);
+    var oldNode = newNode.original;
+    Printable.assert(oldNode);
+    (0, tiny_invariant_1.default)(reprints.length === 0);
+    if (newNode.type !== oldNode.type) {
+        return false;
+    }
+    var oldPath = new fast_path_1.default(oldNode);
+    var canReprint = findChildReprints(newPath, oldPath, reprints);
+    if (!canReprint) {
+        // Make absolutely sure the calling code does not attempt to reprint
+        // any nodes.
+        reprints.length = 0;
+    }
+    return canReprint;
+}
+function findAnyReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    if (newNode === oldNode)
+        return true;
+    if (isArray.check(newNode))
+        return findArrayReprints(newPath, oldPath, reprints);
+    if (isObject.check(newNode))
+        return findObjectReprints(newPath, oldPath, reprints);
+    return false;
+}
+function findArrayReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    if (newNode === oldNode ||
+        newPath.valueIsDuplicate() ||
+        oldPath.valueIsDuplicate()) {
+        return true;
+    }
+    isArray.assert(newNode);
+    var len = newNode.length;
+    if (!(isArray.check(oldNode) && oldNode.length === len))
+        return false;
+    for (var i = 0; i < len; ++i) {
+        newPath.stack.push(i, newNode[i]);
+        oldPath.stack.push(i, oldNode[i]);
+        var canReprint = findAnyReprints(newPath, oldPath, reprints);
+        newPath.stack.length -= 2;
+        oldPath.stack.length -= 2;
+        if (!canReprint) {
+            return false;
+        }
+    }
+    return true;
+}
+function findObjectReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    isObject.assert(newNode);
+    if (newNode.original === null) {
+        // If newNode.original node was set to null, reprint the node.
+        return false;
+    }
+    var oldNode = oldPath.getValue();
+    if (!isObject.check(oldNode))
+        return false;
+    if (newNode === oldNode ||
+        newPath.valueIsDuplicate() ||
+        oldPath.valueIsDuplicate()) {
+        return true;
+    }
+    if (Printable.check(newNode)) {
+        if (!Printable.check(oldNode)) {
+            return false;
+        }
+        var newParentNode = newPath.getParentNode();
+        var oldParentNode = oldPath.getParentNode();
+        if (oldParentNode !== null &&
+            oldParentNode.type === "FunctionTypeAnnotation" &&
+            newParentNode !== null &&
+            newParentNode.type === "FunctionTypeAnnotation") {
+            var oldNeedsParens = oldParentNode.params.length !== 1 || !!oldParentNode.params[0].name;
+            var newNeedParens = newParentNode.params.length !== 1 || !!newParentNode.params[0].name;
+            if (!oldNeedsParens && newNeedParens) {
+                return false;
+            }
+        }
+        // Here we need to decide whether the reprinted code for newNode is
+        // appropriate for patching into the location of oldNode.
+        if (newNode.type === oldNode.type) {
+            var childReprints = [];
+            if (findChildReprints(newPath, oldPath, childReprints)) {
+                reprints.push.apply(reprints, childReprints);
+            }
+            else if (oldNode.loc) {
+                // If we have no .loc information for oldNode, then we won't be
+                // able to reprint it.
+                reprints.push({
+                    oldPath: oldPath.copy(),
+                    newPath: newPath.copy(),
+                });
+            }
+            else {
+                return false;
+            }
+            return true;
+        }
+        if (Expression.check(newNode) &&
+            Expression.check(oldNode) &&
+            // If we have no .loc information for oldNode, then we won't be
+            // able to reprint it.
+            oldNode.loc) {
+            // If both nodes are subtypes of Expression, then we should be able
+            // to fill the location occupied by the old node with code printed
+            // for the new node with no ill consequences.
+            reprints.push({
+                oldPath: oldPath.copy(),
+                newPath: newPath.copy(),
+            });
+            return true;
+        }
+        // The nodes have different types, and at least one of the types is
+        // not a subtype of the Expression type, so we cannot safely assume
+        // the nodes are syntactically interchangeable.
+        return false;
+    }
+    return findChildReprints(newPath, oldPath, reprints);
+}
+function findChildReprints(newPath, oldPath, reprints) {
+    var newNode = newPath.getValue();
+    var oldNode = oldPath.getValue();
+    isObject.assert(newNode);
+    isObject.assert(oldNode);
+    if (newNode.original === null) {
+        // If newNode.original node was set to null, reprint the node.
+        return false;
+    }
+    // If this node needs parentheses and will not be wrapped with
+    // parentheses when reprinted, then return false to skip reprinting and
+    // let it be printed generically.
+    if (newPath.needsParens() && !oldPath.hasParens()) {
+        return false;
+    }
+    var keys = (0, util_1.getUnionOfKeys)(oldNode, newNode);
+    if (oldNode.type === "File" || newNode.type === "File") {
+        // Don't bother traversing file.tokens, an often very large array
+        // returned by Babylon, and useless for our purposes.
+        delete keys.tokens;
+    }
+    // Don't bother traversing .loc objects looking for reprintable nodes.
+    delete keys.loc;
+    var originalReprintCount = reprints.length;
+    for (var k in keys) {
+        if (k.charAt(0) === "_") {
+            // Ignore "private" AST properties added by e.g. Babel plugins and
+            // parsers like Babylon.
+            continue;
+        }
+        newPath.stack.push(k, types.getFieldValue(newNode, k));
+        oldPath.stack.push(k, types.getFieldValue(oldNode, k));
+        var canReprint = findAnyReprints(newPath, oldPath, reprints);
+        newPath.stack.length -= 2;
+        oldPath.stack.length -= 2;
+        if (!canReprint) {
+            return false;
+        }
+    }
+    // Return statements might end up running into ASI issues due to
+    // comments inserted deep within the tree, so reprint them if anything
+    // changed within them.
+    if (ReturnStatement.check(newPath.getNode()) &&
+        reprints.length > originalReprintCount) {
+        return false;
+    }
+    return true;
+}

tools/ui/node_modules/recast/lib/printer.d.ts

@@ -0,0 +1,14 @@
+export interface PrintResultType {
+    code: string;
+    map?: any;
+    toString(): string;
+}
+interface PrinterType {
+    print(ast: any): PrintResultType;
+    printGenerically(ast: any): PrintResultType;
+}
+interface PrinterConstructor {
+    new (config?: any): PrinterType;
+}
+declare const Printer: PrinterConstructor;
+export { Printer };

tools/ui/node_modules/recast/lib/util.d.ts

@@ -0,0 +1,18 @@
+export declare function getLineTerminator(): any;
+export declare function isBrowser(): boolean;
+export declare function getOption(options: any, key: any, defaultValue: any): any;
+export declare function getUnionOfKeys(...args: any[]): any;
+export declare function comparePos(pos1: any, pos2: any): number;
+export declare function copyPos(pos: any): {
+    line: any;
+    column: any;
+};
+export declare function composeSourceMaps(formerMap: any, latterMap: any): any;
+export declare function getTrueLoc(node: any, lines: any): {
+    start: any;
+    end: any;
+} | null;
+export declare function fixFaultyLocations(node: any, lines: any): void;
+export declare function isExportDeclaration(node: any): boolean;
+export declare function getParentExportDeclaration(path: any): any;
+export declare function isTrailingCommaEnabled(options: any, context: any): boolean;

tools/ui/node_modules/recast/lib/util.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrailingCommaEnabled = exports.getParentExportDeclaration = exports.isExportDeclaration = exports.fixFaultyLocations = exports.getTrueLoc = exports.composeSourceMaps = exports.copyPos = exports.comparePos = exports.getUnionOfKeys = exports.getOption = exports.isBrowser = exports.getLineTerminator = void 0;
+var tslib_1 = require("tslib");
+var tiny_invariant_1 = tslib_1.__importDefault(require("tiny-invariant"));
+var types = tslib_1.__importStar(require("ast-types"));
+var n = types.namedTypes;
+var source_map_1 = tslib_1.__importDefault(require("source-map"));
+var SourceMapConsumer = source_map_1.default.SourceMapConsumer;
+var SourceMapGenerator = source_map_1.default.SourceMapGenerator;
+var hasOwn = Object.prototype.hasOwnProperty;
+function getLineTerminator() {
+    return isBrowser() ? "\n" : require("os").EOL || "\n";
+}
+exports.getLineTerminator = getLineTerminator;
+function isBrowser() {
+    return (typeof window !== "undefined" && typeof window.document !== "undefined");
+}
+exports.isBrowser = isBrowser;
+function getOption(options, key, defaultValue) {
+    if (options && hasOwn.call(options, key)) {
+        return options[key];
+    }
+    return defaultValue;
+}
+exports.getOption = getOption;
+function getUnionOfKeys() {
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    var result = {};
+    var argc = args.length;
+    for (var i = 0; i < argc; ++i) {
+        var keys = Object.keys(args[i]);
+        var keyCount = keys.length;
+        for (var j = 0; j < keyCount; ++j) {
+            result[keys[j]] = true;
+        }
+    }
+    return result;
+}
+exports.getUnionOfKeys = getUnionOfKeys;
+function comparePos(pos1, pos2) {
+    return pos1.line - pos2.line || pos1.column - pos2.column;
+}
+exports.comparePos = comparePos;
+function copyPos(pos) {
+    return {
+        line: pos.line,
+        column: pos.column,
+    };
+}
+exports.copyPos = copyPos;
+function composeSourceMaps(formerMap, latterMap) {
+    if (formerMap) {
+        if (!latterMap) {
+            return formerMap;
+        }
+    }
+    else {
+        return latterMap || null;
+    }
+    var smcFormer = new SourceMapConsumer(formerMap);
+    var smcLatter = new SourceMapConsumer(latterMap);
+    var smg = new SourceMapGenerator({
+        file: latterMap.file,
+        sourceRoot: latterMap.sourceRoot,
+    });
+    var sourcesToContents = {};
+    smcLatter.eachMapping(function (mapping) {
+        var origPos = smcFormer.originalPositionFor({
+            line: mapping.originalLine,
+            column: mapping.originalColumn,
+        });
+        var sourceName = origPos.source;
+        if (sourceName === null) {
+            return;
+        }
+        smg.addMapping({
+            source: sourceName,
+            original: copyPos(origPos),
+            generated: {
+                line: mapping.generatedLine,
+                column: mapping.generatedColumn,
+            },
+            name: mapping.name,
+        });
+        var sourceContent = smcFormer.sourceContentFor(sourceName);
+        if (sourceContent && !hasOwn.call(sourcesToContents, sourceName)) {
+            sourcesToContents[sourceName] = sourceContent;
+            smg.setSourceContent(sourceName, sourceContent);
+        }
+    });
+    return smg.toJSON();
+}
+exports.composeSourceMaps = composeSourceMaps;
+function getTrueLoc(node, lines) {
+    // It's possible that node is newly-created (not parsed by Esprima),
+    // in which case it probably won't have a .loc property (or an
+    // .original property for that matter). That's fine; we'll just
+    // pretty-print it as usual.
+    if (!node.loc) {
+        return null;
+    }
+    var result = {
+        start: node.loc.start,
+        end: node.loc.end,
+    };
+    function include(node) {
+        expandLoc(result, node.loc);
+    }
+    // If the node is an export declaration and its .declaration has any
+    // decorators, their locations might contribute to the true start/end
+    // positions of the export declaration node.
+    if (node.declaration &&
+        node.declaration.decorators &&
+        isExportDeclaration(node)) {
+        node.declaration.decorators.forEach(include);
+    }
+    if (comparePos(result.start, result.end) < 0) {
+        // Trim leading whitespace.
+        result.start = copyPos(result.start);
+        lines.skipSpaces(result.start, false, true);
+        if (comparePos(result.start, result.end) < 0) {
+            // Trim trailing whitespace, if the end location is not already the
+            // same as the start location.
+            result.end = copyPos(result.end);
+            lines.skipSpaces(result.end, true, true);
+        }
+    }
+    // If the node has any comments, their locations might contribute to
+    // the true start/end positions of the node.
+    if (node.comments) {
+        node.comments.forEach(include);
+    }
+    return result;
+}
+exports.getTrueLoc = getTrueLoc;
+function expandLoc(parentLoc, childLoc) {
+    if (parentLoc && childLoc) {
+        if (comparePos(childLoc.start, parentLoc.start) < 0) {
+            parentLoc.start = childLoc.start;
+        }
+        if (comparePos(parentLoc.end, childLoc.end) < 0) {
+            parentLoc.end = childLoc.end;
+        }
+    }
+}
+function fixFaultyLocations(node, lines) {
+    var loc = node.loc;
+    if (loc) {
+        if (loc.start.line < 1) {
+            loc.start.line = 1;
+        }
+        if (loc.end.line < 1) {
+            loc.end.line = 1;
+        }
+    }
+    if (node.type === "File") {
+        // Babylon returns File nodes whose .loc.{start,end} do not include
+        // leading or trailing whitespace.
+        loc.start = lines.firstPos();
+        loc.end = lines.lastPos();
+    }
+    fixForLoopHead(node, lines);
+    fixTemplateLiteral(node, lines);
+    if (loc && node.decorators) {
+        // Expand the .loc of the node responsible for printing the decorators
+        // (here, the decorated node) so that it includes node.decorators.
+        node.decorators.forEach(function (decorator) {
+            expandLoc(loc, decorator.loc);
+        });
+    }
+    else if (node.declaration && isExportDeclaration(node)) {
+        // Nullify .loc information for the child declaration so that we never
+        // try to reprint it without also reprinting the export declaration.
+        node.declaration.loc = null;
+        // Expand the .loc of the node responsible for printing the decorators
+        // (here, the export declaration) so that it includes node.decorators.
+        var decorators = node.declaration.decorators;
+        if (decorators) {
+            decorators.forEach(function (decorator) {
+                expandLoc(loc, decorator.loc);
+            });
+        }
+    }
+    else if ((n.MethodDefinition && n.MethodDefinition.check(node)) ||
+        (n.Property.check(node) && (node.method || node.shorthand))) {
+        // If the node is a MethodDefinition or a .method or .shorthand
+        // Property, then the location information stored in
+        // node.value.loc is very likely untrustworthy (just the {body}
+        // part of a method, or nothing in the case of shorthand
+        // properties), so we null out that information to prevent
+        // accidental reuse of bogus source code during reprinting.
+        node.value.loc = null;
+        if (n.FunctionExpression.check(node.value)) {
+            // FunctionExpression method values should be anonymous,
+            // because their .id fields are ignored anyway.
+            node.value.id = null;
+        }
+    }
+    else if (node.type === "ObjectTypeProperty") {
+        var loc_1 = node.loc;
+        var end = loc_1 && loc_1.end;
+        if (end) {
+            end = copyPos(end);
+            if (lines.prevPos(end) && lines.charAt(end) === ",") {
+                // Some parsers accidentally include trailing commas in the
+                // .loc.end information for ObjectTypeProperty nodes.
+                if ((end = lines.skipSpaces(end, true, true))) {
+                    loc_1.end = end;
+                }
+            }
+        }
+    }
+}
+exports.fixFaultyLocations = fixFaultyLocations;
+function fixForLoopHead(node, lines) {
+    if (node.type !== "ForStatement") {
+        return;
+    }
+    function fix(child) {
+        var loc = child && child.loc;
+        var start = loc && loc.start;
+        var end = loc && copyPos(loc.end);
+        while (start && end && comparePos(start, end) < 0) {
+            lines.prevPos(end);
+            if (lines.charAt(end) === ";") {
+                // Update child.loc.end to *exclude* the ';' character.
+                loc.end.line = end.line;
+                loc.end.column = end.column;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    fix(node.init);
+    fix(node.test);
+    fix(node.update);
+}
+function fixTemplateLiteral(node, lines) {
+    if (node.type !== "TemplateLiteral") {
+        return;
+    }
+    if (node.quasis.length === 0) {
+        // If there are no quasi elements, then there is nothing to fix.
+        return;
+    }
+    // node.loc is not present when using export default with a template literal
+    if (node.loc) {
+        // First we need to exclude the opening ` from the .loc of the first
+        // quasi element, in case the parser accidentally decided to include it.
+        var afterLeftBackTickPos = copyPos(node.loc.start);
+        (0, tiny_invariant_1.default)(lines.charAt(afterLeftBackTickPos) === "`");
+        (0, tiny_invariant_1.default)(lines.nextPos(afterLeftBackTickPos));
+        var firstQuasi = node.quasis[0];
+        if (comparePos(firstQuasi.loc.start, afterLeftBackTickPos) < 0) {
+            firstQuasi.loc.start = afterLeftBackTickPos;
+        }
+        // Next we need to exclude the closing ` from the .loc of the last quasi
+        // element, in case the parser accidentally decided to include it.
+        var rightBackTickPos = copyPos(node.loc.end);
+        (0, tiny_invariant_1.default)(lines.prevPos(rightBackTickPos));
+        (0, tiny_invariant_1.default)(lines.charAt(rightBackTickPos) === "`");
+        var lastQuasi = node.quasis[node.quasis.length - 1];
+        if (comparePos(rightBackTickPos, lastQuasi.loc.end) < 0) {
+            lastQuasi.loc.end = rightBackTickPos;
+        }
+    }
+    // Now we need to exclude ${ and } characters from the .loc's of all
+    // quasi elements, since some parsers accidentally include them.
+    node.expressions.forEach(function (expr, i) {
+        // Rewind from expr.loc.start over any whitespace and the ${ that
+        // precedes the expression. The position of the $ should be the same
+        // as the .loc.end of the preceding quasi element, but some parsers
+        // accidentally include the ${ in the .loc of the quasi element.
+        var dollarCurlyPos = lines.skipSpaces(expr.loc.start, true, false);
+        if (lines.prevPos(dollarCurlyPos) &&
+            lines.charAt(dollarCurlyPos) === "{" &&
+            lines.prevPos(dollarCurlyPos) &&
+            lines.charAt(dollarCurlyPos) === "$") {
+            var quasiBefore = node.quasis[i];
+            if (comparePos(dollarCurlyPos, quasiBefore.loc.end) < 0) {
+                quasiBefore.loc.end = dollarCurlyPos;
+            }
+        }
+        // Likewise, some parsers accidentally include the } that follows
+        // the expression in the .loc of the following quasi element.
+        var rightCurlyPos = lines.skipSpaces(expr.loc.end, false, false);
+        if (lines.charAt(rightCurlyPos) === "}") {
+            (0, tiny_invariant_1.default)(lines.nextPos(rightCurlyPos));
+            // Now rightCurlyPos is technically the position just after the }.
+            var quasiAfter = node.quasis[i + 1];
+            if (comparePos(quasiAfter.loc.start, rightCurlyPos) < 0) {
+                quasiAfter.loc.start = rightCurlyPos;
+            }
+        }
+    });
+}
+function isExportDeclaration(node) {
+    if (node)
+        switch (node.type) {
+            case "ExportDeclaration":
+            case "ExportDefaultDeclaration":
+            case "ExportDefaultSpecifier":
+            case "DeclareExportDeclaration":
+            case "ExportNamedDeclaration":
+            case "ExportAllDeclaration":
+                return true;
+        }
+    return false;
+}
+exports.isExportDeclaration = isExportDeclaration;
+function getParentExportDeclaration(path) {
+    var parentNode = path.getParentNode();
+    if (path.getName() === "declaration" && isExportDeclaration(parentNode)) {
+        return parentNode;
+    }
+    return null;
+}
+exports.getParentExportDeclaration = getParentExportDeclaration;
+function isTrailingCommaEnabled(options, context) {
+    var trailingComma = options.trailingComma;
+    if (typeof trailingComma === "object") {
+        return !!trailingComma[context];
+    }
+    return !!trailingComma;
+}
+exports.isTrailingCommaEnabled = isTrailingCommaEnabled;

tools/ui/node_modules/recast/main.d.ts

@@ -0,0 +1,50 @@
+import * as types from "ast-types";
+import { parse } from "./lib/parser";
+import { Options } from "./lib/options";
+export { 
+/**
+ * Parse a string of code into an augmented syntax tree suitable for
+ * arbitrary modification and reprinting.
+ */
+parse, 
+/**
+ * Convenient shorthand for the ast-types package.
+ */
+types, };
+/**
+ * Traverse and potentially modify an abstract syntax tree using a
+ * convenient visitor syntax:
+ *
+ *   recast.visit(ast, {
+ *     names: [],
+ *     visitIdentifier: function(path) {
+ *       var node = path.value;
+ *       this.visitor.names.push(node.name);
+ *       this.traverse(path);
+ *     }
+ *   });
+ */
+export { visit } from "ast-types";
+/**
+ * Options shared between parsing and printing.
+ */
+export { Options } from "./lib/options";
+/**
+ * Reprint a modified syntax tree using as much of the original source
+ * code as possible.
+ */
+export declare function print(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType;
+/**
+ * Print without attempting to reuse any original source code.
+ */
+export declare function prettyPrint(node: types.ASTNode, options?: Options): import("./lib/printer").PrintResultType;
+/**
+ * Convenient command-line interface (see e.g. example/add-braces).
+ */
+export declare function run(transformer: Transformer, options?: RunOptions): void;
+export interface Transformer {
+    (ast: types.ASTNode, callback: (ast: types.ASTNode) => void): void;
+}
+export interface RunOptions extends Options {
+    writeback?(code: string): void;
+}

tools/ui/node_modules/recast/main.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.prettyPrint = exports.print = exports.visit = exports.types = exports.parse = void 0;
+var tslib_1 = require("tslib");
+var fs_1 = tslib_1.__importDefault(require("fs"));
+var types = tslib_1.__importStar(require("ast-types"));
+exports.types = types;
+var parser_1 = require("./lib/parser");
+Object.defineProperty(exports, "parse", { enumerable: true, get: function () { return parser_1.parse; } });
+var printer_1 = require("./lib/printer");
+/**
+ * Traverse and potentially modify an abstract syntax tree using a
+ * convenient visitor syntax:
+ *
+ *   recast.visit(ast, {
+ *     names: [],
+ *     visitIdentifier: function(path) {
+ *       var node = path.value;
+ *       this.visitor.names.push(node.name);
+ *       this.traverse(path);
+ *     }
+ *   });
+ */
+var ast_types_1 = require("ast-types");
+Object.defineProperty(exports, "visit", { enumerable: true, get: function () { return ast_types_1.visit; } });
+/**
+ * Reprint a modified syntax tree using as much of the original source
+ * code as possible.
+ */
+function print(node, options) {
+    return new printer_1.Printer(options).print(node);
+}
+exports.print = print;
+/**
+ * Print without attempting to reuse any original source code.
+ */
+function prettyPrint(node, options) {
+    return new printer_1.Printer(options).printGenerically(node);
+}
+exports.prettyPrint = prettyPrint;
+/**
+ * Convenient command-line interface (see e.g. example/add-braces).
+ */
+function run(transformer, options) {
+    return runFile(process.argv[2], transformer, options);
+}
+exports.run = run;
+function runFile(path, transformer, options) {
+    fs_1.default.readFile(path, "utf-8", function (err, code) {
+        if (err) {
+            console.error(err);
+            return;
+        }
+        runString(code, transformer, options);
+    });
+}
+function defaultWriteback(output) {
+    process.stdout.write(output);
+}
+function runString(code, transformer, options) {
+    var writeback = (options && options.writeback) || defaultWriteback;
+    transformer((0, parser_1.parse)(code, options), function (node) {
+        writeback(print(node, options).code);
+    });
+}

tools/ui/node_modules/recast/package.json

@@ -0,0 +1,74 @@
+{
+  "author": "Ben Newman <bn@cs.stanford.edu>",
+  "name": "recast",
+  "version": "0.23.11",
+  "description": "JavaScript syntax tree transformer, nondestructive pretty-printer, and automatic source map generator",
+  "keywords": [
+    "ast",
+    "rewriting",
+    "refactoring",
+    "codegen",
+    "syntax",
+    "transformation",
+    "parsing",
+    "pretty-printing"
+  ],
+  "homepage": "http://github.com/benjamn/recast",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/benjamn/recast.git"
+  },
+  "license": "MIT",
+  "main": "main.js",
+  "types": "main.d.ts",
+  "scripts": {
+    "mocha": "test/run.sh",
+    "debug": "test/run.sh --inspect-brk",
+    "test": "npm run lint && npm run build && npm run mocha",
+    "build": "npm run clean && tsc",
+    "lint": "eslint --ext .ts .",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "clean": "tsc --build --clean",
+    "prepare": "npm run build",
+    "postpack": "npm run clean"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint",
+      "prettier -c"
+    ]
+  },
+  "browser": {
+    "fs": false
+  },
+  "dependencies": {
+    "ast-types": "^0.16.1",
+    "esprima": "~4.0.0",
+    "source-map": "~0.6.1",
+    "tiny-invariant": "^1.3.3",
+    "tslib": "^2.0.1"
+  },
+  "devDependencies": {
+    "@babel/core": "7.20.5",
+    "@babel/parser": "7.20.5",
+    "@babel/preset-env": "7.20.2",
+    "@types/esprima": "4.0.3",
+    "@types/glob": "8.0.0",
+    "@types/mocha": "10.0.1",
+    "@types/node": "18.11.15",
+    "@typescript-eslint/parser": "^5.47.1",
+    "eslint": "^8.40.0",
+    "esprima-fb": "15001.1001.0-dev-harmony-fb",
+    "flow-parser": "0.195.0",
+    "glob": "8.0.3",
+    "lint-staged": "^13.2.2",
+    "mocha": "^10.2.0",
+    "prettier": "^2.6.2",
+    "reify": "0.20.12",
+    "typescript": "^4.9.4"
+  },
+  "engines": {
+    "node": ">= 4"
+  }
+}

tools/ui/node_modules/recast/parsers/_babel_options.d.ts

@@ -0,0 +1,8 @@
+import { ParserOptions, ParserPlugin } from "@babel/parser";
+export type Overrides = Partial<{
+    sourceType: ParserOptions["sourceType"];
+    strictMode: ParserOptions["strictMode"];
+}>;
+export default function getBabelOptions(options?: Overrides): ParserOptions & {
+    plugins: ParserPlugin[];
+};

tools/ui/node_modules/recast/parsers/_babel_options.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var util_1 = require("../lib/util");
+function getBabelOptions(options) {
+    // The goal here is to tolerate as much syntax as possible, since Recast
+    // is not in the business of forbidding anything. If you want your
+    // parser to be more restrictive for some reason, you can always pass
+    // your own parser object to recast.parse.
+    return {
+        sourceType: (0, util_1.getOption)(options, "sourceType", "module"),
+        strictMode: (0, util_1.getOption)(options, "strictMode", false),
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+        startLine: 1,
+        tokens: true,
+        plugins: [
+            "asyncGenerators",
+            "bigInt",
+            "classPrivateMethods",
+            "classPrivateProperties",
+            "classProperties",
+            "classStaticBlock",
+            "decimal",
+            "decorators-legacy",
+            "doExpressions",
+            "dynamicImport",
+            "exportDefaultFrom",
+            "exportExtensions",
+            "exportNamespaceFrom",
+            "functionBind",
+            "functionSent",
+            "importAssertions",
+            "importMeta",
+            "nullishCoalescingOperator",
+            "numericSeparator",
+            "objectRestSpread",
+            "optionalCatchBinding",
+            "optionalChaining",
+            [
+                "pipelineOperator",
+                {
+                    proposal: "minimal",
+                },
+            ],
+            [
+                "recordAndTuple",
+                {
+                    syntaxType: "hash",
+                },
+            ],
+            "throwExpressions",
+            "topLevelAwait",
+            "v8intrinsic",
+        ],
+    };
+}
+exports.default = getBabelOptions;

tools/ui/node_modules/recast/parsers/acorn.d.ts

@@ -0,0 +1 @@
+export declare function parse(source: string, options?: any): any;

tools/ui/node_modules/recast/parsers/acorn.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+// This module is suitable for passing as options.parser when calling
+// recast.parse to process JavaScript code with Acorn:
+//
+//   const ast = recast.parse(source, {
+//     parser: require("recast/parsers/acorn")
+//   });
+//
+var util_1 = require("../lib/util");
+function parse(source, options) {
+    var comments = [];
+    var tokens = [];
+    var ast = require("acorn").parse(source, {
+        allowHashBang: true,
+        allowImportExportEverywhere: true,
+        allowReturnOutsideFunction: true,
+        ecmaVersion: (0, util_1.getOption)(options, "ecmaVersion", 8),
+        sourceType: (0, util_1.getOption)(options, "sourceType", "module"),
+        locations: true,
+        onComment: comments,
+        onToken: tokens,
+    });
+    if (!ast.comments) {
+        ast.comments = comments;
+    }
+    if (!ast.tokens) {
+        ast.tokens = tokens;
+    }
+    return ast;
+}
+exports.parse = parse;

tools/ui/node_modules/recast/parsers/babel-ts.d.ts

@@ -0,0 +1,4 @@
+import { parser } from "./babel";
+import { Overrides } from "./_babel_options";
+export { parser };
+export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult<import("@babel/types").File>;

tools/ui/node_modules/recast/parsers/babel-ts.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.parser = void 0;
+var tslib_1 = require("tslib");
+var babel_1 = require("./babel");
+Object.defineProperty(exports, "parser", { enumerable: true, get: function () { return babel_1.parser; } });
+var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options"));
+function parse(source, options) {
+    var babelOptions = (0, _babel_options_1.default)(options);
+    babelOptions.plugins.push("jsx", "typescript");
+    return babel_1.parser.parse(source, babelOptions);
+}
+exports.parse = parse;

tools/ui/node_modules/recast/parsers/babel.d.ts

@@ -0,0 +1,8 @@
+import { parse as babelParse } from "@babel/parser";
+import { Overrides } from "./_babel_options";
+type BabelParser = {
+    parse: typeof babelParse;
+};
+export declare const parser: BabelParser;
+export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult<import("@babel/types").File>;
+export {};

tools/ui/node_modules/recast/parsers/babel.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = exports.parser = void 0;
+var tslib_1 = require("tslib");
+var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options"));
+// Prefer the new @babel/parser package, but fall back to babylon if
+// that's what's available.
+exports.parser = (function () {
+    try {
+        return require("@babel/parser");
+    }
+    catch (_a) {
+        try {
+            return require("babylon");
+        }
+        catch (_b) {
+            throw new Error("Install @babel/parser to use the `typescript`, `flow`, or `babel` parsers");
+        }
+    }
+})();
+// This module is suitable for passing as options.parser when calling
+// recast.parse to process JavaScript code with Babel:
+//
+//   const ast = recast.parse(source, {
+//     parser: require("recast/parsers/babel")
+//   });
+//
+function parse(source, options) {
+    var babelOptions = (0, _babel_options_1.default)(options);
+    babelOptions.plugins.push("jsx", "flow", "decoratorAutoAccessors");
+    return exports.parser.parse(source, babelOptions);
+}
+exports.parse = parse;

tools/ui/node_modules/recast/parsers/babylon.d.ts

@@ -0,0 +1 @@
+export * from "./babel";

tools/ui/node_modules/recast/parsers/babylon.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./babel"), exports);

tools/ui/node_modules/recast/parsers/esprima.d.ts

@@ -0,0 +1 @@
+export declare function parse(source: string, options?: any): any;

tools/ui/node_modules/recast/parsers/esprima.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+// This module is suitable for passing as options.parser when calling
+// recast.parse to process ECMAScript code with Esprima:
+//
+//   const ast = recast.parse(source, {
+//     parser: require("recast/parsers/esprima")
+//   });
+//
+var util_1 = require("../lib/util");
+function parse(source, options) {
+    var comments = [];
+    var ast = require("esprima").parse(source, {
+        loc: true,
+        locations: true,
+        comment: true,
+        onComment: comments,
+        range: (0, util_1.getOption)(options, "range", false),
+        tolerant: (0, util_1.getOption)(options, "tolerant", true),
+        tokens: true,
+        jsx: (0, util_1.getOption)(options, "jsx", false),
+        sourceType: (0, util_1.getOption)(options, "sourceType", "module"),
+    });
+    if (!Array.isArray(ast.comments)) {
+        ast.comments = comments;
+    }
+    return ast;
+}
+exports.parse = parse;

tools/ui/node_modules/recast/parsers/flow.d.ts

@@ -0,0 +1,2 @@
+import { Overrides } from "./_babel_options";
+export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult<import("@babel/types").File>;

tools/ui/node_modules/recast/parsers/flow.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+var tslib_1 = require("tslib");
+var babel_1 = require("./babel");
+var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options"));
+// This module is suitable for passing as options.parser when calling
+// recast.parse to process Flow code:
+//
+//   const ast = recast.parse(source, {
+//     parser: require("recast/parsers/flow")
+//   });
+//
+function parse(source, options) {
+    var babelOptions = (0, _babel_options_1.default)(options);
+    babelOptions.plugins.push("jsx", "flow");
+    return babel_1.parser.parse(source, babelOptions);
+}
+exports.parse = parse;

tools/ui/node_modules/recast/parsers/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Overrides } from "./_babel_options";
+export declare function parse(source: string, options?: Overrides): import("@babel/parser").ParseResult<import("@babel/types").File>;

tools/ui/node_modules/recast/parsers/typescript.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+var tslib_1 = require("tslib");
+var babel_1 = require("./babel");
+var _babel_options_1 = tslib_1.__importDefault(require("./_babel_options"));
+// This module is suitable for passing as options.parser when calling
+// recast.parse to process TypeScript code:
+//
+//   const ast = recast.parse(source, {
+//     parser: require("recast/parsers/typescript")
+//   });
+//
+function parse(source, options) {
+    var babelOptions = (0, _babel_options_1.default)(options);
+    babelOptions.plugins.push("typescript");
+    return babel_1.parser.parse(source, babelOptions);
+}
+exports.parse = parse;

tools/ui/node_modules/recast/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "es5",
+    "lib": ["es2015"],
+    "module": "commonjs",
+    "declaration": true,
+    "rootDir": ".",
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "importHelpers": true,
+    "stripInternal": true
+  },
+  "exclude": ["node_modules", "test/data"]
+}

tools/ui/node_modules/redent/index.d.ts

@@ -0,0 +1,27 @@
+import {Options as IndentStringOptions} from 'indent-string';
+
+declare namespace redent {
+	type Options = IndentStringOptions;
+}
+
+/**
+[Strip redundant indentation](https://github.com/sindresorhus/strip-indent) and [indent the string](https://github.com/sindresorhus/indent-string).
+
+@param string - The string to normalize indentation.
+@param count - How many times you want `options.indent` repeated. Default: `0`.
+
+@example
+```
+import redent = require('redent');
+
+redent('\n  foo\n    bar\n', 1);
+//=> '\n foo\n   bar\n'
+```
+*/
+declare function redent(
+	string: string,
+	count?: number,
+	options?: redent.Options
+): string;
+
+export = redent;

tools/ui/node_modules/redent/index.js

@@ -0,0 +1,5 @@
+'use strict';
+const stripIndent = require('strip-indent');
+const indentString = require('indent-string');
+
+module.exports = (string, count = 0, options) => indentString(stripIndent(string), count, options);

tools/ui/node_modules/redent/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (sindresorhus.com)
+
+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.

tools/ui/node_modules/redent/package.json

@@ -0,0 +1,44 @@
+{
+	"name": "redent",
+	"version": "3.0.0",
+	"description": "Strip redundant indentation and indent the string",
+	"license": "MIT",
+	"repository": "sindresorhus/redent",
+	"author": {
+		"name": "Sindre Sorhus",
+		"email": "sindresorhus@gmail.com",
+		"url": "sindresorhus.com"
+	},
+	"engines": {
+		"node": ">=8"
+	},
+	"scripts": {
+		"test": "xo && ava && tsd"
+	},
+	"files": [
+		"index.js",
+		"index.d.ts"
+	],
+	"keywords": [
+		"string",
+		"strip",
+		"trim",
+		"indent",
+		"indentation",
+		"add",
+		"reindent",
+		"normalize",
+		"remove",
+		"whitespace",
+		"space"
+	],
+	"dependencies": {
+		"indent-string": "^4.0.0",
+		"strip-indent": "^3.0.0"
+	},
+	"devDependencies": {
+		"ava": "^1.4.1",
+		"tsd": "^0.7.2",
+		"xo": "^0.24.0"
+	}
+}

tools/ui/node_modules/redent/readme.md

@@ -0,0 +1,61 @@
+# redent [![Build Status](https://travis-ci.org/sindresorhus/redent.svg?branch=master)](https://travis-ci.org/sindresorhus/redent)
+
+> [Strip redundant indentation](https://github.com/sindresorhus/strip-indent) and [indent the string](https://github.com/sindresorhus/indent-string)
+
+
+## Install
+
+```
+$ npm install redent
+```
+
+
+## Usage
+
+```js
+const redent = require('redent');
+
+redent('\n  foo\n    bar\n', 1);
+//=> '\n foo\n   bar\n'
+```
+
+
+## API
+
+### redent(string, [count], [options])
+
+#### string
+
+Type: `string`
+
+The string to normalize indentation.
+
+#### count
+
+Type: `number`<br>
+Default: `0`
+
+How many times you want `options.indent` repeated.
+
+#### options
+
+Type: `object`
+
+##### indent
+
+Type: `string`<br>
+Default: `' '`
+
+The string to use for the indent.
+
+##### includeEmptyLines
+
+Type: `boolean`<br>
+Default: `false`
+
+Also indent empty lines.
+
+
+## License
+
+MIT © [Sindre Sorhus](https://sindresorhus.com)

tools/ui/node_modules/reflect.getprototypeof/.eslintrc

@@ -0,0 +1,17 @@
+{
+	"root": true,
+
+	"extends": "@ljharb",
+
+	"rules": {
+		"id-length": 0,
+		"max-statements": [2, 25],
+		"new-cap": [2, {
+			"capIsNewExceptions": [
+				"GetIntrinsic",
+				"IsCallable",
+				"Type",
+			],
+		}],
+	},
+}

tools/ui/node_modules/reflect.getprototypeof/.nycrc

@@ -0,0 +1,9 @@
+{
+	"all": true,
+	"check-coverage": false,
+	"reporter": ["text-summary", "text", "html", "json"],
+	"exclude": [
+		"coverage",
+		"test"
+	]
+}

tools/ui/node_modules/reflect.getprototypeof/CHANGELOG.md

@@ -0,0 +1,115 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [v1.0.10](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.9...v1.0.10) - 2025-01-02
+
+### Commits
+
+- [Refactor] use `es-object-atoms` and `get-proto` directly [`2c55da0`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/2c55da02fb56d9ce7a19e505f487dfb088256d24)
+- [Refactor] use `isObject` helper instead of `Type` [`e4c24a4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e4c24a4cc1b9928da3eb1f0a032703235d32855e)
+- [Deps] update `es-abstract`, `get-intrinsic` [`54005fb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/54005fb9df56fb399e0c526600cb7799d23ef64f)
+- [Deps] update `es-abstract` [`e71b3b7`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e71b3b75847d4af71e42ff049bd2b4d55f0324fc)
+
+## [v1.0.9](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.8...v1.0.9) - 2024-12-18
+
+### Commits
+
+- [Fix] avoid a crash with node `--disable-proto=throw` flag [`73f449d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/73f449dff08fe574a4cd937d7265aceb1774de05)
+- [Deps] update `dunder-proto`, `es-abstract`, `get-intrinsic`, `which-builtin-type` [`80c8227`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/80c8227aac6cef446ac8460f8bbdd9a83bd1d131)
+
+## [v1.0.8](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.7...v1.0.8) - 2024-12-06
+
+### Commits
+
+- [Refactor] share the getDunderProto helper [`f4be71b`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f4be71b2941f217311210a00d84d8338b4880e2a)
+- [Refactor] extract helper to `dunder-proto` [`51dcd35`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/51dcd3547ef9808c9fee7aa4a638d3d5d93db70c)
+- [Deps] update `call-bind` [`c06e8d3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c06e8d3c1c9b567ca5bd6bb8542ae2e342f276ff)
+- [Deps] update `gopd` [`c951a70`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c951a709d5483fecc4041287a676d881295d1940)
+- [Deps] update `gopd` [`8bd7b85`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/8bd7b8524aacc0574c979e3fe4f82adc51b03f3f)
+- [Deps] update `which-builtin-type` [`f46f624`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f46f62423c1c452063f73d34a363c127410742b2)
+
+## [v1.0.7](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.6...v1.0.7) - 2024-11-23
+
+### Commits
+
+- [Fix] cache `Object.prototype[__proto__]` getter [`68acea1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/68acea171951197f83bb107af9e186ce68a5a78f)
+- [Tests] remove unused test file [`055596a`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/055596aa2e050e08d35f8f19aa642e9b61a54f7f)
+- [actions] split out node 10-20, and 20+ [`99a57c2`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/99a57c2551d11de70ea90b934e02b04ff3cec6c0)
+- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `auto-changelog`, `tape` [`fe4bb92`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/fe4bb92a4d629e629f42f76567d837f8f17643a4)
+- [Deps] update `es-abstract`, `globalthis`, `which-builtin-type` [`867aeb3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/867aeb3c434ee03fd819da09d23a32a2c71290dc)
+- [Tests] replace `aud` with `npm audit` [`5129c11`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/5129c112e18e3475afe42a836ac5d4d7ddfcfc18)
+- [Deps] remove unused dep; add missing dev dep [`23cf537`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/23cf537aeac98bf27a8d39e24048e1c9fa4df7a7)
+- [Dev Deps] add missing peer dep [`18862fa`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/18862fa57d2aa86825998db935ac6ffe23dec113)
+
+## [v1.0.6](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.5...v1.0.6) - 2024-03-16
+
+### Commits
+
+- [meta] remove useless ESM [`cc16ab1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/cc16ab1f3b050c9465b41fbbf79e284e8e9084ff)
+- [Deps] update `call-bind`, `es-abstract`, `es-errors`, `get-intrinsic` [`ece7445`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/ece7445f03d148c67f5fc91ea455a05731b54cea)
+- [Dev Deps] update `tape` [`a894b62`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/a894b624c16247cbb76a00e76a39e3d44ac5bccf)
+
+## [v1.0.5](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.4...v1.0.5) - 2024-02-04
+
+### Commits
+
+- [Refactor] use `es-errors` where possible, so things that only need those do not need `get-intrinsic` [`08735cb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/08735cba1dfeabae4e362b61e6de36843a472d22)
+- [Deps] update `call-bind`, `define-properties`, `es-abstract`, `get-intrinsic` [`b5700ec`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/b5700eca8af88bbc693b304567d6124d13c03827)
+- [Dev Deps] update `aud`, `npmignore`, `tape` [`f80fcbb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/f80fcbb140661c07aa2a94547ffae0a5a8f937ac)
+
+## [v1.0.4](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.3...v1.0.4) - 2023-08-30
+
+### Commits
+
+- [Deps] update `define-properties`, `es-abstract`, `get-intrinsic` [`325044f`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/325044f152c87f18344ba558b5967e69298a5dd2)
+- [Dev Deps] update `@es-shims/api`, `@ljharb/eslint-config`, `aud`, `tape` [`56b9555`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/56b9555a536207493c4e2c17f1fee2390535a659)
+
+## [v1.0.3](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.2...v1.0.3) - 2022-11-07
+
+### Commits
+
+- [actions] reuse common workflows [`0a76d97`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/0a76d972c13cd319504d3eecf8e7e00e39327c88)
+- [meta] use `npmignore` to autogenerate an npmignore file [`c4861b4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/c4861b45aeebddd1d998bdd44438b29e4bf974e8)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `safe-publish-latest`, `tape` [`e5352ab`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/e5352ab099f7104c085ffd2ee8fbfec69546fa2c)
+- [actions] update codecov uploader [`dbcedf8`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/dbcedf83e967e17316fc98fb18011c603bb54823)
+- [Deps] update `define-properties`, `es-abstract`, `globalthis`, `which-builtin-type` [`84fbfab`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/84fbfabe53774587be4748df303cec8acded7c0f)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `auto-changelog`, `tape` [`75dc8a3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/75dc8a337f11f11a947241c968bb7f5b843a1d17)
+- [actions] update rebase action to use reusable workflow [`49463a7`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/49463a7a6d9aaa08c201ff4206efcade7a997175)
+- [Dev Deps] update `@es-shims/api` [`adf75cb`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/adf75cb9dbda9052437a8e48e33da28dc52aa63c)
+
+## [v1.0.2](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.1...v1.0.2) - 2021-10-03
+
+### Commits
+
+- [Deps] update `es-abstract` [`947bbb1`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/947bbb1bff0cc08ab80bb809a19771c6087e9fda)
+- [actions] update workflows` [`af4708d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/af4708d75212ee5781b549b1ff86f903fc659e3f)
+
+## [v1.0.1](https://github.com/es-shims/Reflect.getPrototypeOf/compare/v1.0.0...v1.0.1) - 2021-09-08
+
+### Commits
+
+- [actions] use `node/install` instead of `node/run`; use `codecov` action [`86f4aa3`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/86f4aa392c73220ecb561d644def5c3efab4f9f5)
+- [Refactor] remove unnecessary ESM files [`162e4bf`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/162e4bfb58fb4eba6f2f26f11b0f46a8ea6587a7)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `@es-shims/api`, `aud`, `auto-changelog`, `tape` [`5515a8d`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/5515a8d17fc1978792db7e57a79f7f2fa60dc55e)
+- [Dev Deps] update `eslint`, `@ljharb/eslint-config`, `aud`, `tape` [`db05b43`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/db05b43dff616acab04544ab04bd385d462b8572)
+- [readme] add github actions/codecov badges [`d9ea295`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/d9ea295264f1d415b5083b3d4116b14a5a8ee7ff)
+- [Deps] update `es-abstract`, `which-builtin-type` [`1753dee`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1753deeaadbd66bb65e140e4bc81cee6652f07cd)
+- [Dev Deps] update `eslint`, `tape` [`4bce2db`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/4bce2db34c4182edd0bf3610eaeb1ea42844ee15)
+- [Deps] update `es-abstract`, `get-intrinsic` [`1dca685`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1dca685d1e5305b6720882ac8f4d5038a8309431)
+- [meta] use `prepublishOnly` script for npm 7+ [`1108273`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/1108273eba643ac8b135d177c21dd371ccb32901)
+- [actions] update workflows [`8674d66`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/8674d662705675531d216bdba2b7e1e26be1b12b)
+- [Deps] update `es-abstract` [`4e4fdcf`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/4e4fdcf854f3cd71d71aa80723664f5d2b814dad)
+
+## v1.0.0 - 2021-01-12
+
+### Commits
+
+- es-shims initial commit [`ffd0b98`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/ffd0b980b47f0b2db6bc3373364e950f6fce33cb)
+- Initial commit [`64c868f`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/64c868fa1bb3630f4ab823aaba98d0f28b3f8078)
+- [meta] add Automatic Rebase and Require Allow Edits workflows [`6a006b4`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/6a006b4ddebfe68fd23b2870c83aadefecf80b04)
+- [meta] Only apps should have lockfiles [`d1a29b5`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/d1a29b5b37d31129ecc1fecac1922d4c4935f9fa)
+- [Deps] update `call-bind` [`bfcc1a0`](https://github.com/es-shims/Reflect.getPrototypeOf/commit/bfcc1a0bd04fffe5fe53e791dd40f7988bbd5d03)

tools/ui/node_modules/reflect.getprototypeof/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ECMAScript Shims
+
+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.

tools/ui/node_modules/reflect.getprototypeof/README.md

@@ -0,0 +1,77 @@
+# reflect.getprototypeof <sup>[![Version Badge][npm-version-svg]][package-url]</sup>
+
+[![github actions][actions-image]][actions-url]
+[![coverage][codecov-image]][codecov-url]
+[![dependency status][deps-svg]][deps-url]
+[![dev dependency status][dev-deps-svg]][dev-deps-url]
+[![License][license-image]][license-url]
+[![Downloads][downloads-image]][downloads-url]
+
+[![npm badge][npm-badge-png]][package-url]
+
+An ES2015 mostly-spec-compliant `Reflect.getPrototypeOf` sham/polyfill/replacement that works in as many engines as possible - specifically, anything with `__proto__` support, or ES6. Built-in types will also work correctly in older engines.
+
+This package implements the [es-shim API](https://github.com/es-shims/api) interface. It works in an ES3-supported environment and complies with the [spec](https://www.ecma-international.org/ecma-262/5.1/).
+
+## Example
+
+```js
+var getPrototypeOf = require('reflect.getprototypeof');
+var assert = require('assert');
+
+assert.throws(() => getPrototypeOf(true));
+assert.throws(() => getPrototypeOf(42));
+assert.throws(() => getPrototypeOf(''));
+assert.equal(getPrototypeOf(/a/g), RegExp.prototype);
+assert.equal(getPrototypeOf(new Date()), Date.prototype);
+assert.equal(getPrototypeOf(function () {}), Function.prototype);
+assert.equal(getPrototypeOf([]), Array.prototype);
+assert.equal(getPrototypeOf({}), Object.prototype);
+```
+
+```js
+var getPrototypeOf = require('reflect.getprototypeof');
+var assert = require('assert');
+/* when Reflect or Reflect.getPrototypeOf is not present */
+if (typeof Reflect === 'object') { delete Reflect.getPrototypeOf; }
+delete globalThis.Reflect;
+var shimmed = getPrototypeOf.shim();
+assert.equal(shimmed, getPrototypeOf.getPolyfill());
+
+assert.throws(() => Reflect.getPrototypeOf(true));
+assert.throws(() => Reflect.getPrototypeOf(42));
+assert.throws(() => Reflect.getPrototypeOf(''));
+assert.equal(Reflect.getPrototypeOf(/a/g), RegExp.prototype);
+assert.equal(Reflect.getPrototypeOf(new Date()), Date.prototype);
+assert.equal(Reflect.getPrototypeOf(function () {}), Function.prototype);
+assert.equal(Reflect.getPrototypeOf([]), Array.prototype);
+assert.equal(Reflect.getPrototypeOf({}), Object.prototype);
+```
+
+```js
+var getPrototypeOf = require('reflect.getprototypeof');
+var assert = require('assert');
+/* when Reflect.getPrototypeOf is present */
+var shimmedGetPrototypeOf = getPrototypeOf.shim();
+assert.equal(shimmedGetPrototypeOf, Reflect.getPrototypeOf);
+assert.equal(Reflect.getPrototypeOf([]), Array.prototype);
+```
+
+## Tests
+Simply clone the repo, `npm install`, and run `npm test`
+
+[package-url]: https://npmjs.org/package/reflect.getprototypeof
+[npm-version-svg]: https://versionbadg.es/es-shims/Reflect.getPrototypeOf.svg
+[deps-svg]: https://david-dm.org/es-shims/Reflect.getPrototypeOf.svg
+[deps-url]: https://david-dm.org/es-shims/Reflect.getPrototypeOf
+[dev-deps-svg]: https://david-dm.org/es-shims/Reflect.getPrototypeOf/dev-status.svg
+[dev-deps-url]: https://david-dm.org/es-shims/Reflect.getPrototypeOf#info=devDependencies
+[npm-badge-png]: https://nodei.co/npm/reflect.getprototypeof.png?downloads=true&stars=true
+[license-image]: https://img.shields.io/npm/l/reflect.getprototypeof.svg
+[license-url]: LICENSE
+[downloads-image]: https://img.shields.io/npm/dm/reflect.getprototypeof.svg
+[downloads-url]: https://npm-stat.com/charts.html?package=reflect.getprototypeof
+[codecov-image]: https://codecov.io/gh/es-shims/Reflect.getPrototypeOf/branch/main/graphs/badge.svg
+[codecov-url]: https://app.codecov.io/gh/es-shims/Reflect.getPrototypeOf/
+[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/es-shims/Reflect.getPrototypeOf
+[actions-url]: https://github.com/es-shims/Reflect.getPrototypeOf/actions

tools/ui/node_modules/reflect.getprototypeof/auto.js

@@ -0,0 +1,3 @@
+'use strict';
+
+require('./shim')();

tools/ui/node_modules/reflect.getprototypeof/implementation.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var GetIntrinsic = require('get-intrinsic');
+var IsCallable = require('es-abstract/2024/IsCallable');
+var isObject = require('es-abstract/helpers/isObject');
+var whichBuiltinType = require('which-builtin-type');
+var $TypeError = require('es-errors/type');
+
+var gPO = require('get-proto');
+var $Object = require('es-object-atoms');
+
+module.exports = function getPrototypeOf(O) {
+	if (!isObject(O)) {
+		throw new $TypeError('Reflect.getPrototypeOf called on non-object');
+	}
+
+	if (gPO) {
+		return gPO(O);
+	}
+
+	var type = whichBuiltinType(O);
+	if (type) {
+		var intrinsic = GetIntrinsic('%' + type + '.prototype%', true);
+		if (intrinsic) {
+			return intrinsic;
+		}
+	}
+	if (IsCallable(O.constructor)) {
+		return O.constructor.prototype;
+	}
+	if (O instanceof Object) {
+		return $Object.prototype;
+	}
+
+	/*
+	 * Correctly return null for Objects created with `Object.create(null)` (shammed or native) or `{ __proto__: null}`.  Also returns null for
+	 * cross-realm objects on browsers that lack `__proto__` support (like IE <11), but that's the best we can do.
+	 */
+	return null;
+};

tools/ui/node_modules/reflect.getprototypeof/index.js

@@ -0,0 +1,18 @@
+'use strict';
+
+var callBind = require('call-bind');
+var define = require('define-properties');
+
+var implementation = require('./implementation');
+var getPolyfill = require('./polyfill');
+var shim = require('./shim');
+
+var bound = callBind(getPolyfill(), typeof Reflect === 'object' ? Reflect : Object);
+
+define(bound, {
+	getPolyfill: getPolyfill,
+	implementation: implementation,
+	shim: shim
+});
+
+module.exports = bound;

tools/ui/node_modules/reflect.getprototypeof/package.json

@@ -0,0 +1,98 @@
+{
+	"name": "reflect.getprototypeof",
+	"version": "1.0.10",
+	"description": "An ES2015 mostly-spec-compliant `Reflect.getPrototypeOf` sham/polyfill/replacement that works in as many engines as possible",
+	"main": "index.js",
+	"type": "commonjs",
+	"exports": {
+		".": "./index.js",
+		"./auto": "./auto.js",
+		"./polyfill": "./polyfill.js",
+		"./implementation": "./implementation.js",
+		"./shim": "./shim.js",
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"prepack": "npmignore --auto --commentLines=autogenerated",
+		"prepublish": "not-in-publish || npm run prepublishOnly",
+		"prepublishOnly": "safe-publish-latest",
+		"prelint": "evalmd README.md",
+		"lint": "eslint --ext=js,mjs .",
+		"postlint": "es-shim-api --bound",
+		"pretest": "npm run lint",
+		"tests-only": "nyc tape 'test/**/*.js'",
+		"test": "npm run tests-only",
+		"posttest": "npx npm@'>=10.2' audit --production",
+		"version": "auto-changelog && git add CHANGELOG.md",
+		"postversion": "auto-changelog && git add CHANGELOG.md && git commit --no-edit --amend && git tag -f \"v$(node -e \"console.log(require('./package.json').version)\")\""
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/es-shims/Reflect.getPrototypeOf.git"
+	},
+	"keywords": [
+		"Reflect.getPrototypeOf",
+		"Object.getPrototypeOf",
+		"proto",
+		"__proto__",
+		"[[Prototype]]",
+		"getPrototypeOf",
+		"ES5",
+		"shim",
+		"polyfill",
+		"es-shim API",
+		"browser"
+	],
+	"author": "Jordan Harband <ljharb@gmail.com>",
+	"funding": {
+		"url": "https://github.com/sponsors/ljharb"
+	},
+	"license": "MIT",
+	"bugs": {
+		"url": "https://github.com/es-shims/Reflect.getPrototypeOf/issues"
+	},
+	"homepage": "https://github.com/es-shims/Reflect.getPrototypeOf",
+	"engines": {
+		"node": ">= 0.4"
+	},
+	"dependencies": {
+		"call-bind": "^1.0.8",
+		"define-properties": "^1.2.1",
+		"es-abstract": "^1.23.9",
+		"es-errors": "^1.3.0",
+		"es-object-atoms": "^1.0.0",
+		"get-intrinsic": "^1.2.7",
+		"get-proto": "^1.0.1",
+		"which-builtin-type": "^1.2.1"
+	},
+	"devDependencies": {
+		"@es-shims/api": "^2.5.1",
+		"@ljharb/eslint-config": "^21.1.1",
+		"auto-changelog": "^2.5.0",
+		"encoding": "^0.1.13",
+		"eslint": "=8.8.0",
+		"evalmd": "^0.0.19",
+		"functions-have-names": "^1.2.3",
+		"in-publish": "^2.0.1",
+		"npmignore": "^0.3.1",
+		"nyc": "^10.3.2",
+		"safe-publish-latest": "^2.0.0",
+		"tape": "^5.9.0"
+	},
+	"auto-changelog": {
+		"output": "CHANGELOG.md",
+		"template": "keepachangelog",
+		"unreleased": false,
+		"commitLimit": false,
+		"backfillLimit": false,
+		"hideCredit": true
+	},
+	"publishConfig": {
+		"ignore": [
+			".github/workflows"
+		]
+	},
+	"testling": {
+		"files": "test/implementation.js"
+	}
+}

tools/ui/node_modules/reflect.getprototypeof/polyfill.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var implementation = require('./implementation');
+
+var getProto = require('get-proto');
+
+module.exports = function getPolyfill() {
+	if (typeof Reflect === 'object' && Reflect && Reflect.getPrototypeOf) {
+		return Reflect.getPrototypeOf;
+	}
+	return getProto
+		? function getPrototypeOf(O) { return getProto(O); }
+		: implementation;
+};

tools/ui/node_modules/reflect.getprototypeof/shim.js

@@ -0,0 +1,21 @@
+'use strict';
+
+var define = require('define-properties');
+var getPolyfill = require('./polyfill');
+
+module.exports = function shimGetPrototypeOf() {
+	define(
+		global,
+		{ Reflect: {} },
+		{ Reflect: function () { return typeof Reflect !== 'object' || !Reflect; } }
+	);
+
+	var polyfill = getPolyfill();
+	define(
+		Reflect,
+		{ getPrototypeOf: polyfill },
+		{ getPrototypeOf: function () { return Reflect.getPrototypeOf !== polyfill; } }
+	);
+
+	return polyfill;
+};

tools/ui/node_modules/reflect.getprototypeof/test/implementation.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var getPrototypeOf = require('../implementation');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+	runTests(getPrototypeOf, t);
+
+	t.end();
+});

tools/ui/node_modules/reflect.getprototypeof/test/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+var getPrototypeOf = require('../');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+	runTests(getPrototypeOf, t);
+
+	t.end();
+});

tools/ui/node_modules/reflect.getprototypeof/test/shimmed.js

@@ -0,0 +1,28 @@
+'use strict';
+
+require('../auto');
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+var runTests = require('./tests');
+
+test('shimmed', function (t) {
+	t.equal(Reflect.getPrototypeOf.length, 1, 'Reflect.getPrototypeOf has length of 1');
+	t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+		st.equal(Reflect.getPrototypeOf.name, 'getPrototypeOf', 'Reflect.getPrototypeOf has name "getPrototypeOf"');
+		st.end();
+	});
+
+	t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+		et.equal(false, isEnumerable.call(Reflect, 'getPrototypeOf'), 'Reflect.getPrototypeOf is not enumerable');
+		et.end();
+	});
+
+	runTests(Reflect.getPrototypeOf, t);
+
+	t.end();
+});