dequanto 0.0.1

package/dist/src/contracts/utils/TypeUtils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TypeUtils = void 0;
+var TypeUtils;
+(function (TypeUtils) {
+    function normalize(args) {
+        args = Array.from(args);
+        for (let i = 0; i < args.length; i++) {
+            let val = args[i];
+            if (val == null || typeof val !== 'object') {
+                continue;
+            }
+            if (Array.isArray(val)) {
+                args[i] = normalize(val);
+                continue;
+            }
+            if (val._isBigNumber) {
+                args[i] = BigInt(val.toString());
+            }
+        }
+        return args;
+    }
+    TypeUtils.normalize = normalize;
+})(TypeUtils = exports.TypeUtils || (exports.TypeUtils = {}));

package/dist/src/defi/OneInch/OneInchRouter.js

@@ -0,0 +1,14 @@
+"use strict";
+/**
+ * dequanto
+ * name: OneInchRouterV3Base
+ * platform: bsc
+ * source.abi: 0x11111112542d85b3ef69ae05771c2dccff4faa26
+ * output: ./contracts/gen/bsc/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OneInchRouterContract = void 0;
+const OneInchRouterV3Base_1 = require("../../../contracts/gen/bsc/OneInchRouterV3Base");
+class OneInchRouterContract extends OneInchRouterV3Base_1.OneInchRouterV3Base {
+}
+exports.OneInchRouterContract = OneInchRouterContract;

package/dist/src/env/BigIntSerializer.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BigIntSerializer = void 0;
+BigInt.prototype.toJSON = function () { return this.toString(); };
+BigInt.prototype.toBuffer = function () {
+    let hex = this.toString(16);
+    if (hex.length % 2 !== 0) {
+        hex = `0${hex}`;
+    }
+    return Buffer.from(hex, 'hex');
+};
+BigInt.prototype.valueOf = function () {
+    if (this > BigInt(Number.MAX_VALUE)) {
+        throw new Error(`BigInt to Number overfows: ${this}`);
+    }
+    return Number(this);
+};
+function BigIntSerializer() { }
+exports.BigIntSerializer = BigIntSerializer;

package/dist/src/gen/Ast.js

@@ -0,0 +1,12 @@
+"use strict";
+//import parser from '@solidity-parser/parser';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ast = void 0;
+class Ast {
+    static parse(source) {
+        // let ast = parser.parse(source, {
+        //     tolerant: true,
+        // });
+    }
+}
+exports.Ast = Ast;

package/dist/src/gen/ContractTemplate.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$NAME$ = void 0;
+/**
+ *  AUTO-Generated Class: $DATE$
+ *  Implementation: $EXPLORER_URL$
+ */
+const a_di_1 = __importDefault(require("a-di"));
+const ContractBase_1 = require("@dequanto/contracts/ContractBase");
+/* IMPORTS */
+class $NAME$ extends ContractBase_1.ContractBase {
+    constructor(address = '$ADDRESS$', client = a_di_1.default.resolve($EthWeb3Client$), explorer = a_di_1.default.resolve($Etherscan$)) {
+        super(address, client, explorer);
+        this.address = address;
+        this.client = client;
+        this.explorer = explorer;
+        /* METHODS */
+        /* EVENTS */
+        /* EVENTS_EXTRACTORS */
+        this.abi = $ABI$;
+    }
+}
+exports.$NAME$ = $NAME$;
+/* $EVENT_INTERFACES$ */

