dequanto 0.0.1 → 0.0.7

package/dist/src/evm/utils/stringifyVariables.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (variables) => {
+    let output = '';
+    Object.keys(variables).forEach((key, index) => {
+        const variable = variables[key];
+        const types = variable.types
+            .map((type) => {
+            if (typeof type === 'function') {
+                return type();
+            }
+            else {
+                return type;
+            }
+        })
+            .filter((type) => type);
+        if (types.length === 0) {
+            types.push('unknown');
+        }
+        if (variable.label) {
+            output += [...new Set(types)].join('|') + ' public ' + variable.label + ';';
+        }
+        else {
+            output += [...new Set(types)].join('|') + ' var' + (index + 1).toString() + ';';
+            index++;
+        }
+        output += '\n';
+    });
+    if (Object.keys(variables).length > 0) {
+        output += '\n';
+    }
+    return output;
+};

package/dist/src/gen/ContractStorageReaderTemplate.js

@@ -0,0 +1,11 @@
+class $NAME$ extends ContractStorageReaderBase {
+    constructor(address, client, explorer) {
+        super(address, client, explorer);
+        this.address = address;
+        this.client = client;
+        this.explorer = explorer;
+        /* METHODS */
+        this.$slots = $SLOTS$;
+        this.$createHandler(this.$slots);
+    }
+}

package/dist/src/gen/Generator.js

