wice_grid 7.1.0 → 7.1.1

data/node_modules/recast/lib/mapping.js

@@ -1,202 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __importDefault(require("assert"));
-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 {
-                assert_1.default.strictEqual(name, "start");
-            }
-            return skipChars(sourceLines, sourceFromPos, lines, targetFromPos, targetToPos);
-        }
-        if (util_1.comparePos(start, targetLoc.start) <= 0) {
-            if (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 (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 (util_1.comparePos(targetLoc.end, start) <= 0) {
-                return null;
-            }
-            if (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 = util_1.comparePos(targetFromPos, targetToPos);
-    if (targetComparison === 0) {
-        // Trivial case: no characters to skip.
-        return sourceFromPos;
-    }
-    if (targetComparison < 0) {
-        // Skipping forward.
-        var sourceCursor = sourceLines.skipSpaces(sourceFromPos) || sourceLines.lastPos();
-        var 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 {
-            assert_1.default.strictEqual(lineDiff, 0);
-        }
-        while (util_1.comparePos(targetCursor, targetToPos) < 0 &&
-            targetLines.nextPos(targetCursor, true)) {
-            assert_1.default.ok(sourceLines.nextPos(sourceCursor, true));
-            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
-        }
-    }
-    else {
-        // Skipping backward.
-        var sourceCursor = sourceLines.skipSpaces(sourceFromPos, true) || sourceLines.firstPos();
-        var 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 {
-            assert_1.default.strictEqual(lineDiff, 0);
-        }
-        while (util_1.comparePos(targetToPos, targetCursor) < 0 &&
-            targetLines.prevPos(targetCursor, true)) {
-            assert_1.default.ok(sourceLines.prevPos(sourceCursor, true));
-            assert_1.default.strictEqual(sourceLines.charAt(sourceCursor), targetLines.charAt(targetCursor));
-        }
-    }
-    return sourceCursor;
-}

data/node_modules/recast/lib/options.d.ts

@@ -1,148 +0,0 @@
-import { Omit } from "ast-types/types";
-/**
- * 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 declare type NormalizedOptions = Required<Omit<Options, keyof DeprecatedOptions>>;
-export declare function normalize(opts?: Options): NormalizedOptions;
-export {};

data/node_modules/recast/lib/options.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var defaults = {
-    parser: require("../parsers/esprima"),
-    tabWidth: 4,
-    useTabs: false,
-    reuseWhitespace: true,
-    lineTerminator: require("os").EOL || "\n",
-    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;
-;

data/node_modules/recast/lib/parser.d.ts

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

data/node_modules/recast/lib/parser.js

@@ -1,257 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
-    result["default"] = mod;
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var assert_1 = __importDefault(require("assert"));
-var types = __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 = __importStar(require("./util"));
-function parse(source, options) {
-    options = options_1.normalize(options);
-    var lines = 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.
-    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) {
-    assert_1.default.ok(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 = new Array(node.length);
-        this.seen.set(node, copy);
-        node.forEach(function (item, i) {
-            copy[i] = this.copy(item);
-        }, this);
-        return copy;
-    }
-    if (!isObject.check(node)) {
-        return node;
-    }
-    util.fixFaultyLocations(node, this.lines);
-    var copy = Object.create(Object.getPrototypeOf(node), {
-        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;
-};

data/node_modules/recast/lib/patcher.d.ts

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