package/dist/src/gen/Generator.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Generator = void 0;
+const a_di_1 = __importDefault(require("a-di"));
+const alot_1 = __importDefault(require("alot"));
+const _address_1 = require("@dequanto/utils/$address");
+const _require_1 = require("@dequanto/utils/$require");
+const GeneratorFromAbi_1 = require("./GeneratorFromAbi");
+const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
+const BlockChainExplorerProvider_1 = require("@dequanto/BlockchainExplorer/BlockChainExplorerProvider");
+const KEYS = {
+    'platform': 1,
+    'name': 1,
+    'defaultAddress': 1,
+    'source.abi': 1,
+    'source.code': 1,
+    'output': 1,
+    'implementation': 1
+};
+class Generator {
+    constructor(options) {
+        this.options = options;
+        let { platform, } = options;
+        this.explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(platform);
+        if (options.defaultAddress == null && _address_1.$address.isValid(options.source.abi)) {
+            options.defaultAddress = options.source.abi;
+        }
+    }
+    static async generateForClass(path) {
+        let i = path.indexOf('*');
+        if (i > -1) {
+            let base = path.substring(0, i).replace(/\\/g, '/');
+            let glob = path.substring(i).replace(/\\/g, '/');
+            let files = await atma_io_1.Directory.readFilesAsync(base, glob);
+            await (0, alot_1.default)(files)
+                .forEachAsync(async (file) => {
+                await this.generateForClass(file.uri.toString());
+            })
+                .toArrayAsync({ threads: 1 });
+            return;
+        }
+        let jsCode = await atma_io_1.File.readAsync(path, { skipHooks: true });
+        let startIdx = jsCode.indexOf('/*');
+        let endIdx = jsCode.indexOf('*/');
+        if (startIdx === -1 || endIdx === -1) {
+            throw new Error(`${path} should contain dequanto options in comment`);
+        }
+        let header = jsCode.substring(startIdx, endIdx);
+        let lines = header.split('\n');
+        let rgxOpts = /(?<key>[\w.]+)\s*:\s*(?<value>[^\n]+)/;
+        let options = {};
+        for (let line of lines) {
+            let match = rgxOpts.exec(line);
+            if (match == null) {
+                continue;
+            }
+            let key = match.groups.key.trim();
+            let value = match.groups.value.trim();
+            if (value === 'true') {
+                value = true;
+            }
+            else if (value === 'false') {
+                value = false;
+            }
+            else if (/^[\d\.]$/.test(value)) {
+                value = Number(value);
+            }
+            if (key in KEYS === false) {
+                throw new Error(`Invalid options key ${key}`);
+            }
+            (0, atma_utils_1.obj_setProperty)(options, key, value);
+        }
+        // make Contracts in dequanto package relative to dequanto root
+        let rgxRoot = /[\\\/]dequanto[\\\/].+/;
+        if (rgxRoot.test(path)) {
+            let root = path.replace(rgxRoot, '/dequanto/');
+            options.output = atma_utils_1.class_Uri.combine(root, options.output);
+        }
+        let generator = new Generator({
+            ...options,
+            location: new atma_utils_1.class_Uri(path).toDir().toString()
+        });
+        await generator.generate();
+    }
+    async generate() {
+        let { name, platform: network, output, implementation: implSource } = this.options;
+        let { abiJson, implementation } = await this.getAbi({ implementation: implSource });
+        let sources = await this.getSources(implementation, name);
+        let generator = a_di_1.default.resolve(GeneratorFromAbi_1.GeneratorFromAbi);
+        let address = this.options.defaultAddress;
+        return await generator.generate(abiJson, {
+            network: network,
+            name: name,
+            address: address,
+            output: output,
+            implementation: implementation,
+            sources: sources,
+            saveAbi: this.options.saveAbi
+        });
+    }
+    async getAbi(opts) {
+        let abi = this.options.source.abi;
+        _require_1.$require.notNull(abi, `Abi not provided to get the Abi Json from`);
+        let abiJson;
+        let implementation;
+        if (abi.startsWith('0x')) {
+            let { abi, implementation: impl } = await this.getAbiByAddress(opts);
+            abiJson = abi;
+            implementation = impl;
+        }
+        else {
+            let path = abi;
+            let location = this.options.location;
+            if (location && path[0] !== '/') {
+                // if path not relative, check the file at ClassFile location
+                let relPath = atma_utils_1.class_Uri.combine(location, path);
+                if (await atma_io_1.File.existsAsync(relPath)) {
+                    path = relPath;
+                }
+            }
+            abiJson = await atma_io_1.File.readAsync(path);
+        }
+        _require_1.$require.notNull(abiJson, `Abi not resolved from ${abi}`);
+        return { abiJson, implementation };
+    }
+    async getSources(implementation, name) {
+        if (_address_1.$address.isValid(implementation) === false) {
+            return null;
+        }
+        console.log('Loading contract source code.');
+        let meta = await this.explorer.getContractSource(implementation);
+        if (meta?.SourceCode == null) {
+            console.log('No contract source found.');
+            return null;
+        }
+        if (/^\s*\{/.test(meta.SourceCode) === false) {
+            console.log('Source contract as single file fetched.');
+            return {
+                [`${name}.sol`]: {
+                    content: meta.SourceCode
+                }
+            };
+        }
+        let code = meta
+            .SourceCode
+            .replace(/\{\{/g, '{')
+            .replace(/\}\}/g, '}');
+        try {
+            let sources = JSON.parse(code);
+            let files = sources.sources;
+            console.log(`Source code (${Object.keys(files).join(', ')}) fetched.`);
+            return files;
+        }
+        catch (error) {
+            console.error(`Source code can't be parsed: `, code);
+            throw new Error(`Source code can't be parsed: ${error.message}`);
+        }
+    }
+    async getAbiByAddress(opts) {
+        let address = _address_1.$address.expectValid(this.options.source?.abi, 'contract address is not valid');
+        let explorer = _require_1.$require.notNull(this.explorer, `Explorer not resolved for network: ${this.options.platform}`);
+        try {
+            console.log(`Loading contracts ABI for ${address}. `);
+            let { abi, implementation } = await explorer.getContractAbi(address, opts);
+            let hasProxy = _address_1.$address.eq(address, implementation) === false;
+            console.log(`Proxy detected: ${hasProxy ? 'YES' : 'NO'}`, hasProxy ? implementation : '');
+            let abiJson = JSON.parse(abi);
+            return { abi: abiJson, implementation };
+        }
+        catch (error) {
+            console.error(error);
+            throw new Error(`ABI is not resolved from ${this.options.platform}/${address}: ${error.message ?? error}`);
+        }
+    }
+}
+exports.Generator = Generator;

package/dist/src/gen/GeneratorFromAbi.js

@@ -0,0 +1,361 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeneratorFromAbi = void 0;
+const atma_io_1 = require("atma-io");
+const atma_utils_1 = require("atma-utils");
+const alot_1 = __importDefault(require("alot"));
+const _abiType_1 = require("@dequanto/utils/$abiType");
+const _date_1 = require("@dequanto/utils/$date");
+const _path_1 = require("@dequanto/utils/$path");
+const _abiUtils_1 = require("@dequanto/utils/$abiUtils");
+class GeneratorFromAbi {
+    static get Gen() {
+        return Gen;
+    }
+    async generate(abiJson, opts) {
+        let methodsArr = abiJson
+            .map(item => {
+            if (item.type === 'function') {
+                return Gen.serializeMethodTs(item);
+            }
+            return null;
+        })
+            .filter(Boolean)
+            .map(Str.formatMethod);
+        ;
+        let eventsArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEvent(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+        ;
+        let eventsExtractorsArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventExtractor(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+        let eventInterfaces = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventInterface(x))
+            .filter(Boolean)
+            .map(Str.formatMethod);
+        ;
+        let methods = methodsArr.join('\n\n');
+        let events = eventsArr.join('\n\n');
+        let eventsExtractors = eventsExtractorsArr.join('\n\n');
+        let name = opts.name;
+        let templatePath = _path_1.$path.resolve(`/src/gen/ContractTemplate.ts`);
+        let template = await atma_io_1.File.readAsync(templatePath, { skipHooks: true });
+        let EtherscanStr;
+        let EthWeb3ClientStr;
+        let imports = [];
+        let explorerUrl;
+        switch (opts.network) {
+            case 'bsc':
+                EtherscanStr = 'Bscscan';
+                EthWeb3ClientStr = 'BscWeb3Client';
+                imports = [
+                    `import { Bscscan } from '@dequanto/BlockchainExplorer/Bscscan'`,
+                    `import { BscWeb3Client } from '@dequanto/clients/BscWeb3Client'`,
+                ];
+                explorerUrl = `https://bscscan.com/address/${opts.implementation}#code`;
+                break;
+            case 'polygon':
+                EtherscanStr = 'Polyscan';
+                EthWeb3ClientStr = 'PolyWeb3Client';
+                imports = [
+                    `import { Polyscan } from '@dequanto/BlockchainExplorer/Polyscan'`,
+                    `import { PolyWeb3Client } from '@dequanto/clients/PolyWeb3Client'`,
+                ];
+                explorerUrl = `https://polygonscan.com/address/${opts.implementation}#code`;
+                break;
+            case 'xdai':
+                EtherscanStr = 'XDaiscan';
+                EthWeb3ClientStr = 'XDaiWeb3Client';
+                imports = [
+                    `import { XDaiscan } from '@dequanto/chains/xdai/XDaiscan'`,
+                    `import { XDaiWeb3Client } from '@dequanto/chains/xdai/XDaiWeb3Client'`,
+                ];
+                explorerUrl = `https://blockscout.com/xdai/mainnet/address/${opts.implementation}/contracts`;
+                break;
+            case 'eth':
+                EtherscanStr = 'Etherscan';
+                EthWeb3ClientStr = 'EthWeb3Client';
+                imports = [
+                    `import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'`,
+                    `import { EthWeb3Client } from '@dequanto/clients/EthWeb3Client'`,
+                ];
+                explorerUrl = `https://etherscan.io/address/${opts.implementation}#code`;
+                break;
+            default:
+                throw new Error(`Unknown network ${opts.network}`);
+        }
+        let code = template
+            .replace(/\$Etherscan\$/g, EtherscanStr)
+            .replace(/\$EthWeb3Client\$/g, EthWeb3ClientStr)
+            .replace(`/* IMPORTS */`, imports.join('\n'))
+            .replace(`$NAME$`, Gen.toClassName(name))
+            .replace(`$ADDRESS$`, opts.address ?? '')
+            .replace(`/* METHODS */`, methods)
+            .replace(`/* EVENTS */`, events)
+            .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractors)
+            .replace(`$ABI$`, JSON.stringify(abiJson))
+            .replace(`$DATE$`, _date_1.$date.format(new Date(), 'yyyy-MM-dd HH:mm'))
+            .replace(`$EXPLORER_URL$`, explorerUrl)
+            .replace(`/* $EVENT_INTERFACES$ */`, eventInterfaces.join('\n'));
+        let directory = name;
+        let filename = /[^\\/]+$/.exec(name)[0];
+        let path = atma_utils_1.class_Uri.combine(opts.output, directory, `${filename}.ts`);
+        await atma_io_1.File.writeAsync(path, code, { skipHooks: true });
+        if (opts.saveAbi) {
+            let path = atma_utils_1.class_Uri.combine(opts.output, directory, `${filename}.json`);
+            await atma_io_1.File.writeAsync(path, abiJson);
+        }
+        console.log(`ABI wrapper class created: ${path}`);
+        let sources = opts.sources;
+        let sourceFiles = [];
+        if (sources) {
+            sourceFiles = await alot_1.default.fromObject(sources).mapAsync(async (entry) => {
+                let sourceFilename = /\/?([^/]+$)/.exec(entry.key)[1];
+                let path = atma_utils_1.class_Uri.combine(opts.output, directory, filename, sourceFilename);
+                await atma_io_1.File.writeAsync(path, entry.value.content, { skipHooks: true });
+                console.log(`Source code saved: ${path}`);
+                return path;
+            }).toArrayAsync();
+        }
+        return {
+            main: path,
+            sources: sourceFiles,
+        };
+    }
+}
+exports.GeneratorFromAbi = GeneratorFromAbi;
+var Gen;
+(function (Gen) {
+    function toClassName(name) {
+        let str = name.replace(/[^\w_\-\\/]/g, '');
+        str = str.replace(/[\-\\/](\w)/g, (full, letter) => {
+            return letter.toUpperCase();
+        });
+        return str[0].toUpperCase() + str.substring(1);
+    }
+    Gen.toClassName = toClassName;
+    function serializeMethodTs(abi) {
+        let isRead = isReader(abi);
+        if (isRead) {
+            return serializeReadMethodTs(abi);
+        }
+        return serializeWriteMethodTs(abi);
+    }
+    Gen.serializeMethodTs = serializeMethodTs;
+    function serializeEvent(abi) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        return `
+            on${abi.name} (fn: (event: EventData, ${fnInputArguments}) => void): ClientEventsStream<any> {
+                return this.$on('${abi.name}', fn);
+            }
+        `;
+    }
+    Gen.serializeEvent = serializeEvent;
+    function serializeEventExtractor(abi) {
+        return `
+            extractLogs${abi.name} (tx: TransactionReceipt): TLog${abi.name}[] {
+                let abi = this.$getAbiItem('event', '${abi.name}');
+                return this.$extractLogs(tx, abi) as any as TLog${abi.name}[];
+            }
+        `;
+    }
+    Gen.serializeEventExtractor = serializeEventExtractor;
+    function serializeEventInterface(abi) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        return `
+            type TLog${abi.name} = {
+                contract: TAddress,
+                ${fnInputArguments}
+            }
+        `;
+    }
+    Gen.serializeEventInterface = serializeEventInterface;
+    function isReader(abi) {
+        return ['view', 'pure', null].includes(abi.stateMutability);
+    }
+    Gen.isReader = isReader;
+    function serializeMethodAbi(abi, includeNames) {
+        let params = abi.inputs?.map(x => {
+            let param = x.type;
+            if (includeNames && x.name) {
+                param += ' ' + x.name;
+            }
+            return param;
+        }).join(', ') ?? '';
+        let returns = serializeMethodAbiReturns(abi.outputs);
+        if (returns && abi.outputs.length > 1) {
+            returns = `(${returns})`;
+        }
+        let returnsStr = returns ? `returns ${returns}` : '';
+        return `function ${abi.name}(${params}) ${returnsStr}`.trim();
+    }
+    Gen.serializeMethodAbi = serializeMethodAbi;
+    function serializeReadMethodTs(abi) {
+        let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
+        if (callInputArguments) {
+            callInputArguments = `, ${callInputArguments}`;
+        }
+        return `
+            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (${fnInputArguments}): ${fnResult} {
+                return this.$read('${serializeMethodAbi(abi)}'${callInputArguments});
+            }
+        `;
+    }
+    function serializeWriteMethodTs(abi) {
+        let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
+        if (callInputArguments) {
+            callInputArguments = `, ${callInputArguments}`;
+        }
+        return `
+            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (eoa: {address: TAddress, key: string, value?: string | number | bigint }, ${fnInputArguments}): Promise<TxWriter> {
+                return this.$write(this.$getAbiItem('function', '${abi.name}'), eoa${callInputArguments});
+            }
+        `;
+    }
+    function serializeArgumentsTs(abi) {
+        let inputs = abi.inputs.map((input, i) => {
+            let result = { ...input };
+            if (result.name == null || result.name === '') {
+                result.name = 'input' + i;
+            }
+            return result;
+        });
+        let fnInputArguments = inputs
+            ?.map((input) => {
+            let tsType = _abiType_1.$abiType.getTsType(input.type, input);
+            if (tsType == null) {
+                throw new Error(`Unknown abi type in arguments: ${input.type}`);
+            }
+            return `${input.name}: ${tsType}`;
+        })
+            ?.join(', ') ?? '';
+        let callInputArguments = inputs
+            ?.map(input => {
+            return `${input.name}`;
+        })
+            ?.join(', ') ?? '';
+        let fnResult = serializeMethodTsReturns(abi.outputs);
+        return { fnInputArguments, callInputArguments, fnResult };
+    }
+    function isObjectParams(params) {
+        return params?.every(x => Boolean(x.name));
+    }
+    function serializeMethodAbiReturns(params) {
+        if (params == null) {
+            return '';
+        }
+        // if (isObjectParams(params)) {
+        //     return params.map(x => serializeMethodAbiReturnsSingle(x)).join(',');
+        // }
+        return params?.map(x => serializeMethodAbiReturnsSingle(x)).join(',');
+    }
+    function serializeMethodAbiReturnsSingle(param) {
+        if (param == null) {
+            return null;
+        }
+        if (param.components) {
+            // tuple, tuple[]
+            let fields = serializeMethodAbiReturns(param.components);
+            return `[${fields}]${param.type === 'tuple[]' ? '[]' : ''}`;
+        }
+        // if (param.name && param.type) {
+        //     return `${param.type} ${param.name}`;
+        // }
+        return param.type;
+    }
+    function serializeMethodTsReturns(params) {
+        if (params == null || params.length === 0) {
+            params = [{ name: '', type: 'uint256' }];
+        }
+        let tsTypes = params.map(param => {
+            let tsType = _abiType_1.$abiType.getTsType(param.type, param);
+            if (tsType == null) {
+                throw new Error(`(gen) Unknown abi type in return: ${param.type}`);
+            }
+            return {
+                name: param.name,
+                type: tsType
+            };
+        });
+        if (params.length > 1 && isObjectParams(params)) {
+            let paramsStr = tsTypes.map(x => `${x.name}: ${x.type}`).join(', ');
+            return `Promise<{ ${paramsStr} }>`;
+        }
+        let fnResult = tsTypes?.map(x => x.type).join(', ');
+        if (tsTypes.length > 1) {
+            fnResult = `[ ${fnResult} ]`;
+        }
+        return `Promise<${fnResult}>`;
+    }
+    // const AbiTsTypes = {
+    //     'uint8': 'number',
+    //     'uint4': 'number',
+    //     'uint': 'number',
+    //     'bool': 'boolean',
+    //     'bytes': 'Buffer',
+    //     'bytes4': 'Buffer',
+    //     'bytes32': 'Buffer',
+    //     'bytes64': 'Buffer',
+    //     'bytes128': 'Buffer',
+    //     'bytes256': 'Buffer',
+    //     'address': 'TAddress',
+    //     'string': 'string',
+    // };
+    // const AbiTsTypesRgx = [
+    //     {
+    //         rgx: /uint\d+/,
+    //         type: 'bigint',
+    //     }
+    // ];
+})(Gen || (Gen = {}));
+var Str;
+(function (Str) {
+    function formatMethod(str) {
+        str = trim(str);
+        str = indent(str, '    ');
+        return str;
+    }
+    Str.formatMethod = formatMethod;
+    function trim(str) {
+        let lines = str.split('\n');
+        let min = (0, alot_1.default)(lines).min(x => {
+            if (x.trim() === '') {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            let match = /^\s+/.exec(x);
+            if (match == null) {
+                return Number.MAX_SAFE_INTEGER;
+            }
+            return match[0].length;
+        });
+        lines = lines.map((line, i) => {
+            let x = line.substring(min);
+            if ((i === 0) || (lines.length === i + 1)) {
+                if (x === '') {
+                    return null;
+                }
+            }
+            return x;
+        }).filter(Boolean);
+        return lines.join('\n');
+    }
+    Str.trim = trim;
+    function indent(str, indent) {
+        return str
+            .split('\n')
+            .map(x => `${indent}${x}`)
+            .join('\n');
+    }
+    Str.indent = indent;
+})(Str || (Str = {}));