@@ -12,6 +12,10 @@ 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 _path_1 = require("@dequanto/utils/$path");
+const _logger_1 = require("@dequanto/utils/$logger");
+const Web3ClientFactory_1 = require("@dequanto/clients/Web3ClientFactory");
+const EVM_1 = require("@dequanto/evm/EVM");
 const KEYS = {
     'platform': 1,
     'name': 1,
@@ -26,6 +30,7 @@ class Generator {
         this.options = options;
         let { platform, } = options;
         this.explorer = BlockChainExplorerProvider_1.BlockChainExplorerProvider.get(platform);
+        this.client = Web3ClientFactory_1.Web3ClientFactory.get(platform);
         if (options.defaultAddress == null && _address_1.$address.isValid(options.source.abi)) {
             options.defaultAddress = options.source.abi;
         }
@@ -95,11 +100,13 @@ class Generator {
         return await generator.generate(abiJson, {
             network: network,
             name: name,
+            contractName: sources?.contractName,
             address: address,
             output: output,
             implementation: implementation,
-            sources: sources,
-            saveAbi: this.options.saveAbi
+            sources: sources?.files,
+            saveAbi: this.options.saveAbi,
+            client: this.client,
         });
     }
     async getAbi(opts) {
@@ -115,14 +122,15 @@ class Generator {
         else {
             let path = abi;
             let location = this.options.location;
-            if (location && path[0] !== '/') {
+            if (location && _path_1.$path.isAbsolute(path) === false) {
                 // 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);
+            let json = await atma_io_1.File.readAsync(path);
+            abiJson = Array.isArray(json) ? json : json.abi;
         }
         _require_1.$require.notNull(abiJson, `Abi not resolved from ${abi}`);
         return { abiJson, implementation };
@@ -131,17 +139,20 @@ class Generator {
         if (_address_1.$address.isValid(implementation) === false) {
             return null;
         }
-        console.log('Loading contract source code.');
+        _logger_1.$logger.log('Loading contract source code.');
         let meta = await this.explorer.getContractSource(implementation);
         if (meta?.SourceCode == null) {
-            console.log('No contract source found.');
+            _logger_1.$logger.log('No contract source found.');
             return null;
         }
         if (/^\s*\{/.test(meta.SourceCode) === false) {
-            console.log('Source contract as single file fetched.');
+            _logger_1.$logger.log('Source contract as single file fetched.');
             return {
-                [`${name}.sol`]: {
-                    content: meta.SourceCode
+                contractName: meta.ContractName,
+                files: {
+                    [`${name}.sol`]: {
+                        content: meta.SourceCode
+                    }
                 }
             };
         }
@@ -152,11 +163,14 @@ class Generator {
         try {
             let sources = JSON.parse(code);
             let files = sources.sources;
-            console.log(`Source code (${Object.keys(files).join(', ')}) fetched.`);
-            return files;
+            _logger_1.$logger.log(`Source code (${Object.keys(files).join(', ')}) fetched.`);
+            return {
+                contractName: meta.ContractName,
+                files
+            };
         }
         catch (error) {
-            console.error(`Source code can't be parsed: `, code);
+            _logger_1.$logger.error(`Source code can't be parsed: `, code);
             throw new Error(`Source code can't be parsed: ${error.message}`);
         }
     }
@@ -164,16 +178,23 @@ class Generator {
         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}. `);
+            _logger_1.$logger.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 : '');
+            _logger_1.$logger.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}`);
+            let message = `ABI is not resolved from ${this.options.platform}/${address}: ${error.message ?? error}. Extract from bytecode...`;
+            (0, _logger_1.l) `${message}`;
+            let code = await this.client.getCode();
+            if (code == null || code === '' || code === '0x') {
+                throw new Error(`${this.options.platform}:${address} is not a contract`);
+            }
+            let evm = new EVM_1.EVM(code);
+            let abi = await evm.getAbi();
+            return { abi };
         }
     }
 }

package/dist/src/gen/GeneratorFromAbi.js

@@ -4,48 +4,77 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeneratorFromAbi = void 0;
+const alot_1 = __importDefault(require("alot"));
 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");
+const _config_1 = require("@dequanto/utils/$config");
+const _logger_1 = require("@dequanto/utils/$logger");
+const GeneratorStorageReader_1 = require("./GeneratorStorageReader");
+const Str_1 = require("./utils/Str");
+const _gen_1 = require("./utils/$gen");
 class GeneratorFromAbi {
     static get Gen() {
         return Gen;
     }
     async generate(abiJson, opts) {
-        let methodsArr = abiJson
-            .map(item => {
-            if (item.type === 'function') {
+        let methodsArr = (0, alot_1.default)(abiJson)
+            .filter(x => x.type === 'function')
+            .groupBy(x => x.name)
+            .map(group => {
+            if (group.values.length === 1) {
+                let item = group.values[0];
                 return Gen.serializeMethodTs(item);
             }
+            if (group.values.length > 1) {
+                let items = group.values;
+                return Gen.serializeMethodTsOverloads(items);
+            }
             return null;
         })
             .filter(Boolean)
-            .map(Str.formatMethod);
-        ;
+            .map(Str_1.Str.formatMethod)
+            .toArray();
+        let methodInterfacesArr = (0, alot_1.default)(abiJson)
+            .filter(x => x.type === 'function')
+            .groupBy(x => x.name)
+            .map(group => {
+            let item = group.values[0];
+            return Gen.serializeMethodInterfacesTs(item.name, group.values);
+        })
+            .filter(Boolean)
+            .toArray();
+        let methodInterfacesAll = Gen.serializeMethodInterfacesAllTs(methodInterfacesArr);
         let eventsArr = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEvent(x))
             .filter(Boolean)
-            .map(Str.formatMethod);
+            .map(Str_1.Str.formatMethod);
         ;
+        let eventInterfacesAll = Gen.serializeEventsInterfacesAllTs(abiJson.filter(x => x.type === 'event'));
         let eventsExtractorsArr = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventExtractor(x))
             .filter(Boolean)
-            .map(Str.formatMethod);
+            .map(Str_1.Str.formatMethod);
+        let eventsFetchersArr = abiJson
+            .filter(x => x.type === 'event')
+            .map(x => Gen.serializeEventFetcher(x))
+            .filter(Boolean)
+            .map(Str_1.Str.formatMethod);
         let eventInterfaces = abiJson
             .filter(x => x.type === 'event')
             .map(x => Gen.serializeEventInterface(x))
             .filter(Boolean)
-            .map(Str.formatMethod);
+            .map(Str_1.Str.formatMethod);
         ;
         let methods = methodsArr.join('\n\n');
         let events = eventsArr.join('\n\n');
         let eventsExtractors = eventsExtractorsArr.join('\n\n');
+        let eventsFetchers = eventsFetchersArr.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 });
@@ -53,6 +82,8 @@ class GeneratorFromAbi {
         let EthWeb3ClientStr;
         let imports = [];
         let explorerUrl;
+        let Web3ClientOptions = '';
+        let EvmScanOptions = '';
         switch (opts.network) {
             case 'bsc':
                 EtherscanStr = 'Bscscan';
@@ -90,31 +121,81 @@ class GeneratorFromAbi {
                 ];
                 explorerUrl = `https://etherscan.io/address/${opts.implementation}#code`;
                 break;
-            default:
-                throw new Error(`Unknown network ${opts.network}`);
+            case 'hardhat':
+                EtherscanStr = 'Etherscan';
+                EthWeb3ClientStr = 'HardhatWeb3Client';
+                imports = [
+                    `import { Etherscan } from '@dequanto/BlockchainExplorer/Etherscan'`,
+                    `import { HardhatWeb3Client } from '@dequanto/clients/HardhatWeb3Client'`,
+                ];
+                explorerUrl = ``;
+                break;
+            default: {
+                let web3Config = _config_1.$config.get(`web3.${opts.network}`);
+                if (web3Config) {
+                    EtherscanStr = 'Evmscan';
+                    EthWeb3ClientStr = 'EvmWeb3Client';
+                    imports = [
+                        `import { Evmscan } from '@dequanto/BlockchainExplorer/Evmscan'`,
+                        `import { EvmWeb3Client } from '@dequanto/clients/EvmWeb3Client'`,
+                    ];
+                    Web3ClientOptions = `{ platform: '${opts.network}' }`;
+                    EvmScanOptions = `{ platform: '${opts.network}' }`;
+                    explorerUrl = '';
+                    let evmscan = _config_1.$config.get(`blockchainExplorer.${opts.network}`);
+                    if (evmscan?.www) {
+                        explorerUrl = `${evmscan.www}/address/${opts.implementation}#code`;
+                    }
+                    break;
+                }
+                throw new Error(`Unknown network ${opts.network}, and no configuration found under "web3" field`);
+            }
+        }
+        let storageReaderProperty = '';
+        let storageReaderClass = '';
+        try {
+            let storageReaderGenerator = new GeneratorStorageReader_1.GeneratorStorageReader();
+            let reader = await storageReaderGenerator.generate({ ...opts });
+            let property = reader.className
+                ? `storage = new ${reader.className}(this.address, this.client, this.explorer);`
+                : '';
+            storageReaderClass = reader.code;
+            storageReaderProperty = property;
+            _logger_1.$logger.log(`Storage Reader generated`);
+        }
+        catch (error) {
+            _logger_1.$logger.log(`Storage Reader is skipped: ${error.message}`);
         }
         let code = template
             .replace(/\$Etherscan\$/g, EtherscanStr)
             .replace(/\$EthWeb3Client\$/g, EthWeb3ClientStr)
+            .replace(/\$Web3ClientOptions\$/g, Web3ClientOptions)
+            .replace(/\$EvmScanOptions\$/g, EvmScanOptions)
             .replace(`/* IMPORTS */`, imports.join('\n'))
-            .replace(`$NAME$`, Gen.toClassName(name))
+            .replace(`$NAME$`, _gen_1.$gen.toClassName(name))
             .replace(`$ADDRESS$`, opts.address ?? '')
             .replace(`/* METHODS */`, methods)
             .replace(`/* EVENTS */`, events)
             .replace(`/* EVENTS_EXTRACTORS */`, eventsExtractors)
+            .replace(`/* EVENTS_FETCHERS */`, eventsFetchers)
             .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'));
+            .replace(`/* $EVENT_INTERFACES$ */`, eventInterfaces.join('\n') + '\n\n' + eventInterfacesAll.code + '\n\n')
+            .replace(`/* STORAGE_READER_PROPERTY */`, storageReaderProperty)
+            .replace(`/* STORAGE_READER_CLASS */`, storageReaderClass || '')
+            .replace(`/* $METHOD_INTERFACES$ */`, methodInterfacesArr.map(x => x.code).join('\n\n') + '\n\n' + methodInterfacesAll.code + '\n\n');
         let directory = name;
         let filename = /[^\\/]+$/.exec(name)[0];
-        let path = atma_utils_1.class_Uri.combine(opts.output, directory, `${filename}.ts`);
+        let path = /\.ts$/.test(opts.output)
+            ? opts.output
+            : 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}`);
+        _logger_1.$logger.log(`ABI wrapper class created: ${path}`);
         let sources = opts.sources;
         let sourceFiles = [];
         if (sources) {
@@ -122,7 +203,7 @@ class GeneratorFromAbi {
                 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}`);
+                _logger_1.$logger.log(`Source code saved: ${path}`);
                 return path;
             }).toArrayAsync();
         }
@@ -135,14 +216,6 @@ class GeneratorFromAbi {
 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) {
@@ -151,31 +224,111 @@ var Gen;
         return serializeWriteMethodTs(abi);
     }
     Gen.serializeMethodTs = serializeMethodTs;
+    function serializeMethodTsOverloads(abis) {
+        let isRead = abis.every(abi => isReader(abi));
+        if (isRead) {
+            return serializeReadMethodTsOverloads(abis);
+        }
+        return serializeWriteMethodTsOverloads(abis);
+    }
+    Gen.serializeMethodTsOverloads = serializeMethodTsOverloads;
+    // abi.length > 1 if has method overloads
+    function serializeMethodInterfacesTs(name, abis) {
+        let args = abis.map(abi => {
+            let { fnInputArguments } = serializeArgumentsTs(abi);
+            return `[ ${fnInputArguments} ]`;
+        }).join(' | ');
+        let iface = `IMethod${name[0].toUpperCase()}${name.substring(1)}`;
+        let code = [
+            `interface ${iface} {`,
+            `  method: "${name}"`,
+            `  arguments: ${args}`,
+            `}`
+        ];
+        return {
+            method: name,
+            interface: iface,
+            code: code.join('\n')
+        };
+    }
+    Gen.serializeMethodInterfacesTs = serializeMethodInterfacesTs;
+    function serializeMethodInterfacesAllTs(methods) {
+        let fields = methods.map(method => {
+            return `  ${method.method}: ${method.interface}`;
+        });
+        let code = [
+            `interface IMethods {`,
+            ...fields,
+            `  '*': { method: string, arguments: any[] } `,
+            `}`
+        ];
+        return {
+            code: code.join('\n')
+        };
+    }
+    Gen.serializeMethodInterfacesAllTs = serializeMethodInterfacesAllTs;
+    function serializeEventsInterfacesAllTs(events) {
+        let fields = events.map(item => {
+            return `  ${item.name}: TLog${item.name}Parameters`;
+        });
+        let code = [
+            `interface IEvents {`,
+            ...fields,
+            `  '*': any[] `,
+            `}`
+        ];
+        return {
+            code: code.join('\n')
+        };
+    }
+    Gen.serializeEventsInterfacesAllTs = serializeEventsInterfacesAllTs;
     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);
+            on${abi.name} (fn?: (event: TClientEventsStreamData<TLog${abi.name}Parameters>) => void): ClientEventsStream<TClientEventsStreamData<TLog${abi.name}Parameters>> {
+                return this.$onLog('${abi.name}', fn);
             }
         `;
     }
     Gen.serializeEvent = serializeEvent;
     function serializeEventExtractor(abi) {
         return `
-            extractLogs${abi.name} (tx: TransactionReceipt): TLog${abi.name}[] {
+            extractLogs${abi.name} (tx: TransactionReceipt): ITxLogItem<TLog${abi.name}>[] {
                 let abi = this.$getAbiItem('event', '${abi.name}');
-                return this.$extractLogs(tx, abi) as any as TLog${abi.name}[];
+                return this.$extractLogs(tx, abi) as any as ITxLogItem<TLog${abi.name}>[];
             }
         `;
     }
     Gen.serializeEventExtractor = serializeEventExtractor;
+    function serializeEventFetcher(abi) {
+        let inputs = abi.inputs;
+        let indexed = (0, alot_1.default)(inputs).takeWhile(x => x.indexed).toArray();
+        let indexedParams = indexed.map(param => `${param.name}?: ${_abiType_1.$abiType.getTsType(param.type, param)}`);
+        return `
+            async getPastLogs${abi.name} (options?: {
+                fromBlock?: number | Date
+                toBlock?: number | Date
+                params?: { ${indexedParams} }
+            }): Promise<ITxLogItem<TLog${abi.name}>[]> {
+                let topic = '${_abiUtils_1.$abiUtils.getTopicSignature(abi)}';
+                let abi = this.$getAbiItem('event', '${abi.name}');
+                let filters = await this.$getPastLogsFilters(abi, {
+                    topic,
+                    ...options
+                });
+                let logs= await this.$getPastLogs(filters);
+                return logs.map(log => this.$extractLog(log, abi)) as any;
+            }
+        `;
+    }
+    Gen.serializeEventFetcher = serializeEventFetcher;
     function serializeEventInterface(abi) {
         let { fnInputArguments, callInputArguments, fnResult } = serializeArgumentsTs(abi);
         return `
             type TLog${abi.name} = {
-                contract: TAddress,
                 ${fnInputArguments}
-            }
+            };
+            type TLog${abi.name}Parameters = [ ${fnInputArguments.replace('\n', '')} ];
         `;
     }
     Gen.serializeEventInterface = serializeEventInterface;
@@ -211,6 +364,25 @@ var Gen;
             }
         `;
     }
+    function serializeReadMethodTsOverloads(abis) {
+        let overrides = abis.map(abi => {
+            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            return `
+            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (${fnInputArguments}): ${fnResult}
+            `;
+        }).join('\n');
+        let abi = abis[0];
+        let { fnResult } = serializeArgumentsTs(abi);
+        let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
+        return `
+            ${overrides}
+            async ${abi.name} (...args): ${fnResult} {
+                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                return this.$read(abi, ...args);
+            }
+        `;
+    }
     function serializeWriteMethodTs(abi) {
         let { fnInputArguments, callInputArguments } = serializeArgumentsTs(abi);
         if (callInputArguments) {
@@ -218,8 +390,26 @@ var Gen;
         }
         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});
+            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter> {
+                return this.$write(this.$getAbiItem('function', '${abi.name}'), sender${callInputArguments});
+            }
+        `;
+    }
+    function serializeWriteMethodTsOverloads(abis) {
+        let overrides = abis.map(abi => {
+            let { fnInputArguments, fnResult } = serializeArgumentsTs(abi);
+            return `
+            // ${_abiUtils_1.$abiUtils.getMethodSignature(abi)}
+            async ${abi.name} (sender: TSender, ${fnInputArguments}): Promise<TxWriter>
+            `;
+        }).join('\n');
+        let abi = abis[0];
+        let sigs = abis.map(abi => serializeMethodAbi(abi)).map(x => `'${x}'`).join(', ');
+        return `
+            ${overrides}
+            async ${abi.name} (sender: TSender, ...args): Promise<TxWriter> {
+                let abi = this.$getAbiItemOverload([ ${sigs} ], args);
+                return this.$write(abi, sender, ...args);
             }
         `;
     }
@@ -229,6 +419,9 @@ var Gen;
             if (result.name == null || result.name === '') {
                 result.name = 'input' + i;
             }
+            if (result.name === 'sender') {
+                result.name = '_sender';
+            }
             return result;
         });
         let fnInputArguments = inputs
@@ -319,43 +512,3 @@ var Gen;
     //     }
     // ];
 })(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 = {}));