jcubic/lips | Build 12259396045 | src/lips.js | Coveralls

1

/**@license

1✔

2

 *   __ __                          __

1✔

3

 *  / / \ \       _    _  ___  ___  \ \

1✔

4

 * | |   \ \     | |  | || . \/ __>  | |

1✔

5

 * | |    > \    | |_ | ||  _/\__ \  | |

1✔

6

 * | |   / ^ \   |___||_||_|  <___/  | |

1✔

7

 *  \_\ /_/ \_\                     /_/

1✔

8

1✔

9

 * <https://lips.js.org>

1✔

10

1✔

11

 * LIPS is Pretty Simple - Scheme based powerful LISP in JavaScript

1✔

12

1✔

13

 * Copyright (c) 2018-2024 Jakub T. Jankiewicz <https://jcubic.pl/me>

1✔

14

 * Released under the MIT license

1✔

15

1✔

16

 * Includes:

1✔

17

1✔

18

 * ucs2decode function from Punycode v 2.1.1 by Mathias Bynens MIT License

1✔

19

1✔

20

 * Author: Diego Perini (diego.perini at gmail.com)

1✔

21

 * Summary: cross-browser wrapper for DOMContentLoaded

1✔

22

 * Updated: 20101020

1✔

23

 * License: MIT

1✔

24

 * Version: 1.2

1✔

25

1✔

26

 * contentloaded.js

1✔

27

1✔

28

 * URL:

1✔

29

 * http://javascript.nwbox.com/ContentLoaded/

1✔

30

 * http://javascript.nwbox.com/ContentLoaded/MIT-LICENSE

1✔

31

1✔

32

 * The rationalize algorithm is by Per M.A. Bothner, Alan Bawden and Marc Feeley.

1✔

33

 * source: Kawa, C-Gambit

1✔

34

1✔

35

 * Build time: {{DATE}}

1✔

36

*/

1✔

37

/*

1✔

38

 * TODO: consider using exec in env.eval or use different maybe_async code

1✔

39

*/

1✔

40

/* global jQuery, BigInt, Map, WeakMap, Set, Symbol, importScripts, Uint8Array */

1✔

41

"use strict";

1✔

42

1✔

44

1✔

45

import { addExtension, Encoder } from 'cbor-x';

1✔

46

import { pack, unpack } from 'lzjb-pack';

1✔

47

import unfetch from 'unfetch';

1✔

48

1✔

49

/* c8 ignore next 3 */

1✔

50

if (!root.fetch) {

1✔

51

    root.fetch = unfetch;

1✔

52

1✔

53

1✔

54

// -------------------------------------------------------------------------

1✔

55

// :: typechecking maps

1✔

56

// -------------------------------------------------------------------------

1✔

57

const type_mapping = {

1✔

58

    'pair': Pair,

1✔

59

    'symbol': LSymbol,

1✔

60

    'number': LNumber,

1✔

61

    'array': Array,

1✔

62

    'nil': Nil,

1✔

63

    'character': LCharacter,

1✔

64

    'values': Values,

1✔

65

    'input-port': InputPort,

1✔

66

    'output-port': OutputPort,

1✔

67

    'regex': RegExp,

1✔

68

    'syntax': Syntax,

1✔

69

    'eof': EOF,

1✔

70

    'macro': Macro,

1✔

71

    'string': LString,

1✔

72

    'native-symbol': Symbol

1✔

73

};

1✔

74

const type_constants = new Map([

1✔

75

    [NaN, 'NaN'],

1✔

76

    [null, 'null']

1✔

77

]);

1✔

78

// -------------------------------------------------------------------------

1✔

79

1✔

80

let fs, path, nodeRequire;

1✔

81

1✔

82

const BN = root.BN;

1✔

83

1✔

84

/* eslint-disable */

1✔

85

/* c8 ignore next 32 */

1✔

86

function contentLoaded(win, fn) {

1✔

87

    var done = false, top = true,

1✔

88

1✔

89

        doc = win.document,

1✔

90

        root = doc.documentElement,

1✔

91

        modern = doc.addEventListener,

1✔

92

1✔

93

        add = modern ? 'addEventListener' : 'attachEvent',

1✔

94

        rem = modern ? 'removeEventListener' : 'detachEvent',

1✔

95

        pre = modern ? '' : 'on',

1✔

96

1✔

97

        init = function(e) {

1✔

98

            if (e.type == 'readystatechange' && doc.readyState != 'complete') return;

1✔

99

            (e.type == 'load' ? win : doc)[rem](pre + e.type, init, false);

1✔

100

            if (!done && (done = true)) fn.call(win, e.type || e);

1✔

101

},

1✔

102

1✔

103

        poll = function() {

1✔

104

            try { root.doScroll('left'); } catch(e) { setTimeout(poll, 50); return; }

1✔

105

            init('poll');

1✔

106

};

1✔

107

1✔

108

    if (doc.readyState == 'complete') fn.call(win, 'lazy');

1✔

109

    else {

1✔

110

        if (!modern && root.doScroll) {

1✔

111

            try { top = !win.frameElement; } catch(e) { }

1✔

112

            if (top) poll();

1✔

113

1✔

114

        doc[add](pre + 'DOMContentLoaded', init, false);

1✔

115

        doc[add](pre + 'readystatechange', init, false);

1✔

116

        win[add](pre + 'load', init, false);

1✔

117

1✔

119

// -------------------------------------------------------------------------

1✔

120

/* c8 ignore next 13 */

1✔

121

function log(x, ...args) {

1✔

122

    if (is_plain_object(x) && is_debug(args[0])) {

1✔

123

        console.log(map_object(x, function(value) {

1✔

124

            return toString(value, true);

1✔

125

        }));

1✔

126

    } else if (is_debug()) {

1✔

127

        console.log(toString(x, true), ...args.map(item => {

1✔

128

            return toString(item, true);

1✔

129

        }));

1✔

130

1✔

131

1✔

132

/* eslint-enable */

1✔

133

// ----------------------------------------------------------------------

1✔

134

/* c8 ignore next */

1✔

135

function is_debug(n = null) {

1✔

136

    const debug = user_env && user_env.get('DEBUG', { throwError: false });

107,489✔

137

    if (n === null) {

107,489✔

138

        return debug === true;

107,489✔

139

107,489✔

141

107,489✔

142

/* eslint-enable */

1✔

143

/* eslint-disable max-len */

1✔

144

// functions generate regexes to match number rational, integer, complex, complex+rational

1✔

145

function num_mnemicic_re(mnemonic) {

18✔

146

    return mnemonic ? `(?:#${mnemonic}(?:#[ie])?|#[ie]#${mnemonic})` : '(?:#[ie])?';

18✔

147

18✔

148

function gen_rational_re(mnemonic, range) {

6✔

149

    return `${num_mnemicic_re(mnemonic)}[+-]?${range}+/${range}+`;

6✔

150

6✔

151

// TODO: float complex

1✔

152

function gen_complex_re(mnemonic, range) {

6✔

153

    // [+-]i have (?=..) so it don't match +i from +inf.0

6✔

154

    return `${num_mnemicic_re(mnemonic)}(?:[+-]?(?:${range}+/${range}+|nan.0|inf.0|${range}+))?(?:[+-]i|[+-]?(?:${range}+/${range}+|${range}+|nan.0|inf.0)i)(?=[()[\\]\\s]|$)`;

6✔

155

6✔

156

function gen_integer_re(mnemonic, range) {

6✔

157

    return `${num_mnemicic_re(mnemonic)}[+-]?${range}+`;

6✔

158

6✔

159

var re_re = /^#\/((?:\\\/|[^/]|\[[^\]]*\/[^\]]*\])+)\/([gimyus]*)$/;

1✔

160

var float_stre = '(?:[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)|(?:\\.[0-9]+|[0-9]+\\.[0-9]+)(?:[eE][-+]?[0-9]+)?)|[0-9]+\\.)';

1✔

161

// TODO: extend to ([+-]1/2|float)([+-]1/2|float)

1✔

162

var complex_float_stre = `(?:#[ie])?(?:[+-]?(?:[0-9][0-9_]*/[0-9][0-9_]*|nan.0|inf.0|${float_stre}|[+-]?[0-9]+))?(?:${float_stre}|[+-](?:[0-9]+/[0-9]+|[0-9]+|nan.0|inf.0))i`;

1✔

163

var float_re = new RegExp(`^(#[ie])?${float_stre}$`, 'i');

1✔

164

function make_complex_match_re(mnemonic, range) {

5✔

165

    // complex need special treatment of 10e+1i when it's hex or decimal

5✔

166

    var neg = mnemonic === 'x' ? `(?!\\+|${range})` : `(?!\\.|${range})`;

5✔

167

    var fl = '';

5✔

168

    if (mnemonic === '') {

5✔

169

        fl = '(?:[-+]?(?:[0-9]+(?:[eE][-+]?[0-9]+)|(?:\\.[0-9]+|[0-9]+\\.[0-9]+(?![0-9]))(?:[eE][-+]?[0-9]+)?))';

2✔

170

2✔

171

    return new RegExp(`^((?:(?:${fl}|[-+]?inf.0|[-+]?nan.0|[+-]?${range}+/${range}+(?!${range})|[+-]?${range}+)${neg})?)(${fl}|[-+]?inf.0|[-+]?nan.0|[+-]?${range}+/${range}+|[+-]?${range}+|[+-])i$`, 'i');

5✔

172

5✔

173

var complex_list_re = (function() {

1✔

174

    var result = {};

1✔

175

1✔

176

        [10, '', '[0-9]'],

1✔

177

        [16, 'x', '[0-9a-fA-F]'],

1✔

178

        [8, 'o', '[0-7]'],

1✔

179

        [2, 'b', '[01]']

1✔

180

    ].forEach(([radix, mnemonic, range]) => {

1✔

181

        result[radix] = make_complex_match_re(mnemonic, range);

4✔

182

});

1✔

183

    return result;

1✔

184

})();

1✔

185

const characters = {

1✔

186

    'alarm': '\x07',

1✔

187

    'backspace': '\x08',

1✔

188

    'delete': '\x7F',

1✔

189

    'escape': '\x1B',

1✔

190

    'newline': '\n',

1✔

191

    'null': '\x00',

1✔

192

    'return': '\r',

1✔

193

    'space': ' ',

1✔

194

    'tab': '\t',

1✔

195

    // new symbols from ASCII table in SRFI-175

1✔

196

    'dle': '\x10',

1✔

197

    'soh': '\x01',

1✔

198

    'dc1': '\x11',

1✔

199

    'stx': '\x02',

1✔

200

    'dc2': '\x12',

1✔

201

    'etx': '\x03',

1✔

202

    'dc3': '\x13',

1✔

203

    'eot': '\x04',

1✔

204

    'dc4': '\x14',

1✔

205

    'enq': '\x05',

1✔

206

    'nak': '\x15',

1✔

207

    'ack': '\x06',

1✔

208

    'syn': '\x16',

1✔

209

    'bel': '\x07',

1✔

210

    'etb': '\x17',

1✔

211

    'bs': '\x08',

1✔

212

    'can': '\x18',

1✔

213

    'ht': '\x09',

1✔

214

    'em': '\x19',

1✔

215

    'lf': '\x0a',

1✔

216

    'sub': '\x1a',

1✔

217

    'vt': '\x0b',

1✔

218

    'esc': '\x1b',

1✔

219

    'ff': '\x0c',

1✔

220

    'fs': '\x1c',

1✔

221

    'cr': '\x0d',

1✔

222

    'gs': '\x1d',

1✔

223

    'so': '\x0e',

1✔

224

    'rs': '\x1e',

1✔

225

    'si': '\x0f',

1✔

226

    'us': '\x1f',

1✔

227

    'del': '\x7f'

1✔

228

};

1✔

229

// -------------------------------------------------------------------------

1✔

230

// :: ref: https://github.com/bestiejs/punycode.js/blob/master/punycode.js

1✔

231

// -------------------------------------------------------------------------

1✔

232

function ucs2decode(string) {

97✔

233

    const output = [];

97✔

234

    let counter = 0;

97✔

235

    const length = string.length;

97✔

236

    while (counter < length) {

97✔

237

        const value = string.charCodeAt(counter++);

131✔

238

        if (value >= 0xD800 && value <= 0xDBFF && counter < length) {

131✔

239

            // It's a high surrogate, and there is a next character.

1✔

240

            const extra = string.charCodeAt(counter++);

1✔

241

            if ((extra & 0xFC00) === 0xDC00) { // Low surrogate.

1✔

242

                output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);

1✔

249

        } else {

131✔

250

            output.push(value);

130✔

251

130✔

252

131✔

253

    return output;

97✔

254

97✔

255

// -------------------------------------------------------------------------

1✔

256

const character_symbols = Object.keys(characters).join('|');

1✔

257

const char_sre_re = `#\\\\(?:x[0-9a-f]+|${character_symbols}|[\\s\\S])`;

1✔

258

const char_re = new RegExp(`^${char_sre_re}$`, 'i');

1✔

259

// Complex with (int) (float) (rational)

1✔

260

function make_num_stre(fn) {

3✔

261

    const ranges = [

3✔

262

        ['o', '[0-7]'],

3✔

263

        ['x', '[0-9a-fA-F]'],

3✔

264

        ['b', '[01]'],

3✔

265

        ['d', '[0-9]'],

3✔

266

        ['', '[0-9]']

3✔

267

];

3✔

268

    // float exception that don't accept mnemonics

3✔

269

    let result = ranges.map(([m, range]) => fn(m, range)).join('|');

3✔

270

    if (fn === gen_complex_re) {

3✔

271

        result = complex_float_stre + '|' + result;

1✔

272

1✔

273

    return result;

3✔

274

3✔

275

function make_type_re(fn) {

3✔

276

    return new RegExp('^(?:' + make_num_stre(fn) + ')$', 'i');

3✔

277

3✔

278

const complex_re = make_type_re(gen_complex_re);

1✔

279

const rational_re = make_type_re(gen_rational_re);

1✔

280

const int_re = make_type_re(gen_integer_re);

1✔

281

1✔

282

// regexes with full range but without mnemonics for string->number

1✔

283

const int_bare_re = new RegExp('^(?:' + gen_integer_re('', '[0-9a-f]') + ')$', 'i');

1✔

284

const rational_bare_re = new RegExp('^(?:' + gen_rational_re('', '[0-9a-f]') + ')$', 'i');

1✔

285

const complex_bare_re = new RegExp('^(?:' + gen_complex_re('', '[0-9a-f]') + ')$', 'i');

1✔

286

1✔

287

const complex_bare_match_re = make_complex_match_re('', '[0-9a-fA-F]');

1✔

288

1✔

289

const pre_num_parse_re = /((?:#[xodbie]){0,2})(.*)/i;

1✔

290

/* eslint-enable */

1✔

291

function num_pre_parse(arg) {

4,553✔

292

    var parts = arg.match(pre_num_parse_re);

4,553✔

293

    var options = {};

4,553✔

294

    if (parts[1]) {

4,553✔

295

        var type = parts[1].replace(/#/g, '').toLowerCase().split('');

217✔

296

        if (type.includes('x')) {

217✔

297

            options.radix = 16;

95✔

298

        } else if (type.includes('o')) {

217✔

299

            options.radix = 8;

27✔

300

        } else if (type.includes('b')) {

122✔

301

            options.radix = 2;

61✔

305

        if (type.includes('i')) {

217✔

306

            options.inexact = true;

79✔

307

79✔

308

        if (type.includes('e')) {

217✔

309

            options.exact = true;

31✔

310

31✔

311

217✔

312

    options.number = parts[2];

4,553✔

313

    return options;

4,553✔

314

4,553✔

315

// ----------------------------------------------------------------------

1✔

316

function parse_rational(arg, radix = 10) {

205✔

317

    var parse = num_pre_parse(arg);

205✔

318

    var parts = parse.number.split('/');

205✔

319

    var num = LRational({

205✔

320

        num: LNumber([parts[0], parse.radix || radix]),

205✔

321

        denom: LNumber([parts[1], parse.radix || radix])

205✔

322

});

205✔

323

    if (parse.inexact) {

205✔

324

        return num.valueOf();

16✔

325

    } else {

205✔

326

        return num;

189✔

327

189✔

328

205✔

329

// ----------------------------------------------------------------------

1✔

330

function parse_integer(arg, radix = 10) {

2,658✔

331

    var parse = num_pre_parse(arg);

2,658✔

332

    if (parse.inexact) {

2,658✔

333

        return LFloat(parseInt(parse.number, parse.radix || radix), true);

31✔

334

31✔

335

    return LNumber([parse.number, parse.radix || radix]);

2,658✔

336

2,658✔

337

// ----------------------------------------------------------------------

1✔

338

function parse_character(arg) {

186✔

339

    var m = arg.match(/#\\x([0-9a-f]+)$/i);

186✔

340

    var char;

186✔

341

    if (m) {

186✔

342

        var ord = parseInt(m[1], 16);

1✔

343

        char = String.fromCodePoint(ord);

1✔

344

    } else {

186✔

345

        m = arg.match(/#\\([\s\S]+)$/);

185✔

346

        if (m) {

185✔

347

            char = m[1];

185✔

348

185✔

349

185✔

350

    if (char) {

186✔

351

        return LCharacter(char);

186✔

352

186✔

354

186✔

355

// ----------------------------------------------------------------------

1✔

356

function parse_complex(arg, radix = 10) {

902✔

357

    function parse_num(n) {

902✔

358

        var value;

1,714✔

359

        if (n === '+') {

1,714✔

360

            value = LNumber(1);

21✔

361

        } else if (n === '-') {

1,714✔

362

            value = LNumber(-1);

15✔

363

        } else if (n.match(int_bare_re)) {

1,693✔

364

            value = LNumber([n, radix]);

482✔

365

        } else if (n.match(rational_bare_re)) {

1,678✔

366

            var parts = n.split('/');

317✔

367

            value = LRational({

317✔

368

                num: LNumber([parts[0], radix]),

317✔

369

                denom: LNumber([parts[1], radix])

317✔

370

});

317✔

371

        } else if (n.match(float_re)) {

1,196✔

372

            var float = parse_float(n);

515✔

373

            if (parse.exact) {

515✔

374

                return float.toRational();

7✔

375

7✔

376

            return float;

508✔

377

        } else if (n.match(/nan.0$/)) {

879✔

378

            return LNumber(NaN);

248✔

379

        } else if (n.match(/inf.0$/)) {

364✔

380

            if (n[0] === '-') {

116✔

381

                return LNumber(Number.NEGATIVE_INFINITY);

6✔

382

6✔

383

            return LNumber(Number.POSITIVE_INFINITY);

110✔

387

        if (parse.inexact) {

1,714✔

388

            return LFloat(value.valueOf(), true);

41✔

389

41✔

390

        return value;

794✔

391

1,714✔

392

    var parse = num_pre_parse(arg);

902✔

393

    radix = parse.radix || radix;

902✔

394

    var parts;

902✔

395

    var bare_match = parse.number.match(complex_bare_match_re);

902✔

396

    if (radix !== 10 && bare_match) {

902✔

397

        parts = bare_match;

41✔

398

    } else {

902✔

399

        parts = parse.number.match(complex_list_re[radix]);

861✔

400

861✔

401

    var re, im;

902✔

402

    im = parse_num(parts[2]);

902✔

403

    if (parts[1]) {

902✔

404

        re = parse_num(parts[1]);

812✔

405

    } else if (im instanceof LFloat) {

902✔

406

        re = LFloat(0);

44✔

407

    } else {

90✔

408

        re = LNumber(0);

46✔

409

46✔

410

    if (im.cmp(0) === 0 && im.__type__ === 'bigint') {

902✔

411

        return re;

6✔

412

6✔

413

    return LComplex({ im, re });

896✔

414

902✔

415

// ----------------------------------------------------------------------

1✔

416

function is_int(value) {

779✔

417

    return parseInt(value.toString(), 10) === value;

779✔

418

779✔

419

// ----------------------------------------------------------------------

1✔

420

function parse_big_int(str) {

767✔

421

    var num_match = str.match(/^(([-+]?[0-9]*)(?:\.([0-9]+))?)e([-+]?[0-9]+)/i);

767✔

422

    if (num_match) {

767✔

423

        var exponent = parseInt(num_match[4], 10);

62✔

424

        var mantisa;// = parseFloat(num_match[1]);

62✔

425

        var digits = num_match[1].replace(/[-+]?([0-9]*)\..+$/, '$1').length;

62✔

426

        var decimal_points = num_match[3] && num_match[3].length;

62✔

427

        if (digits < Math.abs(exponent)) {

62✔

428

            mantisa = LNumber([num_match[1].replace(/\./, ''), 10]);

60✔

429

            if (decimal_points) {

60✔

430

                exponent -= decimal_points;

55✔

431

55✔

432

60✔

433

62✔

434

    return { exponent, mantisa };

767✔

435

767✔

436

1✔

437

// ----------------------------------------------------------------------

1✔

438

function string_to_float(str) {

788✔

439

    if (str.match(/e/i)) {

788✔

440

        const [coefficient, exponent] = str.split('e');

82✔

441

        const decimal_places = Math.abs(parseInt(exponent));

82✔

442

        if (decimal_places < 7 && exponent < 0) {

82✔

443

            const zeros = '0'.repeat(decimal_places - 1);

17✔

444

            const sign = coefficient[0] === '-' ? '-' : '+';

17✔

445

            const digits = coefficient.replace(/(^[-+])|\./g, '');

17✔

446

            const float_str = `${sign}0.${zeros}${digits}`;

17✔

447

            return parseFloat(float_str);

17✔

448

17✔

449

82✔

450

    return parseFloat(str);

771✔

451

788✔

452

1✔

453

// ----------------------------------------------------------------------

1✔

454

function parse_float(arg) {

788✔

455

    const parse = num_pre_parse(arg);

788✔

456

    let value = string_to_float(parse.number);

788✔

457

    const simple_number = (parse.number.match(/\.0$/) ||

788✔

458

                         !parse.number.match(/\./)) && !parse.number.match(/e/i);

788✔

459

    if (!parse.inexact) {

788✔

460

        if (parse.exact && simple_number) {

780✔

461

            return LNumber(value);

1✔

462

1✔

463

        // positive big num that eval to int e.g.: 1.2e+20

779✔

464

        if (is_int(value) &&

780✔

465

            Number.isSafeInteger(value) &&

780✔

466

            parse.number.match(/e\+?[0-9]/i)) {

780✔

467

            return LNumber(value);

12✔

468

12✔

469

        // calculate big int and big fraction by hand - it don't fit into JS float

767✔

470

        const { mantisa, exponent } = parse_big_int(parse.number);

767✔

471

        if (mantisa !== undefined && exponent !== undefined) {

780✔

472

            const factor = LNumber(10).pow(LNumber(Math.abs(exponent)));

60✔

473

            if (parse.exact && exponent < 0) {

60✔

474

                return LRational({ num: mantisa, denom: factor });

4✔

475

            } else if (exponent > 0 && (parse.exact || !parse.number.match(/\./))) {

60✔

476

                return LNumber(mantisa).mul(factor);

1✔

477

1✔

478

60✔

479

780✔

480

    value = LFloat(value, true);

770✔

481

    if (parse.exact) {

788✔

482

        return value.toRational();

2✔

483

2✔

484

    return value;

768✔

485

788✔

486

// ----------------------------------------------------------------------

1✔

487

function parse_string(string) {

1,177✔

488

    // handle non JSON escapes and skip unicode escape \u (even partial)

1,177✔

489

    string = string.replace(/\\x([0-9a-f]+);/ig, function(_, hex) {

1,177✔

490

        return "\\u" + hex.padStart(4, '0');

3✔

491

    }).replace(/\n/g, '\\n'); // in LIPS strings can be multiline

1,177✔

492

    var m = string.match(/(\\*)(\\x[0-9A-F])/i);

1,177✔

493

    if (m && m[1].length % 2 === 0) {

1,177✔

494

        throw new Error(`Invalid string literal, unclosed ${m[2]}`);

1✔

495

1✔

496

    try {

1,176✔

497

        const str =  LString(JSON.parse(string));

1,176✔

498

        str.freeze();

1,176✔

499

        return str;

1,176✔

504

1,177✔

505

// ----------------------------------------------------------------------

1✔

506

function parse_symbol(arg) {

11,812✔

507

    const debug = arg.match(/^name/);

11,812✔

508

    const re = /(^|.)\|/g;

11,812✔

509

    if (arg.match(re)) {

11,812✔

510

        // handle escaped bar and escaped slash

18✔

511

        arg = arg.split('|').filter(Boolean).reduce((acc, str) => {

18✔

512

            let result = '';

5✔

513

            if (str.match(/^\\+$/)) {

5✔

514

                if (str.length > 1) {

4✔

515

                    const count = Math.floor(str.length / 2);

3✔

516

                    result = '\\'.repeat(count);

3✔

517

3✔

518

                if (str.length % 2 !== 0) {

4✔

519

                    result += '|';

1✔

520

1✔

521

            } else {

5✔

522

                result = str;

1✔

523

1✔

524

            return acc + result;

5✔

525

});

18✔

526

        const chars = {

18✔

527

            t: '\t',

18✔

528

            r: '\r',

18✔

529

            n: '\n'

18✔

530

};

18✔

531

        arg = arg.replace(/\\(x[^;]+);/g, function(_, chr) {

18✔

532

            return String.fromCharCode(parseInt('0' + chr, 16));

6✔

533

        }).replace(/\\([trn])/g, function(_, chr) {

18✔

534

            return chars[chr];

8✔

535

});

18✔

536

18✔

537

    return new LSymbol(arg);

11,812✔

538

11,812✔

539

// ----------------------------------------------------------------------

1✔

540

function parse_argument(arg, meta = false) {

17,721✔

541

    const token = meta ? arg.token : arg;

17,721✔

542

    if (constants.hasOwnProperty(token)) {

17,721✔

543

        return constants[token];

597✔

544

597✔

545

    let result;

17,124✔

546

    if (token.match(/^"[\s\S]*"$/)) {

17,721✔

547

        result = parse_string(token);

1,177✔

548

    } else if (token[0] === '#') {

17,721✔

549

        var regex = token.match(re_re);

328✔

550

        if (regex) {

328✔

551

            result = new RegExp(regex[1], regex[2]);

20✔

552

        } else if (token.match(char_re)) {

328✔

553

            result = parse_character(token);

97✔

554

97✔

555

        // characters with more than one codepoint

328✔

556

        var m = token.match(/#\\(.+)/);

328✔

557

        if (m && ucs2decode(m[1]).length === 1) {

328✔

558

            result = parse_character(token);

89✔

559

89✔

560

328✔

561

    if (token.match(/[0-9a-f]|[+-]i/i)) {

17,721✔

562

        if (token.match(int_re)) {

11,898✔

563

            result = parse_integer(token);

2,650✔

564

        } else if (token.match(float_re)) {

11,898✔

565

            result = parse_float(token);

272✔

566

        } else if (token.match(rational_re)) {

9,248✔

567

            result = parse_rational(token);

198✔

568

        } else if (token.match(complex_re)) {

8,976✔

569

            result = parse_complex(token);

895✔

570

895✔

571

11,898✔

572

    if (!result && token.match(/^#[iexobd]/)) {

17,721✔

573

        throw new Error('Invalid numeric constant: ' + arg);

2✔

574

2✔

575

    if (!result) {

17,721✔

576

        result = parse_symbol(token);

11,812✔

577

11,812✔

578

    if (meta) {

17,721✔

579

        const { col, offset, line } = arg;

12✔

580

        read_only(result, '__col__', col);

12✔

581

        read_only(result, '__offset__', offset);

12✔

582

        read_only(result, '__line__', line);

12✔

583

12✔

584

    return result;

17,121✔

585

17,721✔

586

// ----------------------------------------------------------------------

1✔

587

function is_atom_string(str) {

580✔

588

    return !(['(', ')', '[', ']'].includes(str) ||

580✔

589

             specials.names().includes(str));

580✔

590

580✔

591

// ----------------------------------------------------------------------

1✔

592

function is_symbol_string(str) {

580✔

593

    return is_atom_string(str) &&

580✔

594

        !(str.match(re_re) ||

320✔

595

          str.match(/^"[\s\S]*"$/) || str.match(int_re) ||

320✔

596

          str.match(float_re) || str.match(complex_re) ||

320✔

597

          str.match(rational_re) || str.match(char_re) ||

320✔

598

          ['#t', '#f', 'nil'].includes(str));

580✔

599

580✔

600

// ----------------------------------------------------------------------

1✔

601

var string_re = /"(?:\\[\S\s]|[^"])*"?/g;

1✔

602

// ----------------------------------------------------------------------

1✔

603

function escape_regex(str) {

1✔

604

    if (typeof str === 'string') {

1✔

605

        var special = /([-\\^$[\]()+{}?*.|])/g;

1✔

606

        return str.replace(special, '\\$1');

1✔

607

1✔

609

1✔

610

// ----------------------------------------------------------------------

1✔

611

// Stack used in balanced function

1✔

612

// TODO: use it in parser

1✔

613

// ----------------------------------------------------------------------

1✔

614

function Stack() {

33✔

615

    this.data = [];

33✔

616

33✔

617

Stack.prototype.push = function(item) {

1✔

618

    this.data.push(item);

133✔

619

};

1✔

620

Stack.prototype.top = function() {

1✔

621

    return this.data[this.data.length - 1];

100✔

622

};

1✔

623

Stack.prototype.pop = function() {

1✔

624

    return this.data.pop();

100✔

625

};

1✔

626

Stack.prototype.is_empty = function() {

1✔

627

    return !this.data.length;

133✔

628

};

1✔

629

// ----------------------------------------------------------------------

1✔

630

function tokens(str) {

51✔

634

    var lexer = new Lexer(str, { whitespace: true });

51✔

635

    var result = [];

51✔

636

    while (true) {

51✔

637

        const token = lexer.peek(true);

1,566✔

638

        if (token === eof) {

1,566✔

639

            break;

50✔

640

50✔

641

        result.push(token);

1,515✔

642

        lexer.skip();

1,515✔

643

1,515✔

644

    return result;

50✔

645

51✔

646

// ----------------------------------------------------------------------

1✔

647

function multiline_formatter(meta) {

85,350✔

648

    var { token, ...rest } = meta;

85,350✔

649

    if (token.match(/^"[\s\S]*"$/) && token.match(/\n/)) {

85,350✔

650

        var re = new RegExp('^ {1,' + (meta.col + 1) + '}', 'mg');

39✔

651

        token = token.replace(re, '');

39✔

652

39✔

653

    return {

85,350✔

654

        token,

85,350✔

655

        ...rest

85,350✔

656

};

85,350✔

657

85,350✔

658

// ----------------------------------------------------------------------

1✔

659

function Thunk(fn, cont = () => {}) {

48,327,548✔

660

    this.fn = fn;

48,327,548✔

661

    this.cont = cont;

48,327,548✔

662

48,327,548✔

663

// ----------------------------------------------------------------------

1✔

664

Thunk.prototype.toString = function() {

1✔

666

};

1✔

667

// ----------------------------------------------------------------------

1✔

668

function trampoline(fn) {

1,586,100✔

669

    return function(...args) {

1,586,100✔

670

        return unwind(fn.apply(this, args));

49,913,660✔

671

};

1,586,100✔

672

1,586,100✔

673

// ----------------------------------------------------------------------

1✔

674

function unwind(result) {

49,913,660✔

675

    while (result instanceof Thunk) {

49,913,660✔

676

        const thunk = result;

48,327,548✔

677

        result = result.fn();

48,327,548✔

678

        if (!(result instanceof Thunk)) {

48,327,548✔

679

            thunk.cont();

19,690,995✔

680

19,690,995✔

681

48,327,548✔

682

    return result;

49,913,660✔

683

49,913,660✔

684

// ----------------------------------------------------------------------

1✔

685

function tokenize(str, meta = false) {

51✔

686

    if (str instanceof LString) {

51✔

687

        str = str.toString();

8✔

688

8✔

689

    if (meta) {

51✔

690

        return tokens(str);

43✔

691

    } else {

51✔

692

        var result = tokens(str).map(function(token) {

8✔

693

            // we don't want literal space character to be trimmed

88✔

697

            return token.token.trim();

88✔

698

        }).filter(function(token) {

8✔

699

            return token && !token.match(/^;/) && !token.match(/^#\|[\s\S]*\|#$/);

88✔

700

});

8✔

701

        return strip_s_comments(result);

8✔

702

8✔

703

51✔

704

// ----------------------------------------------------------------------

1✔

705

function strip_s_comments(tokens) {

7✔

706

    var s_count = 0;

7✔

707

    var s_start = null;

7✔

708

    var remove_list = [];

7✔

709

    for (let i = 0; i < tokens.length; ++i) {

7✔

710

        const token = tokens[i];

57✔

732

57✔

733

    tokens = tokens.slice();

7✔

734

    remove_list.reverse();

7✔

738

    return tokens;

7✔

739

7✔

740

// ----------------------------------------------------------------------

1✔

741

// Detect if object is ES6 Symbol that work with polyfills

1✔

742

// ----------------------------------------------------------------------

1✔

743

function isSymbol(x) {

743,301✔

744

    return typeof x === 'symbol' ||

743,301✔

746

        Object.prototype.toString.call(x) === '[object Symbol]';

743,301✔

747

743,301✔

748

// ----------------------------------------------------------------------

1✔

749

// :: LSymbol constructor

1✔

750

// ----------------------------------------------------------------------

1✔

751

function LSymbol(name) {

1,399,803✔

755

    if (LSymbol.list[name] instanceof LSymbol) {

1,399,803✔

756

        return LSymbol.list[name];

116,532✔

757

116,532✔

758

    if (typeof this !== 'undefined' && this.constructor !== LSymbol ||

1,399,803✔

759

        typeof this === 'undefined') {

1,399,803✔

760

        return new LSymbol(name);

1,262✔

761

1,262✔

762

    this.__name__ = name;

1,282,009✔

763

    if (typeof name === 'string') {

1,399,803✔

764

        LSymbol.list[name] = this;

1,685✔

765

1,685✔

766

1,399,803✔

767

LSymbol.list = {};

1✔

768

LSymbol.literal = Symbol.for('__literal__');

1✔

769

LSymbol.object = Symbol.for('__object__');

1✔

770

// ----------------------------------------------------------------------

1✔

771

LSymbol.is = function(symbol, name) {

1✔

772

    return symbol instanceof LSymbol &&

13,388,545✔

773

        ((name instanceof LSymbol && symbol.__name__ === name.__name__) ||

8,091,642✔

774

         (typeof name === 'string' && symbol.__name__ === name) ||

8,091,642✔

775

         (name instanceof RegExp && name.test(symbol.__name__)));

13,388,545✔

776

};

1✔

777

// ----------------------------------------------------------------------

1✔

778

LSymbol.prototype.toString = function(quote) {

1✔

779

    //return '#<symbol \'' + this.name + '\'>';

743,301✔

780

    if (isSymbol(this.__name__)) {

743,301✔

781

        return symbol_to_string(this.__name__);

95,597✔

782

95,597✔

783

    var str = this.valueOf();

647,704✔

784

    // those special characters can be normal symbol when printed

647,704✔

785

    if (quote && str.match(/(^;|[\s()[\]'])/)) {

743,301✔

786

        return `|${str}|`;

2✔

787

2✔

788

    return str;

647,702✔

789

};

1✔

790

LSymbol.prototype.literal = function() {

1✔

791

    if (this.is_gensym()) {

5,043✔

792

        return this[LSymbol.literal];

216✔

793

216✔

794

    return this.valueOf();

4,827✔

795

};

1✔

796

LSymbol.prototype.serialize = function() {

1✔

797

    if (LString.isString(this.__name__)) {

2✔

798

        return this.__name__;

2✔

799

2✔

801

};

1✔

802

LSymbol.prototype.valueOf = function() {

1✔

803

    return this.__name__.valueOf();

10,755,033✔

804

};

1✔

805

// -------------------------------------------------------------------------

1✔

806

LSymbol.prototype.is_gensym = function() {

1✔

807

    return is_gensym(this.__name__);

5,093✔

808

};

1✔

809

// -------------------------------------------------------------------------

1✔

810

function symbol_to_string(obj) {

95,597✔

811

    return obj.toString().replace(/^Symbol\(([^)]+)\)/, '$1');

95,597✔

812

95,597✔

813

// -------------------------------------------------------------------------

1✔

814

function is_gensym(symbol) {

1,285,689✔

815

    if (typeof symbol === 'symbol') {

1,285,689✔

816

        return !!symbol.toString().match(/^Symbol\(#:/);

295✔

817

295✔

818

    return false;

1,285,394✔

819

1,285,689✔

820

// -------------------------------------------------------------------------

1✔

821

const gensym = (function() {

1✔

822

    var count = 0;

1✔

823

    function with_props(name, sym) {

1✔

824

        var symbol = new LSymbol(sym);

1,280,254✔

825

        hidden_prop(symbol, '__literal__', name);

1,280,254✔

826

        return symbol;

1,280,254✔

827

1,280,254✔

828

    return function(name = null) {

1✔

829

        if (name instanceof LSymbol) {

1,280,324✔

833

            name = name.valueOf();

39✔

834

39✔

835

        if (is_gensym(name)) {

1,280,324✔

836

            // don't do double gynsyms in nested syntax-rules

70✔

837

            return LSymbol(name);

70✔

838

70✔

839

        // use ES6 symbol as name for lips symbol (they are unique)

1,280,254✔

840

        if (name !== null) {

1,280,324✔

841

            return with_props(name, Symbol(`#:${name}`));

1,238,888✔

842

1,238,888✔

843

        count++;

41,366✔

844

        return with_props(count, Symbol(`#:g${count}`));

41,366✔

845

};

1✔

846

})();

1✔

847

// ----------------------------------------------------------------------

1✔

848

// :: helper function that make symbols in names array hygienic

1✔

849

// ----------------------------------------------------------------------

1✔

850

function hygienic_begin(envs, expr) {

1,147,820✔

851

    const begin = global_env.get('begin');

1,147,820✔

852

    const g_begin = gensym('begin');

1,147,820✔

853

    envs.forEach(env => {

1,147,820✔

854

        env.set(g_begin, begin);

1,841,667✔

855

});

1,147,820✔

856

    return new Pair(g_begin, expr);

1,147,820✔

857

1,147,820✔

858

1✔

859

// ----------------------------------------------------------------------

1✔

860

// Class used to escape promises: feature #54

1✔

861

// ----------------------------------------------------------------------

1✔

862

function QuotedPromise(promise) {

19✔

863

    var internal = {

19✔

864

        pending: true,

19✔

865

        rejected: false,

19✔

866

        fulfilled: false,

19✔

867

        reason: undefined,

19✔

868

        type: undefined

19✔

869

};

19✔

870

    // then added to __promise__ is needed otherwise rejection

19✔

871

    // will give UnhandledPromiseRejectionWarning in Node.js

19✔

872

    promise = promise.then(v => {

19✔

873

        internal.type = type(v);

17✔

874

        internal.fulfilled = true;

17✔

875

        internal.pending = false;

17✔

876

        return v;

17✔

877

});

19✔

878

    // promise without catch, used for valueOf - for rejecting

19✔

879

    // that should throw an error when used with await

19✔

880

    read_only(this, '_promise', promise, { hidden: true });

19✔

881

    if (is_function(promise.catch)) {

19✔

882

        // prevent exception on unhandled rejecting when using

19✔

883

        // '>(Promise.reject (new Error "zonk")) in REPL

19✔

884

        promise = promise.catch((err) => {

19✔

885

            internal.rejected = true;

2✔

886

            internal.pending = false;

2✔

887

            internal.reason = err;

2✔

888

});

19✔

889

19✔

890

    Object.keys(internal).forEach(name => {

19✔

891

        Object.defineProperty(this, `__${name}__`, {

95✔

892

            enumerable: true,

95✔

893

            get: () => internal[name]

95✔

894

});

95✔

895

});

19✔

896

    read_only(this, '__promise__', promise);

19✔

897

    // prevent resolving when returned from real promise #153

19✔

898

    this.then = false;

19✔

899

19✔

900

// ----------------------------------------------------------------------

1✔

901

QuotedPromise.prototype.then = function(fn) {

1✔

902

    return new QuotedPromise(this.valueOf().then(fn));

6✔

903

};

1✔

904

// ----------------------------------------------------------------------

1✔

905

QuotedPromise.prototype.catch = function(fn) {

1✔

906

    return new QuotedPromise(this.valueOf().catch(fn));

1✔

907

};

1✔

908

// ----------------------------------------------------------------------

1✔

909

QuotedPromise.prototype.valueOf = function() {

1✔

913

    return this._promise;

16✔

914

};

1✔

915

// ----------------------------------------------------------------------

1✔

916

QuotedPromise.prototype.toString = function() {

1✔

917

    if (this.__pending__) {

5✔

918

        return QuotedPromise.pending_str;

3✔

919

3✔

920

    if (this.__rejected__) {

5✔

921

        return QuotedPromise.rejected_str;

1✔

922

1✔

923

    return `#<js-promise resolved (${this.__type__})>`;

1✔

924

};

1✔

925

QuotedPromise.pending_str = '#<js-promise (pending)>';

1✔

926

QuotedPromise.rejected_str = '#<js-promise (rejected)>';

1✔

927

// ----------------------------------------------------------------------

1✔

928

// wrapper over Promise.all that ignore quoted promises

1✔

929

// ----------------------------------------------------------------------

1✔

930

function promise_all(arg) {

1,806✔

931

    if (Array.isArray(arg)) {

1,806✔

932

        return Promise.all(escape_quoted_promises(arg))

1,806✔

933

            .then(unescape_quoted_promises);

1,806✔

934

1,806✔

936

1,806✔

937

// ----------------------------------------------------------------------

1✔

938

function escape_quoted_promises(array) {

1,806✔

939

    // using loops for performance

1,806✔

940

    var escaped = new Array(array.length), i = array.length;

1,806✔

941

    while (i--) {

1,806✔

942

        const value = array[i];

2,021✔

943

        if (value instanceof QuotedPromise) {

2,021✔

944

            escaped[i] = new Value(value);

1✔

945

        } else {

2,021✔

946

            escaped[i] = value;

2,020✔

947

2,020✔

948

2,021✔

949

    return escaped;

1,806✔

950

1,806✔

951

// ----------------------------------------------------------------------

1✔

952

function unescape_quoted_promises(array) {

1,805✔

953

    var unescaped = new Array(array.length), i = array.length;

1,805✔

954

    while (i--) {

1,805✔

955

        var value = array[i];

2,019✔

956

        if (value instanceof Value) {

2,019✔

957

            unescaped[i] = value.valueOf();

1✔

958

        } else {

2,019✔

959

            unescaped[i] = value;

2,018✔

960

2,018✔

961

2,019✔

962

    return unescaped;

1,805✔

963

1,805✔

964

// ----------------------------------------------------------------------

1✔

965

// :: Parser macros transformers

1✔

966

// ----------------------------------------------------------------------

1✔

967

var specials = {

1✔

968

    LITERAL: Symbol.for('literal'),

1✔

969

    SPLICE: Symbol.for('splice'),

1✔

970

    SYMBOL: Symbol.for('symbol'),

1✔

971

    names: function() {

1✔

972

        return Object.keys(this.__list__);

87,390✔

973

},

1✔

974

    type: function(name) {

1✔

975

        try {

1,969✔

976

            return this.get(name).type;

1,969✔

982

},

1✔

983

    get: function(name) {

1✔

984

        return this.__list__[name];

2,954✔

985

},

1✔

986

    // events are used in Lexer dynamic rules

1✔

987

    off: function(name, fn = null) {

1✔

995

},

1✔

996

    on: function(name, fn) {

1✔

997

        if (Array.isArray(name)) {

3✔

998

            name.forEach(name => this.on(name, fn));

1✔

999

        } else if (!this.__events__[name]) {

3✔

1000

            this.__events__[name] = [fn];

2✔

1004

},

1✔

1005

    trigger: function(name, ...args) {

1✔

1006

        if (this.__events__[name]) {

34✔

1007

            this.__events__[name].forEach(fn => fn(...args));

29✔

1008

29✔

1009

},

1✔

1010

    remove: function(name) {

1✔

1011

        delete this.__list__[name];

7✔

1012

        this.trigger('remove');

7✔

1013

},

1✔

1014

    append: function(name, value, type) {

1✔

1015

        this.__list__[name] = {

27✔

1016

            seq: name,

27✔

1017

            symbol: value,

27✔

1018

            type

27✔

1019

};

27✔

1020

        this.trigger('append');

27✔

1021

},

1✔

1022

    __events__: {},

1✔

1023

    __list__: {}

1✔

1024

};

1✔

1025

function is_special(token) {

87,053✔

1026

    return specials.names().includes(token);

87,053✔

1027

87,053✔

1028

function is_builtin(token) {

985✔

1029

    return specials.__builtins__.includes(token);

985✔

1030

985✔

1031

function is_literal(special) {

984✔

1032

    return specials.type(special) === specials.LITERAL;

984✔

1033

984✔

1034

function is_symbol_extension(special) {

985✔

1035

    return specials.type(special) === specials.SYMBOL;

985✔

1036

985✔

1037

// ----------------------------------------------------------------------

1✔

1038

const defined_specials = [

1✔

1039

    ["'", new LSymbol('quote'), specials.LITERAL],

1✔

1040

    ['`', new LSymbol('quasiquote'), specials.LITERAL],

1✔

1041

    [',@', new LSymbol('unquote-splicing'), specials.LITERAL],

1✔

1042

    [',', new LSymbol('unquote'), specials.LITERAL],

1✔

1043

    ["'>", new LSymbol('quote-promise'), specials.LITERAL]

1✔

1044

];

1✔

1045

1✔

1046

const builtins = defined_specials.map(arr => arr[0]);

1✔

1047

Object.freeze(builtins);

1✔

1048

1✔

1049

Object.defineProperty(specials, '__builtins__', {

1✔

1050

    writable: false,

1✔

1051

    value: builtins

1✔

1052

});

1✔

1053

defined_specials.forEach(([seq, symbol, type]) => {

1✔

1054

    specials.append(seq, symbol, type);

5✔

1055

});

1✔

1056

// ----------------------------------------------------------------------

1✔

1057

// :: Finite State Machine based incremental Lexer

1✔

1058

// ----------------------------------------------------------------------

1✔

1059

/* Lexer debugger

1✔

1060

   var DEBUG = false;

1✔

1061

   function log(...args) {

1✔

1062

   if (DEBUG) {

1✔

1063

   console.log(...args);

1✔

1064

1✔

1065

1✔

1066

*/

1✔

1067

class Lexer {

1✔

1068

    constructor(input, { whitespace = false } = {}) {

1✔

1069

        read_only(this, '__input__', input.replace(/\r/g, ''));

114✔

1070

        var internals = {};

114✔

1071

        // hide internals from introspection

114✔

1072

114✔

1073

            '_i', '_whitespace', '_col', '_newline', '_line',

114✔

1074

            '_state', '_next', '_token', '_prev_char'

114✔

1075

        ].forEach(name => {

114✔

1076

            Object.defineProperty(this, name, {

1,026✔

1077

                configurable: false,

1,026✔

1078

                enumerable: false,

1,026✔

1079

                get() {

1,026✔

1080

                    return internals[name];

1,778,916✔

1081

},

1,026✔

1082

                set(value) {

1,026✔

1083

                    internals[name] = value;

346,989✔

1084

346,989✔

1085

});

1,026✔

1086

});

114✔

1087

        this._whitespace = whitespace;

114✔

1088

        this._i = this._line = this._col = this._newline = 0;

114✔

1089

        this._state = this._next = this._token = null;

114✔

1090

        this._prev_char = '';

114✔

1091

114✔

1092

    get(name) {

1✔

1095

    set(name, value) {

1✔

1098

    token(meta = false) {

1✔

1099

        if (meta) {

133,164✔

1100

            let line = this._line;

133,145✔

1101

            if (this._whitespace && this._token === '\n') {

133,145✔

1102

                --line;

81✔

1103

81✔

1104

            return {

133,145✔

1105

                token: this._token,

133,145✔

1106

                col: this._col,

133,145✔

1107

                offset: this._i,

133,145✔

1108

                line

133,145✔

1109

};

133,145✔

1110

133,145✔

1111

        return this._token;

19✔

1112

133,164✔

1113

    peek(meta = false) {

1✔

1114

        if (this._i >= this.__input__.length) {

87,156✔

1115

            return eof;

84✔

1116

84✔

1117

        if (this._token) {

87,156✔

1118

            read_only(this, '__token__', this.token(true));

45,996✔

1119

            return this.token(meta);

45,996✔

1120

45,996✔

1121

        var found = this.next_token();

41,076✔

1122

        if (found) {

87,156✔

1123

            this._token = this.__input__.substring(this._i, this._next);

41,068✔

1124

            if (!this.__token__) {

41,068✔

1125

                // handle case when accessing __token__ from the syntax extension

104✔

1126

                // (e.g. string interpolation) as the first expression in a REPL

104✔

1127

                read_only(this, '__token__', this.token(true));

104✔

1128

104✔

1129

            return this.token(meta);

41,068✔

1130

41,068✔

1131

        return eof;

6✔

1132

87,156✔

1133

    skip() {

1✔

1134

        if (this._next !== null) {

41,063✔

1135

            this._token = null;

41,063✔

1136

            this._i = this._next;

41,063✔

1137

41,063✔

1138

41,063✔

1139

    read_line() {

1✔

1140

        var len = this.__input__.length;

7✔

1141

        if (this._i >= len) {

7✔

1142

            return eof;

1✔

1143

1✔

1144

        for (let i = this._i; i < len; ++i) {

7✔

1145

            var char = this.__input__[i];

81✔

1146

            if (char === '\n') {

81✔

1147

                const line = this.__input__.substring(this._i, i);

3✔

1148

                this._i = i + 1;

3✔

1149

                ++this._line;

3✔

1150

                return line;

3✔

1151

3✔

1152

81✔

1153

        return this.read_rest();

3✔

1154

7✔

1155

    read_rest() {

1✔

1156

        const i = this._i;

4✔

1157

        this._i = this.__input__.length;

4✔

1158

        return this.__input__.substring(i);

4✔

1159

4✔

1160

    read_string(num) {

1✔

1161

        const len = this.__input__.length;

3✔

1165

        if (num + this._i >= len) {

3✔

1166

            return this.read_rest();

1✔

1167

1✔

1168

        const end = this._i + num;

2✔

1169

        const result = this.__input__.substring(this._i, end);

2✔

1170

        const found = result.match(/\n/g);

2✔

1174

        this._i = end;

2✔

1175

        return result;

2✔

1176

3✔

1177

    peek_char() {

1✔

1178

        if (this._i >= this.__input__.length) {

162✔

1179

            return eof;

4✔

1180

4✔

1181

        return LCharacter(this.__input__[this._i]);

158✔

1182

162✔

1183

    read_char() {

1✔

1184

        const char = this.peek_char();

143✔

1185

        this.skip_char();

143✔

1186

        return char;

143✔

1187

143✔

1188

    skip_char() {

1✔

1189

        if (this._i < this.__input__.length) {

143✔

1190

            ++this._i;

140✔

1191

            this._token = null;

140✔

1192

140✔

1193

143✔

1194

    match_rule(rule, { prev_char, char, next_char } = {}) {

1✔

1195

        var [ re, prev_re, next_re, state ] = rule;

14,400,984✔

1199

        if (is_string(re)) {

14,400,984✔

1200

            if (re !== char) {

8,750,352✔

1201

                return false;

8,570,539✔

1202

8,570,539✔

1203

        } else if (!char.match(re)) {

14,400,984✔

1204

            return false;

4,446,214✔

1205

4,446,214✔

1206

        if (!match_or_null(prev_re, prev_char)) {

14,400,984✔

1207

            return false;

636,616✔

1208

636,616✔

1209

        if (!match_or_null(next_re, next_char)) {

14,400,984✔

1210

            return false;

481,243✔

1211

481,243✔

1212

        if (state !== this._state) {

14,400,984✔

1213

            return false;

211,108✔

1214

211,108✔

1215

        return true;

55,264✔

1216

14,400,984✔

1217

    next_token() {

1✔

1221

        let start = true;

41,076✔

1222

        loop:

41,076✔

1223

        for (let i = this._i, len = this.__input__.length; i < len; ++i) {

41,076✔

1224

            const char = this.__input__[i];

203,652✔

1225

            const prev_char = this.__input__[i - 1] || '';

203,652✔

1226

            const next_char = this.__input__[i + 1] || '';

203,652✔

1227

            if (char === '\n') {

203,652✔

1228

                ++this._line;

6,004✔

1229

                const newline = this._newline;

6,004✔

1230

                if (this._state === null) {

6,004✔

1231

                    // keep beginning of the newline to calculate col

5,956✔

1232

                    // we don't want to check inside the token (e.g. strings)

5,956✔

1233

                    this._newline = i + 1;

5,956✔

1234

5,956✔

1235

                if (this._whitespace && this._state === null) {

6,004✔

1236

                    this._next = i + 1;

81✔

1237

                    this._col = this._i - newline;

81✔

1238

                    return true;

81✔

1239

81✔

1240

6,004✔

1241

            // skip leading spaces

203,571✔

1242

            if (start && this._state === null && char.match(/\s/)) {

203,652✔

1243

                if (this._whitespace) {

73,632✔

1244

                    if (!next_char.match(/\s/)) {

515✔

1245

                        this._next = i + 1;

410✔

1246

                        this._col = this._i - this._newline;

410✔

1247

                        return true;

410✔

1248

                    } else {

515✔

1249

                        continue;

105✔

1250

105✔

1251

                } else {

73,632✔

1252

                    this._i = i + 1;

73,117✔

1253

                    continue;

73,117✔

1254

73,117✔

1255

73,632✔

1256

            start = false;

129,939✔

1257

            for (let rule of Lexer.rules) {

203,652✔

1258

                if (this.match_rule(rule, { prev_char, char, next_char })) {

14,400,984✔

1259

                    // change state to null if end of the token

55,264✔

1260

                    var next_state = rule[rule.length - 1];

55,264✔

1261

                    this._state = next_state;

55,264✔

1262

                    if (this._state === null) {

55,264✔

1263

                        this._next = i + 1;

40,577✔

1264

                        this._col = this._i - this._newline;

40,577✔

1265

                        return true;

40,577✔

1266

40,577✔

1267

                    // token is activated

14,687✔

1268

                    continue loop;

14,687✔

1269

14,687✔

1270

14,400,984✔

1271

            if (this._state !== null) {

74,675✔

1272

                // collect char in token

74,675✔

1273

                continue loop;

74,675✔

1274

74,675✔

1279

        // we need to ignore comments because they can be the last expression in code

8✔

1280

        // without extra newline at the end

8✔

1281

        if (![null, Lexer.comment].includes(this._state)) {

41,076✔

1283

            const line = this.__input__.substring(this._newline);

2✔

1284

            if (this.__input__[this._i] === '#') {

2✔

1285

                const expr = this.__input__.substring(this._i).replace(/^([^\s()\[\]]+).*/, '$1');

1✔

1286

                throw new Error(`Invalid Syntax at line ${line_number + 1}: invalid token ${expr}`);

1✔

1287

1✔

1288

            throw new Unterminated(`Invalid Syntax at line ${line_number + 1}: Unterminated expression ${line}`);

1✔

1289

1✔

1290

41,076✔

1291

1✔

1292

// ----------------------------------------------------------------------

1✔

1293

// TODO: cache the rules creation or whole list

1✔

1294

// ----------------------------------------------------------------------

1✔

1295

// State rule for literal symbol

1✔

1296

// ----------------------------------------------------------------------

1✔

1297

Lexer.literal_rule = function literal_rule(string, symbol, p_re = null, n_re = null) {

1✔

1301

    if (string.length === 1) {

419✔

1302

        return [[string, p_re, n_re, null, null]];

118✔

1303

118✔

1304

    var rules = [];

301✔

1305

    for (let i = 0, len = string.length; i < len; ++i) {

419✔

1306

        const rule = [];

1,290✔

1307

        rule.push(string[i]);

1,290✔

1308

        rule.push(string[i - 1] || p_re);

1,290✔

1309

        rule.push(string[i + 1] || n_re);

1,290✔

1310

        if (i === 0) {

1,290✔

1311

            rule.push(null);

301✔

1312

            rule.push(symbol);

301✔

1313

        } else if (i === len - 1) {

1,290✔

1314

            rule.push(symbol);

301✔

1315

            rule.push(null);

301✔

1316

        } else {

989✔

1317

            rule.push(symbol);

688✔

1318

            rule.push(symbol);

688✔

1319

688✔

1320

        rules.push(rule);

1,290✔

1321

1,290✔

1322

    return rules;

301✔

1323

};

1✔

1324

// ----------------------------------------------------------------------

1✔

1325

Lexer.string = Symbol.for('string');

1✔

1326

Lexer.string_escape = Symbol.for('string_escape');

1✔

1327

Lexer.symbol = Symbol.for('symbol');

1✔

1328

Lexer.comment = Symbol.for('comment');

1✔

1329

Lexer.regex = Symbol.for('regex');

1✔

1330

Lexer.regex_init = Symbol.for('regex_init');

1✔

1331

Lexer.regex_class = Symbol.for('regex_class');

1✔

1332

Lexer.character = Symbol.for('character');

1✔

1333

Lexer.bracket = Symbol.for('bracket');

1✔

1334

Lexer.b_symbol = Symbol.for('b_symbol');

1✔

1335

Lexer.b_symbol_ex = Symbol.for('b_symbol_ex');

1✔

1336

1✔

1337

Lexer.b_comment = Symbol.for('b_comment');

1✔

1338

Lexer.i_comment = Symbol.for('i_comment');

1✔

1339

Lexer.l_datum = Symbol.for('l_datum');

1✔

1340

Lexer.dot = Symbol.for('dot');

1✔

1341

// ----------------------------------------------------------------------

1✔

1342

Lexer.boundary = /^$|[\s()[\]']/;

1✔

1343

// ----------------------------------------------------------------------

1✔

1344

Lexer._rules = [

1✔

1345

    // char_re prev_re next_re from_state to_state

1✔

1346

    // null as to_state mean that is single char token

1✔

1347

    // string

1✔

1348

    [/"/, null, null, Lexer.string, null],

1✔

1349

    [/"/, null, null, null, Lexer.string],

1✔

1350

    [/"/, null, null, Lexer.string_escape, Lexer.string],

1✔

1351

    [/\\/, null, null, Lexer.string, Lexer.string_escape],

1✔

1352

    [/./, /\\/, null, Lexer.string_escape, Lexer.string],

1✔

1353

1✔

1354

    // hash special symbols, lexer don't need to distinguish those

1✔

1355

    // we only care if it's not pick up by vectors literals

1✔

1356

    [/#/, null, /[bdxoei]/i, null, Lexer.symbol],

1✔

1357

1✔

1358

    // characters

1✔

1359

    [/#/, null, /\\/, null, Lexer.character],

1✔

1360

    [/\\/, /#/, /\s/, Lexer.character, Lexer.character],

1✔

1361

    [/\\/, /#/, /[()[\]]/, Lexer.character, Lexer.character],

1✔

1362

    [/\s/, /\\/, null, Lexer.character, null],

1✔

1363

    [/\S/, null, Lexer.boundary, Lexer.character, null],

1✔

1364

1✔

1365

    // regex

1✔

1366

    [/#/, Lexer.boundary, /\//, null, Lexer.regex_init],

1✔

1367

    [/./, /\//, null, Lexer.regex_init, Lexer.regex],

1✔

1368

    [/[ \t]/, null, null, Lexer.regex, Lexer.regex],

1✔

1369

    [/\[/, /[^\\]/, null, Lexer.regex, Lexer.regex_class],

1✔

1370

    [/\]/, /[^\\]/, null, Lexer.regex_class, Lexer.regex],

1✔

1371

    [/[()[\]]/, null, null, Lexer.regex, Lexer.regex],

1✔

1372

    [/\//, /\\/, null, Lexer.regex, Lexer.regex],

1✔

1373

    [/\//, null, Lexer.boundary, Lexer.regex, null],

1✔

1374

    [/[gimyus]/, /\//, Lexer.boundary, Lexer.regex, null],

1✔

1375

    [/[gimyus]/, /\//, /[gimyus]/, Lexer.regex, Lexer.regex],

1✔

1376

    [/[gimyus]/, /[gimyus]/, Lexer.boundary, Lexer.regex, null],

1✔

1377

1✔

1378

    // comment

1✔

1379

    [/;/, /^$|[^#]/, null, null, Lexer.comment],

1✔

1380

    [/\n/, ';', null, Lexer.comment, null],

1✔

1381

    [/[\s\S]/, null, /\n/, Lexer.comment, null],

1✔

1382

    [/\s/, null, null, Lexer.comment, Lexer.comment],

1✔

1383

1✔

1384

    // block comment

1✔

1385

    [/#/, null, /\|/, null, Lexer.b_comment],

1✔

1386

    [/\s/, null, null, Lexer.b_comment, Lexer.b_comment],

1✔

1387

    [/#/, /\|/, null, Lexer.b_comment, null],

1✔

1388

1✔

1389

    // inline commentss

1✔

1390

    [/#/, null, /;/, null, Lexer.i_comment],

1✔

1391

    [/;/, /#/, null, Lexer.i_comment, null],

1✔

1392

1✔

1393

    // datum label

1✔

1394

    [/#/, null, /[0-9]/, null, Lexer.l_datum],

1✔

1395

    [/=/, /[0-9]/, null, Lexer.l_datum, null],

1✔

1396

    [/#/, /[0-9]/, null, Lexer.l_datum, null],

1✔

1397

1✔

1398

    // for dot comma `(a .,b)

1✔

1399

    [/\./, Lexer.boundary, /,/, null, null],

1✔

1400

1✔

1401

    // block symbols

1✔

1402

    [/\|/, null, null, null, Lexer.b_symbol],

1✔

1403

    [/\s/, null, null, Lexer.b_symbol, Lexer.b_symbol],

1✔

1404

    [/\|/, null, Lexer.boundary, Lexer.b_symbol, null],

1✔

1405

    [/\|/, null, /\S/, Lexer.b_symbol, Lexer.b_symbol_ex],

1✔

1406

    [/\S/, null, Lexer.boundary, Lexer.b_symbol_ex, null]

1✔

1407

];

1✔

1408

// ----------------------------------------------------------------------

1✔

1409

Lexer._brackets = [

1✔

1410

    [/[()[\]]/, null, null, null, null]

1✔

1411

];

1✔

1412

// ----------------------------------------------------------------------

1✔

1413

// :: symbols should be matched last

1✔

1414

// ----------------------------------------------------------------------

1✔

1415

Lexer._symbol_rules = [

1✔

1416

    [/\S/, Lexer.boundary, Lexer.boundary, null, null],

1✔

1417

    [/\S/, Lexer.boundary, null, null, Lexer.symbol],

1✔

1418

    [/\S/, null, Lexer.boundary, null, null],

1✔

1419

    [/\S/, null, null, null, Lexer.symbol],

1✔

1420

    [/\S/, null, Lexer.boundary, Lexer.symbol, null]

1✔

1421

];

1✔

1422

// ----------------------------------------------------------------------

1✔

1423

// :: Dynamic getter or Lexer state rules, parser uses this

1✔

1424

// :: so user code can modify Lexer using syntax extensions

1✔

1425

// ----------------------------------------------------------------------

1✔

1426

Lexer._cache = {

1✔

1427

    valid: false,

1✔

1428

    rules: null

1✔

1429

};

1✔

1430

// ----------------------------------------------------------------------

1✔

1431

specials.on(['remove', 'append'], function() {

1✔

1432

    Lexer._cache.valid = false;

29✔

1433

    Lexer._cache.rules = null;

29✔

1434

});

1✔

1435

// those constants need to be add as rules to the Lexer to work with vector literals

1✔

1436

const parsable_contants = {

1✔

1437

    '#null': null,

1✔

1438

    '#void': undefined

1✔

1439

};

1✔

1440

const directives = [

1✔

1441

    '#!fold-case',

1✔

1442

    '#!no-fold-case'

1✔

1443

];

1✔

1444

const hash_literals = ['#t', '#f'];

1✔

1445

// ----------------------------------------------------------------------

1✔

1446

Object.defineProperty(Lexer, 'rules', {

1✔

1447

    get() {

1✔

1448

        if (Lexer._cache.valid) {

129,939✔

1449

            return Lexer._cache.rules;

129,922✔

1450

129,922✔

1451

        const parsable = Object.keys(parsable_contants).concat(directives, hash_literals);

17✔

1452

        const tokens = specials.names().concat(parsable).sort((a, b) => {

17✔

1453

            return b.length - a.length || a.localeCompare(b);

1,534✔

1454

});

17✔

1455

17✔

1456

        // syntax-extensions tokens that share the same first character after hash

17✔

1457

        // should have same symbol, but because tokens are sorted, the longer

17✔

1458

        // tokens are always process first.

17✔

1459

        const special_rules = tokens.reduce((acc, token) => {

17✔

1460

            let symbol;

419✔

1461

            let after = null;

419✔

1462

            if (token[0] === '#') {

419✔

1463

                if (token.length === 1) {

280✔

1464

                    symbol = Symbol.for(token);

16✔

1465

                } else {

280✔

1466

                    if (hash_literals.includes(token)) {

264✔

1467

                        after = Lexer.boundary;

34✔

1468

34✔

1469

                    symbol = Symbol.for(token[1]);

264✔

1470

264✔

1471

            } else {

419✔

1472

                symbol = Symbol.for(token);

139✔

1473

139✔

1474

            const rules = Lexer.literal_rule(token, symbol, null, after);

419✔

1475

            return acc.concat(rules);

419✔

1476

        }, []);

17✔

1477

17✔

1478

        Lexer._cache.rules = Lexer._rules.concat(

17✔

1479

            Lexer._brackets,

17✔

1480

            special_rules,

17✔

1481

            Lexer._symbol_rules

17✔

1482

);

17✔

1483

17✔

1484

        Lexer._cache.valid = true;

17✔

1485

        return Lexer._cache.rules;

17✔

1486

129,939✔

1487

});

1✔

1488

// ----------------------------------------------------------------------

1✔

1489

function match_or_null(re, char) {

2,131,846✔

1490

    return re === null || char.match(re);

2,131,846✔

1491

2,131,846✔

1492

// ----------------------------------------------------------------------

1✔

1493

// :: Parser inspired by BiwaScheme

1✔

1494

// :: ref: https://github.com/biwascheme/biwascheme/blob/master/src/system/parser.js

1✔

1495

// ----------------------------------------------------------------------

1✔

1496

class Parser {

1✔

1497

    constructor({ env, meta = false, formatter = multiline_formatter } = {}) {

1✔

1498

        read_only(this, '_formatter', formatter, { hidden: true });

63✔

1499

        read_only(this, '__env__', env);

63✔

1500

        read_only(this, '_meta', meta, { hidden: true });

63✔

1501

        // datum labels

63✔

1502

        read_only(this, '_refs', [], { hidden: true });

63✔

1503

        read_only(this, '_state', {

63✔

1504

            parentheses: 0,

63✔

1505

            last_token: null,

63✔

1506

            fold_case: false

63✔

1507

        }, { hidden: true });

63✔

1508

63✔

1509

    _with_syntax_scope(fn) {

1✔

1510

        // expose parser and change stdin so parser extension can use current-input

157✔

1511

        // to read data from the parser stream #150

157✔

1512

        const internal = get_internal(this.__env__);

157✔

1513

        const stdin = internal.get('stdin');

157✔

1514

        global_env.set('lips',  { ...lips, __parser__: this });

157✔

1515

        internal.set('stdin', new ParserInputPort(this, this.__env__));

157✔

1516

        const cleanup = () => {

157✔

1517

            global_env.set('lips', lips);

157✔

1518

            internal.set('stdin', stdin);

157✔

1519

157✔

1520

        return unpromise(fn(), (result) => {

157✔

1521

            cleanup();

157✔

1522

            return result;

157✔

1523

        }, cleanup);

157✔

1524

157✔

1525

    prepare(arg) {

1✔

1526

        if (arg instanceof LString) {

63✔

1527

            arg = arg.toString();

39✔

1528

39✔

1529

        read_only(this, '__lexer__', new Lexer(arg));

63✔

1530

63✔

1531

    resolve(name) {

1✔

1534

    async peek() {

1✔

1535

        let token;

85,389✔

1536

        while (true) {

85,389✔

1537

            this._state.last_token = token = this.__lexer__.peek(true);

85,569✔

1538

            if (token === eof) {

85,569✔

1539

                return eof;

38✔

1540

38✔

1541

            if (this.is_comment(token.token)) {

85,569✔

1542

                this.skip();

163✔

1543

                continue;

163✔

1544

163✔

1545

            if (is_directive(token.token)) {

85,569✔

1546

                this.skip();

2✔

1547

                if (token.token === '#!fold-case') {

2✔

1548

                    this._state.fold_case = true;

1✔

1549

                } else if (token.token === '#!no-fold-case') {

1✔

1550

                    this._state.fold_case = false;

1✔

1551

1✔

1552

                continue;

2✔

1553

2✔

1554

            if (token.token === '#;') {

85,569✔

1555

                this.skip();

15✔

1559

                await this._read_object();

15✔

1560

                continue;

15✔

1561

15✔

1562

            break;

85,350✔

1563

85,350✔

1564

        token = this._formatter(token);

85,350✔

1565

        if (this._state.fold_case) {

85,389✔

1566

            token.token = foldcase_string(token.token);

51✔

1567

51✔

1568

        if (this._meta) {

85,389✔

1569

            return token;

59✔

1570

59✔

1571

        return token.token;

85,291✔

1572

85,389✔

1573

    reset() {

1✔

1574

        this._refs.length = 0;

545✔

1575

545✔

1576

    skip() {

1✔

1577

        this.__lexer__.skip();

39,548✔

1578

39,548✔

1579

    async read() {

1✔

1580

        const token = await this.peek();

17,721✔

1581

        this.skip();

17,721✔

1582

        return token;

17,721✔

1583

17,721✔

1584

    match_datum_label(token) {

1✔

1585

        if (this._meta) {

27,965✔

1586

            token = token.token;

20✔

1587

20✔

1588

        var m = token.match(/^#([0-9]+)=$/);

27,965✔

1589

        return m && m[1];

27,965✔

1590

27,965✔

1591

    match_datum_ref(token) {

1✔

1592

        if (this._meta) {

27,970✔

1593

            token = token.token;

20✔

1594

20✔

1595

        var m = token.match(/^#([0-9]+)#$/);

27,970✔

1596

        return m && m[1];

27,970✔

1597

27,970✔

1598

    is_open(token) {

1✔

1599

        if (this._meta) {

27,957✔

1600

            token = token.token;

20✔

1601

20✔

1602

        return ['(', '['].includes(token);

27,957✔

1603

27,957✔

1604

    is_close(token) {

1✔

1605

        if (this._meta) {

66,634✔

1606

            token = token.token;

47✔

1607

47✔

1608

        return [')', ']'].includes(token);

66,634✔

1609

66,634✔

1610

    async read_list() {

1✔

1611

        let head = nil, prev = head, dot;

10,236✔

1612

        while (true) {

10,236✔

1613

            const token = await this.peek();

37,689✔

1617

            if (this.is_close(token)) {

37,689✔

1618

                --this._state.parentheses;

10,233✔

1619

                this.skip();

10,233✔

1620

                break;

10,233✔

1621

10,233✔

1622

            if (token === '.' && !is_nil(head)) {

37,689✔

1623

                this.skip();

180✔

1624

                prev.cdr = await this._read_object();

180✔

1625

                dot = true;

180✔

1626

            } else if (dot) {

37,689✔

1627

                throw new Error('Parser: syntax error more than one element after dot');

1✔

1628

            } else {

27,276✔

1629

                const node = await this._read_object();

27,275✔

1630

                const cur = new Pair(node, nil);

27,273✔

1631

                if (is_nil(head)) {

27,275✔

1632

                    head = cur;

9,919✔

1633

                } else {

27,275✔

1634

                    prev.cdr = cur;

17,354✔

1635

17,354✔

1636

                prev = cur;

27,273✔

1637

27,273✔

1638

37,689✔

1639

        return head;

10,233✔

1640

10,236✔

1641

    async read_value() {

1✔

1642

        let token = await this.read();

17,721✔

1646

        return parse_argument(token, this._meta);

17,721✔

1647

17,721✔

1648

    is_comment(token) {

1✔

1650

85,530✔

1651

    evaluate(code) {

1✔

1652

        return evaluate(code, { env: this.__env__, error: (e) => {

124✔

1654

        } });

124✔

1655

124✔

1656

    // public API that handle R7RS datum labels

1✔

1657

    async read_object() {

1✔

1658

        this.reset();

545✔

1659

        var object = await this._read_object();

545✔

1663

        if (this._refs.length) {

545✔

1664

            return unpromise(this._resolve_object(object), object => {

1✔

1665

                if (is_pair(object)) {

1✔

1666

                    // mark cycles on parser level

1✔

1667

                    object.mark_cycles();

1✔

1668

1✔

1669

                return object;

1✔

1670

});

1✔

1671

1✔

1672

        return object;

537✔

1673

545✔

1674

    balanced() {

1✔

1675

        return this._state.parentheses === 0;

520✔

1676

520✔

1677

    ballancing_error(expr, prev) {

1✔

1678

        const count = this._state.parentheses;

1✔

1679

        let e;

1✔

1680

        if (count < 0) {

1✔

1681

            e = new Error('Parser: unexpected parenthesis');

1✔

1682

            e.__code__ = [prev.toString() + ')'];

1✔

1688

        this._agument_exception(e);

1✔

1689

        throw e;

1✔

1690

1✔

1691

    _agument_exception(e) {

1✔

1698

3✔

1699

    // TODO: Cover This function (array and object branch)

1✔

1700

    async _resolve_object(object) {

1✔

1701

1✔

1712

        if (is_pair(object)) {

1✔

1713

            return this._resolve_pair(object);

1✔

1714

1✔

1716

1✔

1717

    async _resolve_pair(pair) {

1✔

1718

        if (is_pair(pair)) {

254✔

1719

            if (pair.car instanceof DatumReference) {

129✔

1720

                pair.car = await pair.car.valueOf();

4✔

1721

            } else {

129✔

1722

                this._resolve_pair(pair.car);

125✔

1723

125✔

1724

            if (pair.cdr instanceof DatumReference) {

129✔

1725

                pair.cdr = await pair.cdr.valueOf();

1✔

1726

            } else {

129✔

1727

                this._resolve_pair(pair.cdr);

128✔

1728

128✔

1729

129✔

1730

        return pair;

254✔

1731

254✔

1732

    async _read_object() {

1✔

1733

        const token = await this.peek();

28,994✔

1734

        if (token === eof) {

28,994✔

1735

            return token;

38✔

1736

38✔

1737

        if (is_special(token)) {

28,994✔

1738

            // Built-in parser extensions are mapping short symbols to longer symbols

985✔

1739

            // that can be function or macro. Parser doesn't care

985✔

1740

            // if it's not built-in and the extension can be macro or function.

985✔

1741

            // FUNCTION: when it's used, it gets arguments like FEXPR and the

985✔

1742

            // result is returned by parser as is the macro.

985✔

1743

            // MACRO: if macro is used, then it is evaluated in place and the

985✔

1744

            // result is returned by parser and it is quoted.

985✔

1745

            const special = specials.get(token);

985✔

1746

            const builtin = is_builtin(token);

985✔

1747

            this.skip();

985✔

1748

            let expr, extension;

985✔

1749

            const is_symbol = is_symbol_extension(token);

985✔

1750

            const was_close_paren = this.is_close(await this.peek());

985✔

1751

            const object = is_symbol ? undefined : await this._read_object();

985✔

1755

            if (!builtin) {

985✔

1756

                extension = this.__env__.get(special.symbol);

157✔

1757

                if (typeof extension === 'function') {

157✔

1758

                    let args;

33✔

1759

                    if (is_literal(token)) {

33✔

1760

                        args = [object];

2✔

1763

                    } else if (is_pair(object)) {

31✔

1764

                        args = object.to_array(false);

20✔

1765

20✔

1766

                    if (args || is_symbol) {

33✔

1767

                        return this._with_syntax_scope(() => {

33✔

1768

                            return call_function(extension, is_symbol ? [] : args, {

33✔

1769

                                env: this.__env__,

33✔

1770

                                dynamic_env: this.__env__,

33✔

1771

                                use_dynamic: false

33✔

1772

});

33✔

1773

});

33✔

1774

33✔

1780

157✔

1781

            if (is_literal(token)) {

985✔

1782

                if (was_close_paren) {

829✔

1783

                    const e = new Error('Parse Error: expecting datum');

2✔

1784

                    this._agument_exception(e);

2✔

1785

                    throw e

2✔

1786

2✔

1787

                expr = new Pair(

827✔

1788

                    special.symbol,

827✔

1789

                    new Pair(

827✔

1790

                        object,

827✔

1791

nil

827✔

1792

827✔

1793

);

827✔

1794

            } else {

985✔

1795

                expr = new Pair(

122✔

1796

                    special.symbol,

122✔

1797

                    object

122✔

1798

);

122✔

1799

122✔

1800

            // Built-in parser extensions just expand into lists like 'x ==> (quote x)

949✔

1801

            if (builtin) {

985✔

1802

                return expr;

825✔

1803

825✔

1804

            // Evaluate parser extension at parse time

124✔

1805

            if (extension instanceof Macro) {

124✔

1806

                var result = await this._with_syntax_scope(() => {

124✔

1807

                    return this.evaluate(expr);

124✔

1808

});

124✔

1809

                // We need literal quotes to make that macro's return pairs works

124✔

1810

                // because after the parser returns the value it will be evaluated again

124✔

1811

                // by the interpreter, so we create quoted expressions.

124✔

1812

                if (is_pair(result) || result instanceof LSymbol) {

124✔

1813

                    return Pair.fromArray([LSymbol('quote'), result]);

3✔

1814

3✔

1815

                return result;

121✔

1822

985✔

1823

        var ref = this.match_datum_ref(token);

27,970✔

1824

        if (ref !== null) {

28,994✔

1825

            this.skip();

5✔

1826

            if (this._refs[ref]) {

5✔

1827

                return new DatumReference(ref, this._refs[ref]);

5✔

1828

5✔

1833

        var ref_label = this.match_datum_label(token);

27,965✔

1834

        if (ref_label !== null) {

28,994✔

1835

            this.skip();

5✔

1836

            this._refs[ref_label] = this._read_object();

5✔

1837

            return this._refs[ref_label];

5✔

1838

        } else if (this.is_close(token)) {

28,994✔

1839

            --this._state.parentheses;

3✔

1840

            this.skip();

3✔

1841

            // invalid state, we don't need to return anything

3✔

1842

        } else if (this.is_open(token)) {

27,960✔

1843

            ++this._state.parentheses;

10,236✔

1844

            this.skip();

10,236✔

1845

            return this.read_list();

10,236✔

1846

        } else {

27,957✔

1847

            return this.read_value();

17,721✔

1848

17,721✔

1849

28,994✔

1850

1✔

1851

class Unterminated extends Error { }

1✔

1852

Parser.Unterminated = Unterminated;

1✔

1853

// ----------------------------------------------------------------------

1✔

1854

// :: Parser helper that handles circular list structures

1✔

1855

// :: using datum labels

1✔

1856

// ----------------------------------------------------------------------

1✔

1857

class DatumReference {

1✔

1858

    constructor(name, data) {

1✔

1859

        this.name = name;

5✔

1860

        this.data = data;

5✔

1861

5✔

1862

    valueOf() {

1✔

1863

        return this.data;

5✔

1864

5✔

1865

1✔

1866

// ----------------------------------------------------------------------

1✔

1867

// :: Tokens are the array of strings from tokenizer

1✔

1868

// :: the return value is an array of lips code created out of Pair class.

1✔

1869

// :: env is needed for parser extensions that will invoke the function

1✔

1870

// :: or macro assigned to symbol, this function is async because

1✔

1871

// :: it evaluates the code, from parser extensions, that may return a promise.

1✔

1872

// ----------------------------------------------------------------------

1✔

1873

async function* _parse(arg, env) {

45✔

1874

    if (!env) {

45✔

1875

        if (global_env) {

42✔

1876

            env = global_env.get('**interaction-environment**', {

42✔

1877

                throwError: false

42✔

1878

});

42✔

1882

42✔

1883

    let parser;

44✔

1884

    if (arg instanceof Parser) {

45✔

1885

        parser = arg;

1✔

1886

    } else {

45✔

1887

        parser = new Parser({ env });

43✔

1888

        parser.prepare(arg);

43✔

1889

43✔

1890

    let prev;

44✔

1891

    while (true) {

45✔

1892

        const expr = await parser.read_object();

527✔

1893

        if (!parser.balanced()) {

527✔

1894

            parser.ballancing_error(expr, prev);

1✔

1895

1✔

1896

        if (expr === eof) {

527✔

1897

            break;

36✔

1898

36✔

1899

        prev = expr;

483✔

1900

        yield expr;

483✔

1901

483✔

1902

45✔

1903

// ----------------------------------------------------------------------

1✔

1904

function unpromise(value, fn = x => x, error = null) {

17,982,666✔

1905

    if (is_promise(value)) {

17,982,666✔

1906

        var ret = value.then(fn);

14,706✔

1907

        if (error === null) {

14,706✔

1908

            return ret;

6,845✔

1909

        } else {

14,706✔

1910

            return ret.catch(error);

7,861✔

1911

7,861✔

1912

14,706✔

1913

    if (value instanceof Array) {

17,982,666✔

1914

        return unpromise_array(value, fn, error);

3,454,436✔

1915

3,454,436✔

1916

    if (is_plain_object(value)) {

17,982,666✔

1917

        return unpromise_object(value, fn, error);

6,593✔

1918

6,593✔

1919

    return fn(value);

14,506,931✔

1920

17,982,666✔

1921

// ----------------------------------------------------------------------

1✔

1922

function unpromise_array(array, fn, error) {

3,454,436✔

1923

    if (array.find(is_promise)) {

3,454,436✔

1924

        return unpromise(promise_all(array), (arr) => {

3✔

1928

            return fn(arr);

3✔

1929

        }, error);

3✔

1930

3✔

1931

    return fn(array);

3,454,433✔

1932

3,454,436✔

1933

// ----------------------------------------------------------------------

1✔

1934

function unpromise_object(object, fn, error) {

6,593✔

1935

    const keys = Object.keys(object);

6,593✔

1936

    const values = [], anyPromise = [];

6,593✔

1937

    let i = keys.length;

6,593✔

1938

    while (i--) {

6,593✔

1939

        const key = keys[i];

63,755✔

1940

        const value = object[key];

63,755✔

1941

        values[i] = value;

63,755✔

1942

        if (is_promise(value)) {

63,755✔

1943

            anyPromise.push(value);

1✔

1944

1✔

1945

63,755✔

1946

    if (anyPromise.length) {

6,593✔

1947

        return unpromise(promise_all(values), (values) => {

1✔

1948

            const result = {};

1✔

1949

            values.forEach((value, i) => {

1✔

1950

                const key = keys[i];

2✔

1951

                result[key] = value;

2✔

1952

});

1✔

1956

            return result;

1✔

1957

        }, error);

1✔

1958

1✔

1959

    return fn(object);

6,592✔

1960

6,593✔

1961

// ----------------------------------------------------------------------

1✔

1962

function read_only(object, property, value, { hidden = false } = {}) {

93,755✔

1963

    Object.defineProperty(object, property, {

93,755✔

1964

        value,

93,755✔

1965

        configurable: true,

93,755✔

1966

        enumerable: !hidden

93,755✔

1967

});

93,755✔

1968

93,755✔

1969

// ----------------------------------------------------------------------

1✔

1970

// :: Function similar to Array.from that work on async iterators

1✔

1971

// ----------------------------------------------------------------------

1✔

1972

async function uniterate_async(object) {

39✔

1973

    const result = [];

39✔

1974

    for await (let item of object) {

39✔

1975

        result.push(item);

32✔

1976

32✔

1977

    return result;

32✔

1978

39✔

1979

// ----------------------------------------------------------------------

1✔

1980

// :: Function that return matcher function that match string against string

1✔

1981

// ----------------------------------------------------------------------

1✔

1982

function matcher(name, arg) {

12✔

1983

    if (arg instanceof RegExp) {

12✔

1984

        return x => String(x).match(arg);

3✔

1985

    } else if (is_function(arg)) {

12✔

1986

        // it will always be function

9✔

1987

        return arg;

9✔

1988

9✔

1990

12✔

1991

// ----------------------------------------------------------------------

1✔

1992

// :: Documentation decorator to LIPS functions if lines starts with :

1✔

1993

// :: they are ignored (not trimmed) otherwise it trims so

1✔

1994

// :: so you can have indent in source code

1✔

1995

// ----------------------------------------------------------------------

1✔

1996

function doc(name, fn, doc, dump) {

5,641,936✔

1997

    if (typeof name !== 'string') {

5,641,936✔

1998

        fn = arguments[0];

73,736✔

1999

        doc = arguments[1];

73,736✔

2000

        dump = arguments[2];

73,736✔

2001

        name = null;

73,736✔

2002

73,736✔

2003

    if (doc) {

5,641,936✔

2004

        if (dump) {

5,568,591✔

2005

            fn.__doc__ = doc;

358✔

2006

        } else {

5,568,591✔

2007

            fn.__doc__ = trim_lines(doc);

5,568,233✔

2008

5,568,233✔

2009

5,568,591✔

2010

    if (name) {

5,641,936✔

2011

        fn.__name__ = name;

5,568,200✔

2012

    } else if (fn.name && !is_lambda(fn)) {

5,641,936✔

2013

        fn.__name__ = fn.name;

7✔

2014

7✔

2015

    return fn;

5,641,936✔

2016

5,641,936✔

2017

// ----------------------------------------------------------------------

1✔

2018

function trim_lines(string) {

5,568,240✔

2019

    return string.split('\n').map(line => {

5,568,240✔

2020

        return line.trim();

22,272,961✔

2021

    }).join('\n');

5,568,240✔

2022

5,568,240✔

2023

// ----------------------------------------------------------------------

1✔

2024

// return last S-Expression

1✔

2025

// @param tokens - array of tokens (objects from tokenizer or strings)

1✔

2026

// @param sexp - number of expression to look behind

1✔

2027

// ----------------------------------------------------------------------

1✔

2028

function previousSexp(tokens, sexp = 1) {

443✔

2029

    var i = tokens.length;

443✔

2033

    outer: while (sexp-- && i >= 0) {

443✔

2034

        var count = 1;

443✔

2035

        while (count > 0) {

443✔

2036

            var token = tokens[--i];

3,706✔

2040

            if (token === '(' || token.token === '(') {

3,706✔

2041

                count--;

950✔

2042

            } else if (token === ')' || token.token === ')') {

3,706✔

2043

                count++;

507✔

2044

507✔

2045

3,706✔

2046

        i--;

443✔

2047

443✔

2048

    return tokens.slice(i + 1);

443✔

2049

443✔

2050

// ----------------------------------------------------------------------

1✔

2051

// :: Find the number of spaces in line

1✔

2052

// ----------------------------------------------------------------------

1✔

2053

function lineIndent(tokens) {

68✔

2057

    var i = tokens.length;

68✔

2061

    while (--i) {

68✔

2062

        if (tokens[i].token === '\n') {

476✔

2064

            if (token) {

49✔

2065

                return token.length;

49✔

2066

49✔

2067

49✔

2068

476✔

2069

    return 0;

19✔

2070

68✔

2071

// ----------------------------------------------------------------------

1✔

2072

// :: Token based pattern matching (used by formatter)

1✔

2073

// ----------------------------------------------------------------------

1✔

2074

/*

1✔

2075

  Function nested_pattern(pattern) {

1✔

2076

  return pattern instanceof Array ||

1✔

2077

  pattern instanceof Pattern;

1✔

2078

1✔

2079

*/

1✔

2080

// ----------------------------------------------------------------------

1✔

2081

function match(pattern, input) {

6,752✔

2082

    return inner_match(pattern, input) === input.length;

6,752✔

2083

    function inner_match(pattern, input) {

6,752✔

2084

/*

10,173✔

2085

          function empty_match() {

10,173✔

2086

          if (p <= 0 && i <= 0) {

10,173✔

2087

          return false;

10,173✔

2088

10,173✔

2089

          var prev_pattern = pattern[p - 1];

10,173✔

2090

          if (!nested_pattern(prev_pattern)) {

10,173✔

2091

          prev_pattern = [prev_pattern];

10,173✔

2092

10,173✔

2093

          var next_pattern = pattern[p + 1];

10,173✔

2094

          if (next_pattern && !nested_pattern(next_pattern)) {

10,173✔

2095

          next_pattern = [next_pattern];

10,173✔

2096

10,173✔

2097

          return match(prev_pattern, [input[i - 1]]) &&

10,173✔

2098

          (!next_pattern || match(next_pattern, [input[i]]));

10,173✔

2099

10,173✔

2100

*/

10,173✔

2101

        function get_first_match(patterns, input) {

10,173✔

2102

            for (let p of patterns) {

1,844✔

2103

                const m = inner_match(p, input);

1,868✔

2104

                if (m !== -1) {

1,868✔

2105

                    return m;

712✔

2106

712✔

2107

1,868✔

2108

            return -1;

1,132✔

2109

1,844✔

2110

        function not_symbol_match() {

10,173✔

2111

            return pattern[p] === Symbol.for('symbol') && !is_symbol_string(input[i]);

580✔

2112

580✔

2113

        function match_next() {

10,173✔

2114

            var next_pattern = pattern[p + 1];

1,251✔

2115

            var next_input = input[i + 1];

1,251✔

2116

            if (next_pattern !== undefined && next_input !== undefined) {

1,251✔

2117

                return inner_match([next_pattern], [next_input]);

1,159✔

2118

1,159✔

2119

1,251✔

2120

        var p = 0;

10,173✔

2121

        var glob = {};

10,173✔

2122

        for (var i = 0; i < input.length; ++i) {

10,173✔

2123

            if (typeof pattern[p] === 'undefined') {

24,781✔

2124

                return i;

1,569✔

2125

1,569✔

2126

            if (pattern[p] instanceof Pattern) {

24,781✔

2127

                var m;

1,401✔

2128

                if (['+', '*'].includes(pattern[p].flag)) {

1,401✔

2129

                    while (i < input.length) {

1,312✔

2130

                        m = get_first_match(pattern[p].patterns, input.slice(i));

1,755✔

2131

                        if (m === -1) {

1,755✔

2132

                            break;

1,090✔

2133

1,090✔

2134

                        i += m;

665✔

2135

665✔

2136

                    i -= 1;

1,312✔

2137

                    p++;

1,312✔

2138

                    continue;

1,312✔

2139

                } else if (pattern[p].flag === '?') {

1,401✔

2140

                    m = get_first_match(pattern[p].patterns, input.slice(i));

89✔

2141

                    if (m === -1) {

89✔

2142

                        i -= 2; // if not found use same test on same input again

42✔

2143

                    } else {

89✔

2144

                        p++;

47✔

2145

47✔

2146

                    continue;

89✔

2147

89✔

2148

            } else if (pattern[p] instanceof RegExp) {

24,781✔

2149

                if (!input[i].match(pattern[p])) {

14,869✔

2150

                    return -1;

5,525✔

2151

5,525✔

2156

            } else if (typeof pattern[p] === 'symbol') {

6,942✔

2157

                if (pattern[p] === Symbol.for('*')) {

6,548✔

2158

                    // ignore S-expressions inside for case when next pattern is )

5,968✔

2159

                    glob[p] = glob[p] || 0;

5,968✔

2160

                    //var zero_match = empty_match();

5,968✔

2161

                    if (['(', '['].includes(input[i])) {

5,968✔

2162

                        glob[p]++;

1,757✔

2163

                    } else if ([')', ']'].includes(input[i])) {

5,968✔

2164

                        glob[p]--;

1,205✔

2165

1,205✔

2166

                    if ((typeof pattern[p + 1] !== 'undefined' &&

5,968✔

2167

                         glob[p] === 0 && match_next() === -1) ||

5,968✔

2168

                        glob[p] > 0) {

5,968✔

2169

                        continue;

5,601✔

2170

5,601✔

2171

                } else if (not_symbol_match()) {

6,548✔

2172

                    return -1;

260✔

2173

260✔

2174

            } else if (pattern[p] instanceof Array) {

6,942✔

2175

                var inc = inner_match(pattern[p], input.slice(i));

394✔

2176

                if (inc === -1 || inc + i > input.length) {

394✔

2177

                    // if no more input it's not match

176✔

2178

                    return -1;

176✔

2179

176✔

2180

                i += inc - 1;

218✔

2181

                p++;

218✔

2182

                continue;

218✔

2186

            p++;

10,031✔

2187

10,031✔

2188

        if (pattern.length !== p) {

10,173✔

2189

            // if there are still patterns it's not match

2,011✔

2190

            return -1;

2,011✔

2191

2,011✔

2192

        return input.length;

632✔

2193

10,173✔

2194

6,752✔

2195

// ----------------------------------------------------------------------

1✔

2196

// :: Code formatter class

1✔

2197

// :: based on http://community.schemewiki.org/?scheme-style

1✔

2198

// :: and GNU Emacs scheme mode

1✔

2199

// :: it rely on meta data from tokenizer function

1✔

2200

// ----------------------------------------------------------------------

1✔

2201

function Formatter(code) {

21✔

2202

    this.__code__ = code.replace(/\r/g, '');

21✔

2203

21✔

2204

// ----------------------------------------------------------------------

1✔

2205

Formatter.defaults = {

1✔

2206

    offset: 0,

1✔

2207

    indent: 2,

1✔

2208

    exceptions: {

1✔

2209

        specials: [

1✔

2210

            /* eslint-disable max-len */

1✔

2211

            /^(?:#:)?(?:define(?:-values|-syntax|-macro|-class|-record-type)?|(?:call-with-(?:input-file|output-file|port))|lambda|let-env|try|catch|when|unless|while|syntax-rules|(let|letrec)(-syntax|\*?-values|\*)?)$/

1✔

2212

            /* eslint-enable */

1✔

2213

],

1✔

2214

        shift: {

1✔

2215

            1: ['&', '#']

1✔

2216

1✔

2217

1✔

2218

};

1✔

2219

Formatter.match = match;

1✔

2220

// ----------------------------------------------------------------------

1✔

2221

// :: Return indent for next line

1✔

2222

// ----------------------------------------------------------------------

1✔

2223

Formatter.prototype._options = function _options(options) {

1✔

2224

    var defaults = Formatter.defaults;

89✔

2225

    if (typeof options === 'undefined') {

89✔

2226

        return Object.assign({}, defaults);

21✔

2227

21✔

2231

    return {

89✔

2232

        ...defaults,

89✔

2233

        ...options,

89✔

2234

        exceptions: {

89✔

2235

            specials: [...defaults.exceptions.specials, ...specials],

89✔

2236

            shift: {

89✔

2237

                ...shift,

89✔

2238

                1: [...defaults.exceptions.shift[1], ...shift[1]]

89✔

2239

89✔

2240

89✔

2241

};

89✔

2242

};

1✔

2243

// ----------------------------------------------------------------------

1✔

2244

Formatter.prototype.indent = function indent(options) {

1✔

2247

};

1✔

2248

// ----------------------------------------------------------------------

1✔

2249

Formatter.exception_shift = function(token, settings) {

1✔

2250

    function match(list) {

103✔

2256

        } else {

174✔

2257

            var regexes = list.filter(s => s instanceof RegExp);

174✔

2258

            if (!regexes.length) {

174✔

2259

                return false;

71✔

2260

71✔

2261

            for (let re of regexes) {

174✔

2262

                if (token.match(re)) {

174✔

2263

                    return true;

32✔

2264

32✔

2265

174✔

2266

71✔

2267

        return false;

71✔

2268

174✔

2269

    if (match(settings.exceptions.specials)) {

103✔

2270

        return settings.indent;

32✔

2271

32✔

2272

    var shift = settings.exceptions.shift;

71✔

2273

    for (var [indent, tokens] of Object.entries(shift)) {

71✔

2277

71✔

2278

    return -1;

71✔

2279

};

1✔

2280

// ----------------------------------------------------------------------

1✔

2281

Formatter.prototype._indent = function _indent(tokens, options) {

1✔

2282

    var settings = this._options(options);

68✔

2283

    var spaces = lineIndent(tokens);

68✔

2284

    var sexp = previousSexp(tokens);

68✔

2285

    // one character before S-Expression

68✔

2286

    var before_sexpr = tokens[tokens.length - sexp.length - 1];

68✔

2287

    var last = tokens[tokens.length - 1];

68✔

2291

    if (sexp && sexp.length) {

68✔

2292

        if (sexp[0].line > 0) {

68✔

2293

            settings.offset = 0;

26✔

2294

26✔

2299

        } else {

68✔

2300

            // search for token before S-Expression for case like #(10 or &(:x

68✔

2301

            var exception = -1;

68✔

2302

            if (before_sexpr) {

68✔

2303

                var shift = Formatter.exception_shift(before_sexpr.token, settings);

35✔

2307

35✔

2308

            if (exception === -1) {

68✔

2309

                exception = Formatter.exception_shift(sexp[1].token, settings);

68✔

2310

68✔

2311

            if (exception !== -1) {

68✔

2312

                return settings.offset + sexp[0].col + exception;

32✔

2315

            } else if (sexp.length > 3 && sexp[1].line === sexp[3].line) {

36✔

2316

                if (sexp[1].token === '(' || sexp[1].token === '[') {

28✔

2317

                    return settings.offset + sexp[1].col;

19✔

2318

19✔

2319

                return settings.offset + sexp[3].col;

9✔

2320

            } else if (sexp[0].line === sexp[1].line) {

36✔

2321

                return settings.offset + settings.indent + sexp[0].col;

8✔

2331

68✔

2336

};

1✔

2337

// ----------------------------------------------------------------------

1✔

2338

function Ahead(pattern) {

1✔

2339

    this.pattern = pattern;

1✔

2340

1✔

2341

// TODO: make it print

1✔

2342

Ahead.prototype.toString = function() {

1✔

2344

};

1✔

2345

// ----------------------------------------------------------------------

1✔

2346

Ahead.prototype.match = function(string) {

1✔

2347

    return string.match(this.pattern);

138✔

2348

};

1✔

2349

// ----------------------------------------------------------------------

1✔

2350

// Pattern has any number of patterns that it matches using OR operator

1✔

2351

// Pattern is in form of array with regular expressions

1✔

2352

// ----------------------------------------------------------------------

1✔

2353

function Pattern(...args) {

6✔

2354

    var flag = args.pop();

6✔

2355

    this.patterns = args;

6✔

2356

    this.flag = flag;

6✔

2357

6✔

2358

Pattern.prototype.toString = function() {

1✔

2361

};

1✔

2362

// ----------------------------------------------------------------------

1✔

2363

Formatter.Pattern = Pattern;

1✔

2364

Formatter.Ahead = Ahead;

1✔

2365

var p_o = /^[[(]$/;

1✔

2366

var p_e = /^[\])]$/;

1✔

2367

var not_p = /[^()[\]]/;

1✔

2368

const not_close = new Ahead(/[^)\]]/);

1✔

2369

//const open = new Ahead(/[([]/);

1✔

2370

const glob = Symbol.for('*');

1✔

2371

const sexp_or_atom = new Pattern([p_o, glob, p_e], [not_p], '+');

1✔

2372

const sexp = new Pattern([p_o, glob, p_e], '+');

1✔

2373

const symbol = new Pattern([Symbol.for('symbol')], '?');

1✔

2374

const symbols = new Pattern([Symbol.for('symbol')], '*');

1✔

2375

const identifiers = [p_o, symbols, p_e];

1✔

2376

const let_value = new Pattern([p_o, Symbol.for('symbol'), glob, p_e], '+');

1✔

2377

const syntax_rules = keywords_re('syntax-rules');

1✔

2378

// rules for breaking S-Expressions into lines

1✔

2379

var def_lambda_re = keywords_re('define', 'lambda', 'define-macro', 'syntax-rules');

1✔

2380

/* eslint-disable max-len */

1✔

2381

var non_def = /^(?!.*\b(?:[()[\]]|define(?:-macro)?|let(?:\*|rec|-env|-syntax|)?|lambda|syntax-rules)\b).*$/;

1✔

2382

/* eslint-enable */

1✔

2383

var let_re = /^(?:#:)?(let(?:\*|rec|-env|-syntax)?)$/;

1✔

2384

// match keyword if it's normal token or gensym (prefixed with #:)

1✔

2385

function keywords_re(...args) {

7✔

2386

    return new RegExp(`^(?:#:)?(?:${args.join('|')})$`);

7✔

2387

7✔

2388

// line breaking rules

1✔

2389

Formatter.rules = [

1✔

2390

    [[sexp], 0, not_close],

1✔

2391

    [[p_o, keywords_re('begin', 'cond-expand')], 1, not_close],

1✔

2392

    [[p_o, let_re, symbol, p_o, let_value, p_e], 1, not_close],

1✔

2393

    [[p_o, let_re, symbol, sexp_or_atom], 1, not_close],

1✔

2394

    [[p_o, let_re, p_o, let_value], 1, not_close],

1✔

2395

    [[p_o, keywords_re('define-syntax'), /.+/], 1],

1✔

2396

    [[p_o, syntax_rules, not_p, identifiers], 1],

1✔

2397

    [[p_o, syntax_rules, not_p, identifiers, sexp], 1, not_close],

1✔

2398

    [[p_o, syntax_rules, identifiers], 1],

1✔

2399

    [[p_o, syntax_rules, identifiers, sexp], 1, not_close],

1✔

2400

    [[p_o, non_def, new Pattern([/[^()[\]]/], '+'), sexp], 1, not_close],

1✔

2401

    [[p_o, sexp], 1, not_close],

1✔

2402

    [[p_o, not_p, sexp], 1, not_close],

1✔

2403

    [[p_o, keywords_re('lambda', 'if'), not_p], 1, not_close],

1✔

2404

    [[p_o, keywords_re('while'), not_p, sexp], 1, not_close],

1✔

2405

    [[p_o, keywords_re('if'), not_p, glob], 1, not_close],

1✔

2406

    [[p_o, def_lambda_re, identifiers], 0, not_close],

1✔

2407

    [[p_o, def_lambda_re, identifiers, string_re], 0, not_close],

1✔

2408

    [[p_o, def_lambda_re, identifiers, string_re, sexp], 0, not_close],

1✔

2409

    [[p_o, def_lambda_re, identifiers, sexp], 0, not_close]

1✔

2410

];

1✔

2411

// ----------------------------------------------------------------------

1✔

2412

Formatter.prototype.break = function() {

1✔

2413

    var code = this.__code__.replace(/\n[ \t]*/g, '\n ').replace(/^\s+/, '');

21✔

2414

    // function that work when calling tokenize with meta data or not

21✔

2415

    const token = t => {

21✔

2416

        if (t.token.match(string_re) || t.token.match(re_re)) {

630✔

2417

            return t.token;

9✔

2418

        } else {

630✔

2419

            return t.token.replace(/\s+/, ' ');

621✔

2420

621✔

2421

};

21✔

2422

    const first_token_index = tokens => {

21✔

2423

        for (let i = tokens.length; i--;) {

6,752✔

2424

            const token = tokens[i];

9,504✔

2425

            if (token.trim() && !is_special(token)) {

9,504✔

2426

                return tokens.length - i - 1;

6,752✔

2427

6,752✔

2428

9,504✔

2430

    // Tokenize is part of the parser/lexer that split code into tokens and includes

21✔

2431

    // meta data like number of column or line

21✔

2432

    var tokens = tokenize(code, true).map(token).filter(t => t !== '\n');

21✔

2433

    const { rules } = Formatter;

21✔

2434

    outer: for (let i = 1; i < tokens.length; ++i) {

21✔

2435

        if (!tokens[i].trim()) {

541✔

2436

            continue;

166✔

2437

166✔

2438

        var sub = tokens.slice(0, i);

375✔

2439

        var sexp = {};

375✔

2440

        rules.map(b => b[1]).forEach(count => {

375✔

2441

            count = count.valueOf();

7,500✔

2442

            // some patterns require to check what was before like

7,500✔

2443

            // if inside let binding

7,500✔

2444

            if (count > 0 && !sexp[count]) {

7,500✔

2445

                sexp[count] = previousSexp(sub, count);

375✔

2446

375✔

2447

});

375✔

2448

        for (let [pattern, count, ext] of rules) {

541✔

2449

            count = count.valueOf();

6,752✔

2450

            // 0 count mean ignore the previous S-Expression

6,752✔

2451

            var test_sexp = count > 0 ? sexp[count] : sub;

6,752✔

2452

            const input = test_sexp.filter(t => t.trim() && !is_special(t));

6,752✔

2453

            const inc = first_token_index(test_sexp);

6,752✔

2454

            var m = match(pattern, input);

6,752✔

2455

            var next = tokens.slice(i).find(t => t.trim() && !is_special(t));

6,752✔

2456

            if (m && (ext instanceof Ahead && ext.match(next) || !ext)) {

6,752✔

2457

                const index = i - inc;

68✔

2458

                if (tokens[index] !== '\n') {

68✔

2459

                    if (!tokens[index].trim()) {

68✔

2460

                        tokens[index] = '\n';

68✔

2465

68✔

2466

                i += inc;

68✔

2467

                continue outer;

68✔

2468

68✔

2469

6,752✔

2470

307✔

2471

    this.__code__ = tokens.join('');

541✔

2472

    return this;

541✔

2473

};

1✔

2474

// ----------------------------------------------------------------------

1✔

2475

Formatter.prototype._spaces = function(i) {

1✔

2476

    return ' '.repeat(i);

68✔

2477

};

1✔

2478

// ----------------------------------------------------------------------

1✔

2479

// :: Auto formatting of code, it requires to have newlines

1✔

2480

// ----------------------------------------------------------------------

1✔

2481

Formatter.prototype.format = function format(options) {

1✔

2482

    // prepare code with single space after newline

21✔

2483

    // so we have space token to align

21✔

2484

    var code = this.__code__.replace(/[ \t]*\n[ \t]*/g, '\n ');

21✔

2485

    var tokens = tokenize(code, true);

21✔

2486

    var settings = this._options(options);

21✔

2487

    var indent = 0;

21✔

2488

    var offset = 0;

21✔

2489

    for (var i = 0; i < tokens.length; ++i) {

21✔

2490

        var token = tokens[i];

417✔

2491

        if (token.token === '\n') {

417✔

2492

            indent = this._indent(tokens.slice(0, i), settings);

68✔

2493

            offset += indent;

68✔

2494

            if (tokens[i + 1]) {

68✔

2495

                tokens[i + 1].token = this._spaces(indent);

68✔

2496

                // because we have single space as initial indent

68✔

2497

                indent--;

68✔

2498

                offset--;

68✔

2499

                for (var j = i + 2; j < tokens.length; ++j) {

68✔

2500

                    tokens[j].offset += offset;

424✔

2501

                    tokens[j].col += indent;

424✔

2502

                    if (tokens[j].token === '\n') {

424✔

2503

                        // ++i is called after the loop

49✔

2504

                        i = j - 1;

49✔

2505

                        break;

49✔

2506

49✔

2507

424✔

2508

68✔

2509

68✔

2510

417✔

2511

    return tokens.map(token => {

21✔

2512

        if (token.token.match(string_re)) {

698✔

2513

            if (token.token.match(/\n/)) {

9✔

2514

                var spaces = ' '.repeat(token.col);

3✔

2515

                var lines = token.token.split('\n');

3✔

2516

                token.token = [lines[0]].concat(lines.slice(1).map(line => {

3✔

2517

                    return spaces + line;

3✔

2518

                })).join('\n');

3✔

2519

3✔

2520

9✔

2521

        return token.token;

698✔

2522

    }).join('');

21✔

2523

};

1✔

2524

// ----------------------------------------------------------------------

1✔

2525

// :: the Unicode folding case mapping generated scripts/fold.scm to get

1✔

2526

// :: latest version of the file use `make fold`

1✔

2527

// ----------------------------------------------------------------------

1✔

2528

const fold_case_mapping = {

1✔

2529

    "65": 97, "66": 98, "67": 99, "68": 100,

1✔

2530

    "69": 101, "70": 102, "71": 103, "72": 104,

1✔

2531

    "73": 105, "74": 106, "75": 107, "76": 108,

1✔

2532

    "77": 109, "78": 110, "79": 111, "80": 112,

1✔

2533

    "81": 113, "82": 114, "83": 115, "84": 116,

1✔

2534

    "85": 117, "86": 118, "87": 119, "88": 120,

1✔

2535

    "89": 121, "90": 122, "181": 956, "192": 224,

1✔

2536

    "193": 225, "194": 226, "195": 227, "196": 228,

1✔

2537

    "197": 229, "198": 230, "199": 231, "200": 232,

1✔

2538

    "201": 233, "202": 234, "203": 235, "204": 236,

1✔

2539

    "205": 237, "206": 238, "207": 239, "208": 240,

1✔

2540

    "209": 241, "210": 242, "211": 243, "212": 244,

1✔

2541

    "213": 245, "214": 246, "216": 248, "217": 249,

1✔

2542

    "218": 250, "219": 251, "220": 252, "221": 253,

1✔

2543

    "222": 254, "256": 257, "258": 259, "260": 261,

1✔

2544

    "262": 263, "264": 265, "266": 267, "268": 269,

1✔

2545

    "270": 271, "272": 273, "274": 275, "276": 277,

1✔

2546

    "278": 279, "280": 281, "282": 283, "284": 285,

1✔

2547

    "286": 287, "288": 289, "290": 291, "292": 293,

1✔

2548

    "294": 295, "296": 297, "298": 299, "300": 301,

1✔

2549

    "302": 303, "306": 307, "308": 309, "310": 311,

1✔

2550

    "313": 314, "315": 316, "317": 318, "319": 320,

1✔

2551

    "321": 322, "323": 324, "325": 326, "327": 328,

1✔

2552

    "330": 331, "332": 333, "334": 335, "336": 337,

1✔

2553

    "338": 339, "340": 341, "342": 343, "344": 345,

1✔

2554

    "346": 347, "348": 349, "350": 351, "352": 353,

1✔

2555

    "354": 355, "356": 357, "358": 359, "360": 361,

1✔

2556

    "362": 363, "364": 365, "366": 367, "368": 369,

1✔

2557

    "370": 371, "372": 373, "374": 375, "376": 255,

1✔

2558

    "377": 378, "379": 380, "381": 382, "383": 115,

1✔

2559

    "385": 595, "386": 387, "388": 389, "390": 596,

1✔

2560

    "391": 392, "393": 598, "394": 599, "395": 396,

1✔

2561

    "398": 477, "399": 601, "400": 603, "401": 402,

1✔

2562

    "403": 608, "404": 611, "406": 617, "407": 616,

1✔

2563

    "408": 409, "412": 623, "413": 626, "415": 629,

1✔

2564

    "416": 417, "418": 419, "420": 421, "422": 640,

1✔

2565

    "423": 424, "425": 643, "428": 429, "430": 648,

1✔

2566

    "431": 432, "433": 650, "434": 651, "435": 436,

1✔

2567

    "437": 438, "439": 658, "440": 441, "444": 445,

1✔

2568

    "452": 454, "453": 454, "455": 457, "456": 457,

1✔

2569

    "458": 460, "459": 460, "461": 462, "463": 464,

1✔

2570

    "465": 466, "467": 468, "469": 470, "471": 472,

1✔

2571

    "473": 474, "475": 476, "478": 479, "480": 481,

1✔

2572

    "482": 483, "484": 485, "486": 487, "488": 489,

1✔

2573

    "490": 491, "492": 493, "494": 495, "497": 499,

1✔

2574

    "498": 499, "500": 501, "502": 405, "503": 447,

1✔

2575

    "504": 505, "506": 507, "508": 509, "510": 511,

1✔

2576

    "512": 513, "514": 515, "516": 517, "518": 519,

1✔

2577

    "520": 521, "522": 523, "524": 525, "526": 527,

1✔

2578

    "528": 529, "530": 531, "532": 533, "534": 535,

1✔

2579

    "536": 537, "538": 539, "540": 541, "542": 543,

1✔

2580

    "544": 414, "546": 547, "548": 549, "550": 551,

1✔

2581

    "552": 553, "554": 555, "556": 557, "558": 559,

1✔

2582

    "560": 561, "562": 563, "570": 11365, "571": 572,

1✔

2583

    "573": 410, "574": 11366, "577": 578, "579": 384,

1✔

2584

    "580": 649, "581": 652, "582": 583, "584": 585,

1✔

2585

    "586": 587, "588": 589, "590": 591, "837": 953,

1✔

2586

    "880": 881, "882": 883, "886": 887, "895": 1011,

1✔

2587

    "902": 940, "904": 941, "905": 942, "906": 943,

1✔

2588

    "908": 972, "910": 973, "911": 974, "913": 945,

1✔

2589

    "914": 946, "915": 947, "916": 948, "917": 949,

1✔

2590

    "918": 950, "919": 951, "920": 952, "921": 953,

1✔

2591

    "922": 954, "923": 955, "924": 956, "925": 957,

1✔

2592

    "926": 958, "927": 959, "928": 960, "929": 961,

1✔

2593

    "931": 963, "932": 964, "933": 965, "934": 966,

1✔

2594

    "935": 967, "936": 968, "937": 969, "938": 970,

1✔

2595

    "939": 971, "962": 963, "975": 983, "976": 946,

1✔

2596

    "977": 952, "981": 966, "982": 960, "984": 985,

1✔

2597

    "986": 987, "988": 989, "990": 991, "992": 993,

1✔

2598

    "994": 995, "996": 997, "998": 999, "1000": 1001,

1✔

2599

    "1002": 1003, "1004": 1005, "1006": 1007, "1008": 954,

1✔

2600

    "1009": 961, "1012": 952, "1013": 949, "1015": 1016,

1✔

2601

    "1017": 1010, "1018": 1019, "1021": 891, "1022": 892,

1✔

2602

    "1023": 893, "1024": 1104, "1025": 1105, "1026": 1106,

1✔

2603

    "1027": 1107, "1028": 1108, "1029": 1109, "1030": 1110,

1✔

2604

    "1031": 1111, "1032": 1112, "1033": 1113, "1034": 1114,

1✔

2605

    "1035": 1115, "1036": 1116, "1037": 1117, "1038": 1118,

1✔

2606

    "1039": 1119, "1040": 1072, "1041": 1073, "1042": 1074,

1✔

2607

    "1043": 1075, "1044": 1076, "1045": 1077, "1046": 1078,

1✔

2608

    "1047": 1079, "1048": 1080, "1049": 1081, "1050": 1082,

1✔

2609

    "1051": 1083, "1052": 1084, "1053": 1085, "1054": 1086,

1✔

2610

    "1055": 1087, "1056": 1088, "1057": 1089, "1058": 1090,

1✔

2611

    "1059": 1091, "1060": 1092, "1061": 1093, "1062": 1094,

1✔

2612

    "1063": 1095, "1064": 1096, "1065": 1097, "1066": 1098,

1✔

2613

    "1067": 1099, "1068": 1100, "1069": 1101, "1070": 1102,

1✔

2614

    "1071": 1103, "1120": 1121, "1122": 1123, "1124": 1125,

1✔

2615

    "1126": 1127, "1128": 1129, "1130": 1131, "1132": 1133,

1✔

2616

    "1134": 1135, "1136": 1137, "1138": 1139, "1140": 1141,

1✔

2617

    "1142": 1143, "1144": 1145, "1146": 1147, "1148": 1149,

1✔

2618

    "1150": 1151, "1152": 1153, "1162": 1163, "1164": 1165,

1✔

2619

    "1166": 1167, "1168": 1169, "1170": 1171, "1172": 1173,

1✔

2620

    "1174": 1175, "1176": 1177, "1178": 1179, "1180": 1181,

1✔

2621

    "1182": 1183, "1184": 1185, "1186": 1187, "1188": 1189,

1✔

2622

    "1190": 1191, "1192": 1193, "1194": 1195, "1196": 1197,

1✔

2623

    "1198": 1199, "1200": 1201, "1202": 1203, "1204": 1205,

1✔

2624

    "1206": 1207, "1208": 1209, "1210": 1211, "1212": 1213,

1✔

2625

    "1214": 1215, "1216": 1231, "1217": 1218, "1219": 1220,

1✔

2626

    "1221": 1222, "1223": 1224, "1225": 1226, "1227": 1228,

1✔

2627

    "1229": 1230, "1232": 1233, "1234": 1235, "1236": 1237,

1✔

2628

    "1238": 1239, "1240": 1241, "1242": 1243, "1244": 1245,

1✔

2629

    "1246": 1247, "1248": 1249, "1250": 1251, "1252": 1253,

1✔

2630

    "1254": 1255, "1256": 1257, "1258": 1259, "1260": 1261,

1✔

2631

    "1262": 1263, "1264": 1265, "1266": 1267, "1268": 1269,

1✔

2632

    "1270": 1271, "1272": 1273, "1274": 1275, "1276": 1277,

1✔

2633

    "1278": 1279, "1280": 1281, "1282": 1283, "1284": 1285,

1✔

2634

    "1286": 1287, "1288": 1289, "1290": 1291, "1292": 1293,

1✔

2635

    "1294": 1295, "1296": 1297, "1298": 1299, "1300": 1301,

1✔

2636

    "1302": 1303, "1304": 1305, "1306": 1307, "1308": 1309,

1✔

2637

    "1310": 1311, "1312": 1313, "1314": 1315, "1316": 1317,

1✔

2638

    "1318": 1319, "1320": 1321, "1322": 1323, "1324": 1325,

1✔

2639

    "1326": 1327, "1329": 1377, "1330": 1378, "1331": 1379,

1✔

2640

    "1332": 1380, "1333": 1381, "1334": 1382, "1335": 1383,

1✔

2641

    "1336": 1384, "1337": 1385, "1338": 1386, "1339": 1387,

1✔

2642

    "1340": 1388, "1341": 1389, "1342": 1390, "1343": 1391,

1✔

2643

    "1344": 1392, "1345": 1393, "1346": 1394, "1347": 1395,

1✔

2644

    "1348": 1396, "1349": 1397, "1350": 1398, "1351": 1399,

1✔

2645

    "1352": 1400, "1353": 1401, "1354": 1402, "1355": 1403,

1✔

2646

    "1356": 1404, "1357": 1405, "1358": 1406, "1359": 1407,

1✔

2647

    "1360": 1408, "1361": 1409, "1362": 1410, "1363": 1411,

1✔

2648

    "1364": 1412, "1365": 1413, "1366": 1414, "4256": 11520,

1✔

2649

    "4257": 11521, "4258": 11522, "4259": 11523, "4260": 11524,

1✔

2650

    "4261": 11525, "4262": 11526, "4263": 11527, "4264": 11528,

1✔

2651

    "4265": 11529, "4266": 11530, "4267": 11531, "4268": 11532,

1✔

2652

    "4269": 11533, "4270": 11534, "4271": 11535, "4272": 11536,

1✔

2653

    "4273": 11537, "4274": 11538, "4275": 11539, "4276": 11540,

1✔

2654

    "4277": 11541, "4278": 11542, "4279": 11543, "4280": 11544,

1✔

2655

    "4281": 11545, "4282": 11546, "4283": 11547, "4284": 11548,

1✔

2656

    "4285": 11549, "4286": 11550, "4287": 11551, "4288": 11552,

1✔

2657

    "4289": 11553, "4290": 11554, "4291": 11555, "4292": 11556,

1✔

2658

    "4293": 11557, "4295": 11559, "4301": 11565, "5112": 5104,

1✔

2659

    "5113": 5105, "5114": 5106, "5115": 5107, "5116": 5108,

1✔

2660

    "5117": 5109, "7296": 1074, "7297": 1076, "7298": 1086,

1✔

2661

    "7299": 1089, "7300": 1090, "7301": 1090, "7302": 1098,

1✔

2662

    "7303": 1123, "7304": 42571, "7312": 4304, "7313": 4305,

1✔

2663

    "7314": 4306, "7315": 4307, "7316": 4308, "7317": 4309,

1✔

2664

    "7318": 4310, "7319": 4311, "7320": 4312, "7321": 4313,

1✔

2665

    "7322": 4314, "7323": 4315, "7324": 4316, "7325": 4317,

1✔

2666

    "7326": 4318, "7327": 4319, "7328": 4320, "7329": 4321,

1✔

2667

    "7330": 4322, "7331": 4323, "7332": 4324, "7333": 4325,

1✔

2668

    "7334": 4326, "7335": 4327, "7336": 4328, "7337": 4329,

1✔

2669

    "7338": 4330, "7339": 4331, "7340": 4332, "7341": 4333,

1✔

2670

    "7342": 4334, "7343": 4335, "7344": 4336, "7345": 4337,

1✔

2671

    "7346": 4338, "7347": 4339, "7348": 4340, "7349": 4341,

1✔

2672

    "7350": 4342, "7351": 4343, "7352": 4344, "7353": 4345,

1✔

2673

    "7354": 4346, "7357": 4349, "7358": 4350, "7359": 4351,

1✔

2674

    "7680": 7681, "7682": 7683, "7684": 7685, "7686": 7687,

1✔

2675

    "7688": 7689, "7690": 7691, "7692": 7693, "7694": 7695,

1✔

2676

    "7696": 7697, "7698": 7699, "7700": 7701, "7702": 7703,

1✔

2677

    "7704": 7705, "7706": 7707, "7708": 7709, "7710": 7711,

1✔

2678

    "7712": 7713, "7714": 7715, "7716": 7717, "7718": 7719,

1✔

2679

    "7720": 7721, "7722": 7723, "7724": 7725, "7726": 7727,

1✔

2680

    "7728": 7729, "7730": 7731, "7732": 7733, "7734": 7735,

1✔

2681

    "7736": 7737, "7738": 7739, "7740": 7741, "7742": 7743,

1✔

2682

    "7744": 7745, "7746": 7747, "7748": 7749, "7750": 7751,

1✔

2683

    "7752": 7753, "7754": 7755, "7756": 7757, "7758": 7759,

1✔

2684

    "7760": 7761, "7762": 7763, "7764": 7765, "7766": 7767,

1✔

2685

    "7768": 7769, "7770": 7771, "7772": 7773, "7774": 7775,

1✔

2686

    "7776": 7777, "7778": 7779, "7780": 7781, "7782": 7783,

1✔

2687

    "7784": 7785, "7786": 7787, "7788": 7789, "7790": 7791,

1✔

2688

    "7792": 7793, "7794": 7795, "7796": 7797, "7798": 7799,

1✔

2689

    "7800": 7801, "7802": 7803, "7804": 7805, "7806": 7807,

1✔

2690

    "7808": 7809, "7810": 7811, "7812": 7813, "7814": 7815,

1✔

2691

    "7816": 7817, "7818": 7819, "7820": 7821, "7822": 7823,

1✔

2692

    "7824": 7825, "7826": 7827, "7828": 7829, "7835": 7777,

1✔

2693

    "7840": 7841, "7842": 7843, "7844": 7845, "7846": 7847,

1✔

2694

    "7848": 7849, "7850": 7851, "7852": 7853, "7854": 7855,

1✔

2695

    "7856": 7857, "7858": 7859, "7860": 7861, "7862": 7863,

1✔

2696

    "7864": 7865, "7866": 7867, "7868": 7869, "7870": 7871,

1✔

2697

    "7872": 7873, "7874": 7875, "7876": 7877, "7878": 7879,

1✔

2698

    "7880": 7881, "7882": 7883, "7884": 7885, "7886": 7887,

1✔

2699

    "7888": 7889, "7890": 7891, "7892": 7893, "7894": 7895,

1✔

2700

    "7896": 7897, "7898": 7899, "7900": 7901, "7902": 7903,

1✔

2701

    "7904": 7905, "7906": 7907, "7908": 7909, "7910": 7911,

1✔

2702

    "7912": 7913, "7914": 7915, "7916": 7917, "7918": 7919,

1✔

2703

    "7920": 7921, "7922": 7923, "7924": 7925, "7926": 7927,

1✔

2704

    "7928": 7929, "7930": 7931, "7932": 7933, "7934": 7935,

1✔

2705

    "7944": 7936, "7945": 7937, "7946": 7938, "7947": 7939,

1✔

2706

    "7948": 7940, "7949": 7941, "7950": 7942, "7951": 7943,

1✔

2707

    "7960": 7952, "7961": 7953, "7962": 7954, "7963": 7955,

1✔

2708

    "7964": 7956, "7965": 7957, "7976": 7968, "7977": 7969,

1✔

2709

    "7978": 7970, "7979": 7971, "7980": 7972, "7981": 7973,

1✔

2710

    "7982": 7974, "7983": 7975, "7992": 7984, "7993": 7985,

1✔

2711

    "7994": 7986, "7995": 7987, "7996": 7988, "7997": 7989,

1✔

2712

    "7998": 7990, "7999": 7991, "8008": 8000, "8009": 8001,

1✔

2713

    "8010": 8002, "8011": 8003, "8012": 8004, "8013": 8005,

1✔

2714

    "8025": 8017, "8027": 8019, "8029": 8021, "8031": 8023,

1✔

2715

    "8040": 8032, "8041": 8033, "8042": 8034, "8043": 8035,

1✔

2716

    "8044": 8036, "8045": 8037, "8046": 8038, "8047": 8039,

1✔

2717

    "8120": 8112, "8121": 8113, "8122": 8048, "8123": 8049,

1✔

2718

    "8126": 953, "8136": 8050, "8137": 8051, "8138": 8052,

1✔

2719

    "8139": 8053, "8152": 8144, "8153": 8145, "8154": 8054,

1✔

2720

    "8155": 8055, "8168": 8160, "8169": 8161, "8170": 8058,

1✔

2721

    "8171": 8059, "8172": 8165, "8184": 8056, "8185": 8057,

1✔

2722

    "8186": 8060, "8187": 8061, "8486": 969, "8490": 107,

1✔

2723

    "8491": 229, "8498": 8526, "8544": 8560, "8545": 8561,

1✔

2724

    "8546": 8562, "8547": 8563, "8548": 8564, "8549": 8565,

1✔

2725

    "8550": 8566, "8551": 8567, "8552": 8568, "8553": 8569,

1✔

2726

    "8554": 8570, "8555": 8571, "8556": 8572, "8557": 8573,

1✔

2727

    "8558": 8574, "8559": 8575, "8579": 8580, "9398": 9424,

1✔

2728

    "9399": 9425, "9400": 9426, "9401": 9427, "9402": 9428,

1✔

2729

    "9403": 9429, "9404": 9430, "9405": 9431, "9406": 9432,

1✔

2730

    "9407": 9433, "9408": 9434, "9409": 9435, "9410": 9436,

1✔

2731

    "9411": 9437, "9412": 9438, "9413": 9439, "9414": 9440,

1✔

2732

    "9415": 9441, "9416": 9442, "9417": 9443, "9418": 9444,

1✔

2733

    "9419": 9445, "9420": 9446, "9421": 9447, "9422": 9448,

1✔

2734

    "9423": 9449, "11264": 11312, "11265": 11313, "11266": 11314,

1✔

2735

    "11267": 11315, "11268": 11316, "11269": 11317, "11270": 11318,

1✔

2736

    "11271": 11319, "11272": 11320, "11273": 11321, "11274": 11322,

1✔

2737

    "11275": 11323, "11276": 11324, "11277": 11325, "11278": 11326,

1✔

2738

    "11279": 11327, "11280": 11328, "11281": 11329, "11282": 11330,

1✔

2739

    "11283": 11331, "11284": 11332, "11285": 11333, "11286": 11334,

1✔

2740

    "11287": 11335, "11288": 11336, "11289": 11337, "11290": 11338,

1✔

2741

    "11291": 11339, "11292": 11340, "11293": 11341, "11294": 11342,

1✔

2742

    "11295": 11343, "11296": 11344, "11297": 11345, "11298": 11346,

1✔

2743

    "11299": 11347, "11300": 11348, "11301": 11349, "11302": 11350,

1✔

2744

    "11303": 11351, "11304": 11352, "11305": 11353, "11306": 11354,

1✔

2745

    "11307": 11355, "11308": 11356, "11309": 11357, "11310": 11358,

1✔

2746

    "11311": 11359, "11360": 11361, "11362": 619, "11363": 7549,

1✔

2747

    "11364": 637, "11367": 11368, "11369": 11370, "11371": 11372,

1✔

2748

    "11373": 593, "11374": 625, "11375": 592, "11376": 594,

1✔

2749

    "11378": 11379, "11381": 11382, "11390": 575, "11391": 576,

1✔

2750

    "11392": 11393, "11394": 11395, "11396": 11397, "11398": 11399,

1✔

2751

    "11400": 11401, "11402": 11403, "11404": 11405, "11406": 11407,

1✔

2752

    "11408": 11409, "11410": 11411, "11412": 11413, "11414": 11415,

1✔

2753

    "11416": 11417, "11418": 11419, "11420": 11421, "11422": 11423,

1✔

2754

    "11424": 11425, "11426": 11427, "11428": 11429, "11430": 11431,

1✔

2755

    "11432": 11433, "11434": 11435, "11436": 11437, "11438": 11439,

1✔

2756

    "11440": 11441, "11442": 11443, "11444": 11445, "11446": 11447,

1✔

2757

    "11448": 11449, "11450": 11451, "11452": 11453, "11454": 11455,

1✔

2758

    "11456": 11457, "11458": 11459, "11460": 11461, "11462": 11463,

1✔

2759

    "11464": 11465, "11466": 11467, "11468": 11469, "11470": 11471,

1✔

2760

    "11472": 11473, "11474": 11475, "11476": 11477, "11478": 11479,

1✔

2761

    "11480": 11481, "11482": 11483, "11484": 11485, "11486": 11487,

1✔

2762

    "11488": 11489, "11490": 11491, "11499": 11500, "11501": 11502,

1✔

2763

    "11506": 11507, "42560": 42561, "42562": 42563, "42564": 42565,

1✔

2764

    "42566": 42567, "42568": 42569, "42570": 42571, "42572": 42573,

1✔

2765

    "42574": 42575, "42576": 42577, "42578": 42579, "42580": 42581,

1✔

2766

    "42582": 42583, "42584": 42585, "42586": 42587, "42588": 42589,

1✔

2767

    "42590": 42591, "42592": 42593, "42594": 42595, "42596": 42597,

1✔

2768

    "42598": 42599, "42600": 42601, "42602": 42603, "42604": 42605,

1✔

2769

    "42624": 42625, "42626": 42627, "42628": 42629, "42630": 42631,

1✔

2770

    "42632": 42633, "42634": 42635, "42636": 42637, "42638": 42639,

1✔

2771

    "42640": 42641, "42642": 42643, "42644": 42645, "42646": 42647,

1✔

2772

    "42648": 42649, "42650": 42651, "42786": 42787, "42788": 42789,

1✔

2773

    "42790": 42791, "42792": 42793, "42794": 42795, "42796": 42797,

1✔

2774

    "42798": 42799, "42802": 42803, "42804": 42805, "42806": 42807,

1✔

2775

    "42808": 42809, "42810": 42811, "42812": 42813, "42814": 42815,

1✔

2776

    "42816": 42817, "42818": 42819, "42820": 42821, "42822": 42823,

1✔

2777

    "42824": 42825, "42826": 42827, "42828": 42829, "42830": 42831,

1✔

2778

    "42832": 42833, "42834": 42835, "42836": 42837, "42838": 42839,

1✔

2779

    "42840": 42841, "42842": 42843, "42844": 42845, "42846": 42847,

1✔

2780

    "42848": 42849, "42850": 42851, "42852": 42853, "42854": 42855,

1✔

2781

    "42856": 42857, "42858": 42859, "42860": 42861, "42862": 42863,

1✔

2782

    "42873": 42874, "42875": 42876, "42877": 7545, "42878": 42879,

1✔

2783

    "42880": 42881, "42882": 42883, "42884": 42885, "42886": 42887,

1✔

2784

    "42891": 42892, "42893": 613, "42896": 42897, "42898": 42899,

1✔

2785

    "42902": 42903, "42904": 42905, "42906": 42907, "42908": 42909,

1✔

2786

    "42910": 42911, "42912": 42913, "42914": 42915, "42916": 42917,

1✔

2787

    "42918": 42919, "42920": 42921, "42922": 614, "42923": 604,

1✔

2788

    "42924": 609, "42925": 620, "42926": 618, "42928": 670,

1✔

2789

    "42929": 647, "42930": 669, "42931": 43859, "42932": 42933,

1✔

2790

    "42934": 42935, "42936": 42937, "42938": 42939, "42940": 42941,

1✔

2791

    "42942": 42943, "42944": 42945, "42946": 42947, "42948": 42900,

1✔

2792

    "42949": 642, "42950": 7566, "42951": 42952, "42953": 42954,

1✔

2793

    "42960": 42961, "42966": 42967, "42968": 42969, "42997": 42998,

1✔

2794

    "43888": 5024, "43889": 5025, "43890": 5026, "43891": 5027,

1✔

2795

    "43892": 5028, "43893": 5029, "43894": 5030, "43895": 5031,

1✔

2796

    "43896": 5032, "43897": 5033, "43898": 5034, "43899": 5035,

1✔

2797

    "43900": 5036, "43901": 5037, "43902": 5038, "43903": 5039,

1✔

2798

    "43904": 5040, "43905": 5041, "43906": 5042, "43907": 5043,

1✔

2799

    "43908": 5044, "43909": 5045, "43910": 5046, "43911": 5047,

1✔

2800

    "43912": 5048, "43913": 5049, "43914": 5050, "43915": 5051,

1✔

2801

    "43916": 5052, "43917": 5053, "43918": 5054, "43919": 5055,

1✔

2802

    "43920": 5056, "43921": 5057, "43922": 5058, "43923": 5059,

1✔

2803

    "43924": 5060, "43925": 5061, "43926": 5062, "43927": 5063,

1✔

2804

    "43928": 5064, "43929": 5065, "43930": 5066, "43931": 5067,

1✔

2805

    "43932": 5068, "43933": 5069, "43934": 5070, "43935": 5071,

1✔

2806

    "43936": 5072, "43937": 5073, "43938": 5074, "43939": 5075,

1✔

2807

    "43940": 5076, "43941": 5077, "43942": 5078, "43943": 5079,

1✔

2808

    "43944": 5080, "43945": 5081, "43946": 5082, "43947": 5083,

1✔

2809

    "43948": 5084, "43949": 5085, "43950": 5086, "43951": 5087,

1✔

2810

    "43952": 5088, "43953": 5089, "43954": 5090, "43955": 5091,

1✔

2811

    "43956": 5092, "43957": 5093, "43958": 5094, "43959": 5095,

1✔

2812

    "43960": 5096, "43961": 5097, "43962": 5098, "43963": 5099,

1✔

2813

    "43964": 5100, "43965": 5101, "43966": 5102, "43967": 5103,

1✔

2814

    "65313": 65345, "65314": 65346, "65315": 65347, "65316": 65348,

1✔

2815

    "65317": 65349, "65318": 65350, "65319": 65351, "65320": 65352,

1✔

2816

    "65321": 65353, "65322": 65354, "65323": 65355, "65324": 65356,

1✔

2817

    "65325": 65357, "65326": 65358, "65327": 65359, "65328": 65360,

1✔

2818

    "65329": 65361, "65330": 65362, "65331": 65363, "65332": 65364,

1✔

2819

    "65333": 65365, "65334": 65366, "65335": 65367, "65336": 65368,

1✔

2820

    "65337": 65369, "65338": 65370, "66560": 66600, "66561": 66601,

1✔

2821

    "66562": 66602, "66563": 66603, "66564": 66604, "66565": 66605,

1✔

2822

    "66566": 66606, "66567": 66607, "66568": 66608, "66569": 66609,

1✔

2823

    "66570": 66610, "66571": 66611, "66572": 66612, "66573": 66613,

1✔

2824

    "66574": 66614, "66575": 66615, "66576": 66616, "66577": 66617,

1✔

2825

    "66578": 66618, "66579": 66619, "66580": 66620, "66581": 66621,

1✔

2826

    "66582": 66622, "66583": 66623, "66584": 66624, "66585": 66625,

1✔

2827

    "66586": 66626, "66587": 66627, "66588": 66628, "66589": 66629,

1✔

2828

    "66590": 66630, "66591": 66631, "66592": 66632, "66593": 66633,

1✔

2829

    "66594": 66634, "66595": 66635, "66596": 66636, "66597": 66637,

1✔

2830

    "66598": 66638, "66599": 66639, "66736": 66776, "66737": 66777,

1✔

2831

    "66738": 66778, "66739": 66779, "66740": 66780, "66741": 66781,

1✔

2832

    "66742": 66782, "66743": 66783, "66744": 66784, "66745": 66785,

1✔

2833

    "66746": 66786, "66747": 66787, "66748": 66788, "66749": 66789,

1✔

2834

    "66750": 66790, "66751": 66791, "66752": 66792, "66753": 66793,

1✔

2835

    "66754": 66794, "66755": 66795, "66756": 66796, "66757": 66797,

1✔

2836

    "66758": 66798, "66759": 66799, "66760": 66800, "66761": 66801,

1✔

2837

    "66762": 66802, "66763": 66803, "66764": 66804, "66765": 66805,

1✔

2838

    "66766": 66806, "66767": 66807, "66768": 66808, "66769": 66809,

1✔

2839

    "66770": 66810, "66771": 66811, "66928": 66967, "66929": 66968,

1✔

2840

    "66930": 66969, "66931": 66970, "66932": 66971, "66933": 66972,

1✔

2841

    "66934": 66973, "66935": 66974, "66936": 66975, "66937": 66976,

1✔

2842

    "66938": 66977, "66940": 66979, "66941": 66980, "66942": 66981,

1✔

2843

    "66943": 66982, "66944": 66983, "66945": 66984, "66946": 66985,

1✔

2844

    "66947": 66986, "66948": 66987, "66949": 66988, "66950": 66989,

1✔

2845

    "66951": 66990, "66952": 66991, "66953": 66992, "66954": 66993,

1✔

2846

    "66956": 66995, "66957": 66996, "66958": 66997, "66959": 66998,

1✔

2847

    "66960": 66999, "66961": 67000, "66962": 67001, "66964": 67003,

1✔

2848

    "66965": 67004, "68736": 68800, "68737": 68801, "68738": 68802,

1✔

2849

    "68739": 68803, "68740": 68804, "68741": 68805, "68742": 68806,

1✔

2850

    "68743": 68807, "68744": 68808, "68745": 68809, "68746": 68810,

1✔

2851

    "68747": 68811, "68748": 68812, "68749": 68813, "68750": 68814,

1✔

2852

    "68751": 68815, "68752": 68816, "68753": 68817, "68754": 68818,

1✔

2853

    "68755": 68819, "68756": 68820, "68757": 68821, "68758": 68822,

1✔

2854

    "68759": 68823, "68760": 68824, "68761": 68825, "68762": 68826,

1✔

2855

    "68763": 68827, "68764": 68828, "68765": 68829, "68766": 68830,

1✔

2856

    "68767": 68831, "68768": 68832, "68769": 68833, "68770": 68834,

1✔

2857

    "68771": 68835, "68772": 68836, "68773": 68837, "68774": 68838,

1✔

2858

    "68775": 68839, "68776": 68840, "68777": 68841, "68778": 68842,

1✔

2859

    "68779": 68843, "68780": 68844, "68781": 68845, "68782": 68846,

1✔

2860

    "68783": 68847, "68784": 68848, "68785": 68849, "68786": 68850,

1✔

2861

    "71840": 71872, "71841": 71873, "71842": 71874, "71843": 71875,

1✔

2862

    "71844": 71876, "71845": 71877, "71846": 71878, "71847": 71879,

1✔

2863

    "71848": 71880, "71849": 71881, "71850": 71882, "71851": 71883,

1✔

2864

    "71852": 71884, "71853": 71885, "71854": 71886, "71855": 71887,

1✔

2865

    "71856": 71888, "71857": 71889, "71858": 71890, "71859": 71891,

1✔

2866

    "71860": 71892, "71861": 71893, "71862": 71894, "71863": 71895,

1✔

2867

    "71864": 71896, "71865": 71897, "71866": 71898, "71867": 71899,

1✔

2868

    "71868": 71900, "71869": 71901, "71870": 71902, "71871": 71903,

1✔

2869

    "93760": 93792, "93761": 93793, "93762": 93794, "93763": 93795,

1✔

2870

    "93764": 93796, "93765": 93797, "93766": 93798, "93767": 93799,

1✔

2871

    "93768": 93800, "93769": 93801, "93770": 93802, "93771": 93803,

1✔

2872

    "93772": 93804, "93773": 93805, "93774": 93806, "93775": 93807,

1✔

2873

    "93776": 93808, "93777": 93809, "93778": 93810, "93779": 93811,

1✔

2874

    "93780": 93812, "93781": 93813, "93782": 93814, "93783": 93815,

1✔

2875

    "93784": 93816, "93785": 93817, "93786": 93818, "93787": 93819,

1✔

2876

    "93788": 93820, "93789": 93821, "93790": 93822, "93791": 93823,

1✔

2877

    "125184": 125218, "125185": 125219, "125186": 125220, "125187": 125221,

1✔

2878

    "125188": 125222, "125189": 125223, "125190": 125224, "125191": 125225,

1✔

2879

    "125192": 125226, "125193": 125227, "125194": 125228, "125195": 125229,

1✔

2880

    "125196": 125230, "125197": 125231, "125198": 125232, "125199": 125233,

1✔

2881

    "125200": 125234, "125201": 125235, "125202": 125236, "125203": 125237,

1✔

2882

    "125204": 125238, "125205": 125239, "125206": 125240, "125207": 125241,

1✔

2883

    "125208": 125242, "125209": 125243, "125210": 125244, "125211": 125245,

1✔

2884

    "125212": 125246, "125213": 125247, "125214": 125248, "125215": 125249,

1✔

2885

    "125216": 125250, "125217": 125251

1✔

2886

};

1✔

2887

// ----------------------------------------------------------------------

1✔

2888

function foldcase_string(string) {

51✔

2889

    string = string.valueOf();

51✔

2890

    return Array.from(string).map(str => {

51✔

2891

        const ord = str.codePointAt(0);

141✔

2892

        const output = fold_case_mapping[ord];

141✔

2893

        if (output) {

141✔

2894

            return String.fromCodePoint(output);

30✔

2895

30✔

2896

        return str;

111✔

2897

    }).join('');

51✔

2898

51✔

2899

// ----------------------------------------------------------------------

1✔

2900

// :: Flatten nested arrays

1✔

2901

// :: ref: https://stackoverflow.com/a/27282907/387194

1✔

2902

// ----------------------------------------------------------------------

1✔

2928

// ----------------------------------------------------------------------

1✔

2929

// :: Fisher-Yates (aka Knuth) Shuffle

1✔

2930

// :: ref: https://stackoverflow.com/a/2450976/387194

1✔

2931

// ----------------------------------------------------------------------

1✔

2932

function shuffle(array, random) {

3✔

2933

  let currentIndex = array.length,  randomIndex;

3✔

2934

3✔

2935

  // While there remain elements to shuffle.

3✔

2936

  while (currentIndex > 0) {

3✔

2937

11✔

2938

    // Pick a remaining element.

11✔

2939

    randomIndex = Math.floor(random() * currentIndex);

11✔

2940

    currentIndex--;

11✔

2941

11✔

2942

    // And swap it with the current element.

11✔

2943

    [array[currentIndex], array[randomIndex]] = [

11✔

2944

      array[randomIndex], array[currentIndex]];

11✔

2945

11✔

2946

3✔

2947

  return array;

3✔

2948

3✔

2949

// ----------------------------------------------------------------------

1✔

2950

// :: Nil constructor with only once instance

1✔

2951

// ----------------------------------------------------------------------

1✔

2952

function Nil() {}

1✔

2953

Nil.prototype.toString = function() {

1✔

2954

    return '()';

3,571✔

2955

};

1✔

2956

Nil.prototype.valueOf = function() {

1✔

2957

    return undefined;

9✔

2958

};

1✔

2959

Nil.prototype.serialize = function() {

1✔

2960

    return 0;

1✔

2961

};

1✔

2962

Nil.prototype.to_object = function() {

1✔

2964

};

1✔

2965

Nil.prototype.append = function(x) {

1✔

2967

};

1✔

2968

Nil.prototype.to_array = function() {

1✔

2969

    return [];

2✔

2970

};

1✔

2971

var nil = new Nil();

1✔

2972

// ----------------------------------------------------------------------

1✔

2973

// :: Pair constructor

1✔

2974

// ----------------------------------------------------------------------

1✔

2975

function Pair(car, cdr) {

3,777,749✔

2976

    if (typeof this !== 'undefined' && this.constructor !== Pair ||

3,777,749✔

2977

        typeof this === 'undefined') {

3,777,749✔

2978

        return new Pair(car, cdr);

18,801✔

2979

18,801✔

2980

    this.car = car;

3,758,948✔

2981

    this.cdr = cdr;

3,758,948✔

2982

3,777,749✔

2983

// ----------------------------------------------------------------------

1✔

2984

function to_array(name, deep) {

2✔

2985

    return function recur(list) {

2✔

2986

        typecheck(name, list, ['pair', 'nil']);

1,926,172✔

2987

        if (is_nil(list)) {

1,926,172✔

2988

            return [];

18,451✔

2989

18,451✔

2990

        var result = [];

1,907,721✔

2991

        var node = list;

1,907,721✔

2992

        while (true) {

1,926,172✔

2993

            if (is_pair(node)) {

5,144,894✔

2997

                var car = node.car;

3,237,173✔

3001

                result.push(car);

3,237,173✔

3002

                node = node.cdr;

3,237,173✔

3003

            } else if (is_nil(node)) {

5,144,894✔

3004

                break;

1,907,720✔

3005

            } else {

1,907,721✔

3006

                throw new Error(`${name}: can't convert improper list`);

1✔

3007

1✔

3008

5,144,894✔

3009

        return result;

1,907,720✔

3010

};

2✔

3011

2✔

3012

// ----------------------------------------------------------------------

1✔

3013

Pair.prototype.flatten = function() {

1✔

3015

};

1✔

3016

// ----------------------------------------------------------------------

1✔

3017

Pair.prototype.length = function() {

1✔

3018

    var len = 0;

71,557✔

3019

    var node = this;

71,557✔

3020

    while (true) {

71,557✔

3021

        if (!node || is_nil(node) || !is_pair(node) ||

148,655✔

3022

            node.have_cycles('cdr')) {

148,655✔

3023

            break;

71,557✔

3024

71,557✔

3025

        len++;

77,098✔

3026

        node = node.cdr;

77,098✔

3027

77,098✔

3028

    return len;

71,557✔

3029

};

1✔

3030

// ----------------------------------------------------------------------

1✔

3031

Pair.match = function(obj, item) {

1✔

3032

    if (obj instanceof LSymbol) {

2,804,067✔

3033

        return LSymbol.is(obj, item);

961,208✔

3034

    } else if (is_pair(obj)) {

2,804,067✔

3035

        return Pair.match(obj.car, item) || Pair.match(obj.cdr, item);

1,701,847✔

3036

    } else if (Array.isArray(obj)) {

1,842,859✔

3037

        return obj.some(x => {

2✔

3038

            return Pair.match(x, item);

4✔

3039

});

2✔

3040

    } else if (is_plain_object(obj)) {

141,012✔

3041

        return Object.values(obj).some(x => {

1✔

3042

            return Pair.match(x, item);

1✔

3043

});

1✔

3044

1✔

3045

    return false;

141,009✔

3046

};

1✔

3047

// ----------------------------------------------------------------------

1✔

3048

Pair.prototype.find = function(item) {

1✔

3049

    return Pair.match(this, item);

400,284✔

3050

};

1✔

3051

1✔

3052

// ----------------------------------------------------------------------

1✔

3053

Pair.prototype.clone = function(deep = true) {

1✔

3054

    var visited = new Map();

116✔

3055

    function clone(node) {

116✔

3056

        if (is_pair(node)) {

730✔

3060

            var pair = new Pair();

307✔

3061

            visited.set(node, pair);

307✔

3062

            if (deep) {

307✔

3063

                pair.car = clone(node.car);

307✔

3067

            pair.cdr = clone(node.cdr);

307✔

3068

            pair[__cycles__] = node[__cycles__];

307✔

3069

            return pair;

307✔

3070

307✔

3071

        return node;

423✔

3072

730✔

3073

    return clone(this);

116✔

3074

};

1✔

3075

1✔

3076

// ----------------------------------------------------------------------

1✔

3077

Pair.prototype.last_pair = function() {

1✔

3078

    let node = this;

352✔

3079

    while (true) {

352✔

3080

        if (!is_pair(node.cdr)) {

1,332✔

3081

            return node;

352✔

3082

352✔

3086

        node = node.cdr;

980✔

3087

980✔

3088

};

1✔

3089

1✔

3090

// ----------------------------------------------------------------------

1✔

3091

Pair.prototype.to_array = function(deep = true) {

1✔

3092

    var result = [];

114✔

3093

    if (is_pair(this.car)) {

114✔

3096

        } else {

4✔

3097

            result.push(this.car);

4✔

3098

4✔

3099

    } else {

114✔

3100

        result.push(this.car.valueOf());

110✔

3101

110✔

3102

    if (is_pair(this.cdr)) {

114✔

3103

        result = result.concat(this.cdr.to_array(deep));

75✔

3104

75✔

3105

    return result;

114✔

3106

};

1✔

3107

1✔

3108

// ----------------------------------------------------------------------

1✔

3109

// :: TODO: change to Pair.from_array

1✔

3110

// ----------------------------------------------------------------------

1✔

3111

Pair.fromArray = function(array, deep = true, quote = false) {

1✔

3115

    if (deep === false) {

89,863✔

3116

        var list = nil;

42,316✔

3117

        for (let i = array.length; i--;) {

42,316✔

3118

            list = new Pair(array[i], list);

45,242✔

3119

45,242✔

3120

        return list;

42,316✔

3121

42,316✔

3125

    var result = nil;

47,547✔

3126

    var i = array.length;

47,547✔

3127

    while (i--) {

89,863✔

3128

        let car = array[i];

60,375✔

3129

        if (car instanceof Array) {

60,375✔

3130

            car = Pair.fromArray(car, deep, quote);

1,650✔

3131

        } else if (typeof car === 'string') {

60,375✔

3132

            car = LString(car);

44,940✔

3133

        } else if (typeof car === 'number' && !Number.isNaN(car)) {

58,725✔

3134

            car = LNumber(car);

8,031✔

3135

8,031✔

3136

        result = new Pair(car, result);

60,375✔

3137

60,375✔

3138

    return result;

47,547✔

3139

};

1✔

3140

1✔

3141

// ----------------------------------------------------------------------

1✔

3142

// By default to_object was created to create JavaScript objects,

1✔

3143

// so it uses valueOf to get native values.

1✔

3144

// Literal parameter was a hack to allow creating LComplex from LIPS code

1✔

3145

// ----------------------------------------------------------------------

1✔

3146

Pair.prototype.to_object = function(literal = false) {

1✔

3147

    var node = this;

17✔

3148

    var result = {};

17✔

3149

    while (true) {

17✔

3150

        if (is_pair(node) && is_pair(node.car)) {

46✔

3151

            var pair = node.car;

29✔

3152

            var name = pair.car;

29✔

3153

            if (name instanceof LSymbol) {

29✔

3154

                name = name.__name__;

22✔

3155

22✔

3156

            if (name instanceof LString) {

29✔

3157

                name = name.valueOf();

7✔

3158

7✔

3159

            var cdr = pair.cdr;

29✔

3163

            if (is_native(cdr)) {

29✔

3164

                if (!literal) {

28✔

3165

                    cdr = cdr.valueOf();

6✔

3166

6✔

3167

28✔

3168

            result[name] = cdr;

29✔

3169

            node = node.cdr;

29✔

3170

        } else {

46✔

3171

            break;

17✔

3172

17✔

3173

46✔

3174

    return result;

17✔

3175

};

1✔

3176

1✔

3177

// ----------------------------------------------------------------------

1✔

3178

Pair.fromPairs = function(array) {

1✔

3188

};

1✔

3189

1✔

3190

// ----------------------------------------------------------------------

1✔

3191

Pair.fromObject = function(obj) {

1✔

3194

};

1✔

3195

1✔

3196

// ----------------------------------------------------------------------

1✔

3197

Pair.prototype.reduce = function(fn) {

1✔

3198

    var node = this;

83,498✔

3199

    var result = nil;

83,498✔

3200

    while (true) {

83,498✔

3201

        if (!is_nil(node)) {

166,996✔

3202

            result = fn(result, node.car);

83,498✔

3203

            node = node.cdr;

83,498✔

3204

        } else {

83,498✔

3205

            break;

83,498✔

3206

83,498✔

3207

166,996✔

3208

    return result;

83,498✔

3209

};

1✔

3210

1✔

3211

// ----------------------------------------------------------------------

1✔

3212

Pair.prototype.reverse = function() {

1✔

3216

    var node = this;

322✔

3217

    var prev = nil;

322✔

3218

    while (!is_nil(node)) {

322✔

3219

        var next = node.cdr;

802✔

3220

        node.cdr = prev;

802✔

3221

        prev = node;

802✔

3222

        node = next;

802✔

3223

802✔

3224

    return prev;

322✔

3225

};

1✔

3226

1✔

3227

// ----------------------------------------------------------------------

1✔

3228

Pair.prototype.transform = function(fn) {

1✔

3251

};

1✔

3252

1✔

3253

// ----------------------------------------------------------------------

1✔

3254

Pair.prototype.map = function(fn) {

1✔

3255

    if (typeof this.car !== 'undefined') {

3,344✔

3256

        return new Pair(fn(this.car), is_nil(this.cdr) ? nil : this.cdr.map(fn));

3,344✔

3260

};

1✔

3261

const repr = new Map();

1✔

3262

// ----------------------------------------------------------------------

1✔

3263

function is_plain_object(object) {

17,258,072✔

3264

    return object && typeof object === 'object' && object.constructor === Object;

17,258,072✔

3265

17,258,072✔

3266

// ----------------------------------------------------------------------

1✔

3267

var props = Object.getOwnPropertyNames(Array.prototype);

1✔

3268

var array_methods = [];

1✔

3269

props.forEach(x => {

1✔

3270

    array_methods.push(Array[x], Array.prototype[x]);

40✔

3271

});

1✔

3272

// ----------------------------------------------------------------------

1✔

3273

function is_array_method(x) {

19,606✔

3274

    x = unbind(x);

19,606✔

3275

    return array_methods.includes(x);

19,606✔

3276

19,606✔

3277

// ----------------------------------------------------------------------

1✔

3278

function is_lips_function(x) {

3,053,874✔

3279

    return is_function(x) && (is_lambda(x) || x.__doc__);

3,053,874✔

3280

3,053,874✔

3281

// ----------------------------------------------------------------------

1✔

3282

function user_repr(obj) {

14✔

3284

    const plain_object = is_plain_object(obj);

14✔

3285

    var iterator = is_function(obj[Symbol.asyncIterator]) ||

14✔

3286

        is_function(obj[Symbol.iterator]);

14✔

3287

    let fn;

14✔

3290

    } else {

14✔

3291

        repr.forEach(function(value, key) {

14✔

3292

            key = unbind(key);

240✔

3293

            // if key is Object it should only work for plain_object

240✔

3294

            // because otherwise it will match every object

240✔

3295

            // we don't use instanceof so it don't work for subclasses

240✔

3296

            if (constructor === key &&

240✔

3297

                (key === Object && plain_object && !iterator || key !== Object)) {

240✔

3298

                fn = value;

15✔

3299

15✔

3300

});

14✔

3301

14✔

3302

    return fn;

14✔

3303

14✔

3304

// ----------------------------------------------------------------------

1✔

3305

var str_mapping = new Map();

1✔

3306

1✔

3307

    [true, '#t'],

1✔

3308

    [false, '#f'],

1✔

3309

    [null, '#null'],

1✔

3310

    [undefined, '#void']

1✔

3311

].forEach(([key, value]) => {

1✔

3312

    str_mapping.set(key, value);

4✔

3313

});

1✔

3314

// ----------------------------------------------------------------------

1✔

3315

// :: Debug function that can be used with JSON.stringify

1✔

3316

// :: that will show symbols

1✔

3317

// ----------------------------------------------------------------------

1✔

3318

/* c8 ignore next 22 */

1✔

3319

function symbolize(obj) {

1✔

3320

    if (obj && typeof obj === 'object') {

1✔

3321

        var result = {};

1✔

3322

        const symbols = Object.getOwnPropertySymbols(obj);

1✔

3323

        symbols.forEach((key) => {

1✔

3324

            const name = key.toString()

1✔

3325

                .replace(/Symbol\(([^)]+)\)/, '$1');

1✔

3326

            result[name] = toString(obj[key]);

1✔

3327

});

1✔

3328

        const props = Object.getOwnPropertyNames(obj);

1✔

3329

        props.forEach(key => {

1✔

3330

            const o = obj[key];

1✔

3331

            if (o && typeof o === 'object' && o.constructor === Object) {

1✔

3332

                result[key] = symbolize(o);

1✔

3333

            } else {

1✔

3334

                result[key] = toString(o);

1✔

3335

1✔

3336

});

1✔

3337

        return result;

1✔

3338

1✔

3339

    return obj;

1✔

3340

1✔

3341

// ----------------------------------------------------------------------

1✔

3345

// ----------------------------------------------------------------------

1✔

3349

// ----------------------------------------------------------------------

1✔

3382

// ----------------------------------------------------------------------

1✔

3383

// Instances extracted to make cyclomatic complexity of toString smaller

1✔

3384

const instances = new Map();

1✔

3385

// ----------------------------------------------------------------------

1✔

3386

1✔

3387

    [Error, function(e) {

1✔

3389

}],

1✔

3390

    [Pair, function(pair, { quote, skip_cycles, pair_args }) {

1✔

3391

        // make sure that repr directly after update set the cycle ref

218,818✔

3392

        if (!skip_cycles) {

218,818✔

3393

            pair.mark_cycles();

51,871✔

3394

51,871✔

3395

        return pair.toString(quote, ...pair_args);

218,818✔

3396

}],

1✔

3397

    [LCharacter, function(chr, { quote }) {

1✔

3401

        return chr.valueOf();

340✔

3402

}],

1✔

3403

    [LString, function(str, { quote }) {

1✔

3404

        str = str.toString();

70,864✔

3405

        if (quote) {

70,864✔

3406

            return JSON.stringify(str).replace(/\\n/g, '\n');

572✔

3407

572✔

3408

        return str;

70,292✔

3409

}],

1✔

3410

    [RegExp, function(re) {

1✔

3411

        return '#' + re.toString();

22✔

3412

}]

1✔

3413

].forEach(([cls, fn]) => {

1✔

3414

    instances.set(cls, fn);

5✔

3415

});

1✔

3416

// ----------------------------------------------------------------------

1✔

3417

const native_types = [

1✔

3418

    LSymbol,

1✔

3419

    Macro,

1✔

3420

    Values,

1✔

3421

    InputPort,

1✔

3422

    OutputPort,

1✔

3423

    Environment,

1✔

3424

    QuotedPromise

1✔

3425

];

1✔

3426

// ----------------------------------------------------------------------

1✔

3427

function toString(obj, quote, skip_cycles, ...pair_args) {

635,330✔

3432

    if (str_mapping.has(obj)) {

635,330✔

3433

        return str_mapping.get(obj);

433✔

3434

433✔

3435

    if (is_prototype(obj)) {

635,330✔

3436

        return '#<prototype>';

3✔

3437

3✔

3438

    if (obj) {

634,894✔

3439

        var cls = obj.constructor;

634,894✔

3440

        if (instances.has(cls)) {

634,894✔

3441

            return instances.get(cls)(obj, { quote, skip_cycles, pair_args });

290,044✔

3442

290,044✔

3443

634,894✔

3444

    // standard objects that have toString

344,850✔

3445

    for (let type of native_types) {

635,330✔

3446

        if (obj instanceof type) {

503,091✔

3447

            return obj.toString(quote);

318,485✔

3448

318,485✔

3449

503,091✔

3450

    if (obj instanceof LNumber) {

635,330✔

3451

        return obj.toString();

22,776✔

3452

22,776✔

3453

    // constants

3,589✔

3454

    if ([nil, eof].includes(obj)) {

635,330✔

3455

        return obj.toString();

3,571✔

3456

3,571✔

3463

    if (is_function(obj)) {

635,330✔

3464

        if (is_function(obj.toString) && obj.hasOwnProperty('toString')) {

3✔

3465

            // promises

3✔

3466

            return obj.toString().valueOf();

3✔

3467

3✔

3470

    if (typeof obj === 'object') {

635,330✔

3471

        var constructor = obj.constructor;

14✔

3477

        var name;

14✔

3480

        } else {

14✔

3481

            var fn = user_repr(obj);

14✔

3482

            if (fn) {

14✔

3483

                if (is_function(fn)) {

14✔

3484

                    return fn(obj, quote);

14✔

3488

14✔

3525

    return obj;

1✔

3526

635,330✔

3527

1✔

3528

// ----------------------------------------------------------------------------

1✔

3529

Pair.prototype.mark_cycles = function() {

1✔

3530

    mark_cycles(this);

1,586,099✔

3531

    return this;

1,586,099✔

3532

};

1✔

3533

1✔

3534

// ----------------------------------------------------------------------------

1✔

3535

Pair.prototype.have_cycles = function(name = null) {

1✔

3536

    if (!name) {

271,329,607✔

3537

        return this.have_cycles('car') || this.have_cycles('cdr');

322✔

3538

322✔

3539

    return !!(this[__cycles__] && this[__cycles__][name]);

271,329,607✔

3540

};

1✔

3541

1✔

3542

// ----------------------------------------------------------------------------

1✔

3543

Pair.prototype.is_cycle = function() {

1✔

3545

};

1✔

3546

1✔

3547

// ----------------------------------------------------------------------------

1✔

3557

1✔

3558

// ----------------------------------------------------------------------------

1✔

3559

function mark_cycles(pair) {

1,586,099✔

3560

    var seen_pairs = [];

1,586,099✔

3561

    var cycles = [];

1,586,099✔

3562

    var refs = [];

1,586,099✔

3563

    function visit(pair) {

1,586,099✔

3564

        if (!seen_pairs.includes(pair)) {

48,327,563✔

3565

            seen_pairs.push(pair);

48,327,295✔

3566

48,327,295✔

3567

48,327,563✔

3568

    function set(node, type, child, parents) {

1,586,099✔

3569

        if (is_pair(child)) {

96,655,126✔

3570

            if (parents.includes(child)) {

46,741,481✔

3571

                if (!refs.includes(child)) {

17✔

3572

                    refs.push(child);

15✔

3573

15✔

3574

                if (!node[__cycles__]) {

17✔

3575

                    node[__cycles__] = {};

15✔

3576

15✔

3577

                node[__cycles__][type] = child;

17✔

3578

                if (!cycles.includes(node)) {

17✔

3579

                    cycles.push(node);

15✔

3580

15✔

3581

                return true;

17✔

3582

17✔

3583

46,741,481✔

3584

96,655,126✔

3585

    const detect = trampoline(function detect_thunk(pair, parents) {

1,586,099✔

3586

        if (is_pair(pair)) {

98,241,208✔

3587

            delete pair[__ref__];

48,327,563✔

3588

            delete pair[__cycles__];

48,327,563✔

3589

            visit(pair);

48,327,563✔

3590

            parents.push(pair);

48,327,563✔

3591

            var car = set(pair, 'car', pair.car, parents);

48,327,563✔

3592

            var cdr = set(pair, 'cdr', pair.cdr, parents);

48,327,563✔

3593

            if (!car) {

48,327,563✔

3594

                detect(pair.car, parents.slice());

48,327,561✔

3595

48,327,561✔

3596

            if (!cdr) {

48,327,563✔

3597

                return new Thunk(() => {

48,327,548✔

3598

                    return detect_thunk(pair.cdr, parents.slice());

48,327,548✔

3599

});

48,327,548✔

3600

48,327,548✔

3601

48,327,563✔

3602

});

1,586,099✔

3603

    function mark_node(node, type) {

1,586,099✔

3604

        if (is_pair(node[__cycles__][type])) {

30✔

3605

            const count = ref_nodes.indexOf(node[__cycles__][type]);

17✔

3606

            node[__cycles__][type] = `#${count}#`;

17✔

3607

17✔

3608

30✔

3609

    detect(pair, []);

1,586,099✔

3610

    var ref_nodes = seen_pairs.filter(node => refs.includes(node));

1,586,099✔

3611

    ref_nodes.forEach((node, i) => {

1,586,099✔

3612

        node[__ref__] = `#${i}=`;

15✔

3613

});

1,586,099✔

3614

    cycles.forEach(node => {

1,586,099✔

3615

        mark_node(node, 'car');

15✔

3616

        mark_node(node, 'cdr');

15✔

3617

});

1,586,099✔

3618

1,586,099✔

3619

1✔

3620

// ----------------------------------------------------------------------

1✔

3621

// Trampoline based recursive pair to string that don't overflow the stack

1✔

3622

// ----------------------------------------------------------------------

1✔

3623

/* eslint-disable no-unused-vars */

1✔

3624

/* c8 ignore next */

1✔

3625

const pair_to_string = (function() {

1✔

3626

    const prefix = (pair, nested) => {

1✔

3634

};

1✔

3635

    const postfix = (pair, nested) => {

1✔

3640

};

1✔

3641

    return trampoline(function pairToString(pair, quote, extra = {}) {

1✔

3681

});

1✔

3682

})();

1✔

3683

1✔

3684

// ----------------------------------------------------------------------

1✔

3685

Pair.prototype.toString = function(quote, { nested = false } = {}) {

1✔

3686

    var arr = [];

530,571✔

3687

    if (this[__ref__]) {

530,571✔

3688

        arr.push(this[__ref__] + '(');

4✔

3689

    } else if (!nested) {

530,571✔

3690

        arr.push('(');

219,103✔

3691

219,103✔

3692

    var value;

530,571✔

3693

    if (this[__cycles__] && this[__cycles__].car) {

530,571✔

3694

        value = this[__cycles__].car;

1✔

3695

    } else {

530,571✔

3696

        value = toString(this.car, quote, true);

530,570✔

3697

530,570✔

3698

    if (value !== undefined) {

530,571✔

3699

        arr.push(value);

530,571✔

3700

530,571✔

3701

    if (is_pair(this.cdr)) {

530,571✔

3702

        if (this[__cycles__] && this[__cycles__].cdr) {

311,469✔

3703

            arr.push(' . ');

4✔

3704

            arr.push(this[__cycles__].cdr);

4✔

3705

        } else {

311,469✔

3706

            if (this.cdr[__ref__]) {

311,465✔

3707

                arr.push(' . ');

1✔

3708

            } else {

311,465✔

3709

                arr.push(' ');

311,464✔

3710

311,464✔

3711

            const cdr = this.cdr.toString(quote, { nested: true });

311,465✔

3712

            arr.push(cdr);

311,465✔

3713

311,465✔

3714

    } else if (!is_nil(this.cdr)) {

530,571✔

3715

        arr = arr.concat([' . ', toString(this.cdr, quote, true)]);

779✔

3716

779✔

3717

    if (!nested || this[__ref__]) {

530,571✔

3718

        arr.push(')');

219,107✔

3719

219,107✔

3720

    return arr.join('');

530,571✔

3721

};

1✔

3722

1✔

3723

// ----------------------------------------------------------------------

1✔

3724

Pair.prototype.set = function(prop, value) {

1✔

3729

};

1✔

3730

1✔

3731

// ----------------------------------------------------------------------

1✔

3732

Pair.prototype.append = function(arg) {

1✔

3736

    var p = this;

45,187✔

3744

    } else if (!is_nil(arg)) {

45,187✔

3745

        while (true) {

45,180✔

3746

            if (is_pair(p) && !is_nil(p.cdr)) {

57,007✔

3747

                p = p.cdr;

11,827✔

3748

            } else {

57,007✔

3749

                break;

45,180✔

3750

45,180✔

3751

57,007✔

3752

        p.cdr = arg;

45,180✔

3753

45,180✔

3754

    return this;

45,187✔

3755

};

1✔

3756

// ----------------------------------------------------------------------

1✔

3757

Pair.prototype.serialize = function() {

1✔

3758

    return [

8✔

3759

        this.car,

8✔

3760

        this.cdr

8✔

3761

];

8✔

3762

};

1✔

3763

// ----------------------------------------------------------------------

1✔

3764

// :: List iterator (for do-iterator macro)

1✔

3765

// ----------------------------------------------------------------------

1✔

3766

Pair.prototype[Symbol.iterator] = function() {

1✔

3767

    var node = this;

119✔

3768

    return {

119✔

3769

        next: function() {

119✔

3770

            var cur = node;

350✔

3771

            node = cur.cdr;

350✔

3772

            if (is_nil(cur)) {

350✔

3773

                return { value: undefined, done: true };

119✔

3774

            } else {

350✔

3775

                return { value: cur.car, done: false };

231✔

3776

231✔

3777

350✔

3778

};

119✔

3779

};

1✔

3780

// ----------------------------------------------------------------------

1✔

3781

// :: abs that work on BigInt

1✔

3782

// ----------------------------------------------------------------------

1✔

3786

// ----------------------------------------------------------------------

1✔

3787

function seq_compare(fn, args) {

142,132✔

3788

    var [a, ...rest] = args;

142,132✔

3789

    while (rest.length > 0) {

142,132✔

3790

        var [b] = rest;

142,134✔

3791

        if (!fn(a, b)) {

142,134✔

3792

            return false;

82,228✔

3793

82,228✔

3794

        [a, ...rest] = rest;

59,906✔

3795

59,906✔

3796

    return true;

59,904✔

3797

142,132✔

3798

1✔

3799

// ----------------------------------------------------------------------

1✔

3800

function equal(x, y) {

134,297✔

3801

    if (is_function(x)) {

134,297✔

3802

        return is_function(y) && unbind(x) === unbind(y);

20✔

3803

    } else if (x instanceof LNumber) {

134,297✔

3804

        if (!(y instanceof LNumber)) {

3,363✔

3805

            return false;

843✔

3806

843✔

3807

        let type;

2,520✔

3808

        if (x.__type__ === y.__type__) {

3,363✔

3809

            if (x.__type__ === 'complex') {

554✔

3810

                type = x.__im__.__type__ === y.__im__.__type__ &&

4✔

3811

                    x.__re__.__type__ === y.__re__.__type__;

4✔

3812

            } else {

554✔

3813

                type = true;

550✔

3814

550✔

3815

            if (type && x.cmp(y) === 0) {

554✔

3816

                if (x.valueOf() === 0) {

37✔

3817

                    return Object.is(x.valueOf(), y.valueOf());

5✔

3818

5✔

3819

                return true;

32✔

3820

32✔

3821

554✔

3822

        return false;

2,483✔

3837

    } else if (x instanceof LCharacter) {

130,914✔

3838

        if (!(y instanceof LCharacter)) {

143✔

3839

            return false;

116✔

3840

116✔

3841

        return x.__char__ === y.__char__;

27✔

3842

    } else {

130,914✔

3843

        return x === y;

130,771✔

3844

130,771✔

3845

134,297✔

3846

// ----------------------------------------------------------------------

1✔

3847

function same_atom(a, b) {

1,131✔

3848

    if (type(a) !== type(b)) {

1,131✔

3849

        return false;

463✔

3850

463✔

3857

    if (a instanceof LString) {

1,131✔

3858

        return a.valueOf() === b.valueOf();

39✔

3859

39✔

3860

    return equal(a, b);

629✔

3861

1,131✔

3862

// ----------------------------------------------------------------------

1✔

3863

function is_atom(obj) {

9,381✔

3864

    return obj instanceof LSymbol ||

9,381✔

3865

        LString.isString(obj) ||

9,381✔

3866

        is_nil(obj) ||

9,381✔

3867

        obj === null ||

9,381✔

3868

        obj instanceof LCharacter ||

9,381✔

3869

        obj instanceof LNumber ||

9,381✔

3870

        obj === true ||

9,381✔

3871

        obj === false;

9,381✔

3872

9,381✔

3873

// ----------------------------------------------------------------------

1✔

3874

var truncate = (function() {

1✔

3875

    if (Math.trunc) {

1✔

3876

        return Math.trunc;

1✔

3888

})();

1✔

3889

// ----------------------------------------------------------------------

1✔

3890

// :: Macro constructor

1✔

3891

// ----------------------------------------------------------------------

1✔

3892

function Macro(name, fn, doc, dump) {

91✔

3893

    if (typeof this !== 'undefined' && this.constructor !== Macro ||

91✔

3897

    typecheck('Macro', name, 'string', 1);

91✔

3898

    typecheck('Macro', fn, 'function', 2);

91✔

3899

    if (doc) {

91✔

3900

        if (dump) {

44✔

3901

            this.__doc__ = doc;

39✔

3902

        } else {

44✔

3903

            this.__doc__ = trim_lines(doc);

5✔

3904

5✔

3905

44✔

3906

    this.__name__ = name;

91✔

3907

    this.__fn__ = fn;

91✔

3908

91✔

3909

// ----------------------------------------------------------------------

1✔

3910

Macro.defmacro = function(name, fn, doc, dump) {

1✔

3911

    var macro = new Macro(name, fn, doc, dump);

68✔

3912

    macro.__defmacro__ = true;

68✔

3913

    return macro;

68✔

3914

};

1✔

3915

// ----------------------------------------------------------------------

1✔

3916

Macro.prototype.invoke = function(code, { env, ...rest }, macro_expand) {

1✔

3917

    var args = {

3,432,734✔

3918

        ...rest,

3,432,734✔

3919

        macro_expand

3,432,734✔

3920

};

3,432,734✔

3921

    var result = this.__fn__.call(env, code, args, this.__name__);

3,432,734✔

3922

    return result;

3,432,734✔

3923

    //return macro_expand ? quote(result) : result;

3,432,734✔

3924

};

1✔

3925

// ----------------------------------------------------------------------

1✔

3926

Macro.prototype.toString = function() {

1✔

3928

};

1✔

3929

// ----------------------------------------------------------------------

1✔

3930

const macro = 'define-macro';

1✔

3931

// ----------------------------------------------------------------------

1✔

3932

const recur_guard = -10000;

1✔

3933

function macro_expand(single) {

2✔

3934

    return async function(code, args) {

2✔

3935

        var env = args['env'] = this;

7✔

3936

        var bindings = [];

7✔

3937

        var let_macros = ['let', 'let*', 'letrec'];

7✔

3938

        var lambda = global_env.get('lambda');

7✔

3939

        var define = global_env.get('define');

7✔

3940

        function is_let_macro(symbol) {

7✔

3941

            var name = symbol.valueOf();

51✔

3942

            return let_macros.includes(name);

51✔

3943

51✔

3944

        function is_procedure(value, node) {

7✔

3945

            return value === define && is_pair(node.cdr.car);

47✔

3946

47✔

3947

        function is_lambda(value) {

7✔

3948

            return value === lambda;

46✔

3949

46✔

3950

        function proc_bindings(node) {

7✔

3951

            var names = [];

3✔

3952

            while (true) {

3✔

3953

                if (!is_nil(node)) {

8✔

3958

                    names.push(node.car.valueOf());

5✔

3959

                    node = node.cdr;

5✔

3960

                } else {

8✔

3961

                    break;

3✔

3962

3✔

3963

8✔

3964

            return [...bindings, ...names];

3✔

3965

3✔

3966

        function let_binding(node) {

7✔

3967

            return [...bindings, ...node.to_array(false).map(function(node) {

4✔

3968

                if (is_pair(node)) {

4✔

3969

                    return node.car.valueOf();

4✔

3970

4✔

3974

            })];

4✔

3975

4✔

3976

        function is_macro(name, value) {

7✔

3977

            return value instanceof Macro &&

44✔

3978

                value.__defmacro__ &&

44✔

3979

                !bindings.includes(name);

44✔

3980

44✔

3981

        async function expand_let_binding(node, n) {

7✔

3982

            if (is_nil(node)) {

8✔

3983

                return nil;

4✔

3984

4✔

3985

            var pair = node.car;

4✔

3986

            return new Pair(

4✔

3987

                new Pair(

4✔

3988

                    pair.car,

4✔

3989

                    await traverse(pair.cdr, n, env)

4✔

3990

),

4✔

3991

                await expand_let_binding(node.cdr)

4✔

3992

);

4✔

3993

8✔

3994

        async function traverse(node, n, env) {

7✔

3995

            if (is_pair(node) && node.car instanceof LSymbol) {

87✔

3999

                var name = node.car.valueOf();

51✔

4000

                var value = env.get(node.car, { throwError: false });

51✔

4001

                var is_let = is_let_macro(node.car);

51✔

4002

51✔

4003

                var is_binding = is_let ||

51✔

4004

                    is_procedure(value, node) ||

51✔

4005

                    is_lambda(value);

51✔

4006

51✔

4007

                if (is_binding && is_pair(node.cdr.car)) {

51✔

4008

                    var second;

7✔

4009

                    if (is_let) {

7✔

4010

                        bindings = let_binding(node.cdr.car);

4✔

4011

                        second = await expand_let_binding(node.cdr.car, n);

4✔

4012

                    } else {

7✔

4013

                        bindings = proc_bindings(node.cdr.car);

3✔

4014

                        second = node.cdr.car;

3✔

4015

3✔

4016

                    return new Pair(

7✔

4017

                        node.car,

7✔

4018

                        new Pair(

7✔

4019

                            second,

7✔

4020

                            await traverse(node.cdr.cdr, n, env)

7✔

4021

7✔

4022

);

7✔

4023

                } else if (is_macro(name, value)) {

51✔

4024

                    var code = value instanceof Syntax ? node : node.cdr;

6✔

4025

                    var result = await value.invoke(code, { ...args, env }, true);

6✔

4026

                    if (value instanceof Syntax) {

6✔

4027

                        const { expr, scope } = result;

1✔

4028

                        if (is_pair(expr)) {

1✔

4035

                            return traverse(expr, n, scope);

1✔

4036

1✔

4042

                    if (is_pair(result)) {

6✔

4049

                        return traverse(result, n, env);

4✔

4050

4✔

4054

6✔

4055

51✔

4056

            // TODO: CYCLE DETECT

75✔

4057

            var car = node.car;

75✔

4058

            if (is_pair(car)) {

87✔

4059

                car = await traverse(car, n, env);

27✔

4060

27✔

4061

            var cdr = node.cdr;

75✔

4062

            if (is_pair(cdr)) {

87✔

4063

                cdr = await traverse(cdr, n, env);

37✔

4064

37✔

4065

            var pair = new Pair(car, cdr);

75✔

4066

            return pair;

75✔

4067

87✔

4068

        //var this.__code__ = code;

7✔

4075

        return quote((await traverse(code, -1, env)).car);

7✔

4076

};

2✔

4077

2✔

4078

// ----------------------------------------------------------------------

1✔

4079

// TODO: Don't put Syntax as Macro they are not runtime

1✔

4080

// ----------------------------------------------------------------------

1✔

4081

function Syntax(fn, env) {

192✔

4082

    this.__env__ = env;

192✔

4083

    this.__fn__ = fn;

192✔

4084

    // allow macroexpand

192✔

4085

    this.__defmacro__ = true;

192✔

4086

192✔

4087

Syntax.__merge_env__ = Symbol.for('merge');

1✔

4088

// ----------------------------------------------------------------------

1✔

4089

Syntax.prototype = Object.create(Macro.prototype);

1✔

4090

Syntax.prototype.invoke = function(code, { error, env, use_dynamic }, macro_expand) {

1✔

4091

    var args = {

514✔

4092

        error,

514✔

4093

        env,

514✔

4094

        use_dynamic,

514✔

4095

        dynamic_env: this.__env__,

514✔

4096

        macro_expand

514✔

4097

};

514✔

4098

    return this.__fn__.call(env, code, args, this.__name__ || 'syntax');

514✔

4099

};

1✔

4100

Syntax.prototype.constructor = Syntax;

1✔

4101

Syntax.prototype.toString = function() {

1✔

4106

};

1✔

4107

// ----------------------------------------------------------------------

1✔

4108

// :: SRFI-139

1✔

4109

// ----------------------------------------------------------------------

1✔

4110

class SyntaxParameter {

1✔

4111

    constructor(syntax) {

1✔

4112

        read_only(this, '_syntax', syntax, { hidden: true });

21✔

4113

        read_only(this._syntax, '_param', true, { hidden: true });

21✔

4114

21✔

4115

1✔

4116

Syntax.Parameter = SyntaxParameter;

1✔

4117

// ----------------------------------------------------------------------

1✔

4118

// :: for usage in syntax-rule when pattern match it will return

1✔

4119

// :: list of bindings from code that match the pattern

1✔

4120

// :: TODO detect cycles

1✔

4121

// ----------------------------------------------------------------------

1✔

4122

function extract_patterns(pattern, code, symbols, ellipsis_symbol, scope = {}) {

1,011✔

4123

    const bindings = {

1,011✔

4124

        '...': {

1,011✔

4125

            symbols: { }, // symbols ellipsis (x ...)

1,011✔

4126

            lists: [ ]

1,011✔

4127

},

1,011✔

4128

        symbols: { }

1,011✔

4129

};

1,011✔

4130

    const { expansion, define } = scope;

1,011✔

4131

    // pattern_names parameter is used to distinguish

1,011✔

4132

    // multiple matches of ((x ...) ...) against ((1 2 3) (1 2 3))

1,011✔

4133

    // in loop we add x to the list so we know that this is not

1,011✔

4134

    // duplicated ellipsis symbol

1,011✔

4135

    log(symbols);

1,011✔

4136

    /* eslint-disable complexity */

1,011✔

4137

    function traverse(pattern, code, state = {}) {

1,011✔

4138

        const { ellipsis = false, trailing = false, pattern_names = [] } = state;

8,712✔

4139

        log({

8,712✔

4140

            code,

8,712✔

4141

            pattern

8,712✔

4142

});

8,712✔

4143

        if (is_atom(pattern) && !(pattern instanceof LSymbol)) {

8,712✔

4144

            return same_atom(pattern, code);

1,131✔

4145

1,131✔

4146

        if (pattern instanceof LSymbol) {

8,712✔

4147

            const literal = pattern.literal(); // TODO: literal() may be SLOW

2,828✔

4148

            if (symbols.includes(literal)) {

2,828✔

4149

                if (!LSymbol.is(code, literal) && !LSymbol.is(pattern, code)) {

354✔

4150

                    return false;

140✔

4151

140✔

4152

                const ref = expansion.ref(literal);

214✔

4153

                return !ref || ref === define || ref === global_env;

354✔

4154

354✔

4155

2,828✔

4156

        if (Array.isArray(pattern) && Array.isArray(code)) {

8,712✔

4157

            log('<<< a 1');

62✔

4158

            if (pattern.length === 0 && code.length === 0) {

62✔

4159

                return true;

12✔

4160

12✔

4161

            if (LSymbol.is(pattern[1], ellipsis_symbol)) {

62✔

4162

                if (pattern[0] instanceof LSymbol) {

21✔

4163

                    const name = pattern[0].valueOf();

19✔

4164

                    log('<<< a 2 ' + ellipsis);

19✔

4165

                    if (ellipsis) {

19✔

4166

                        const count = code.length - 2;

19✔

4167

                        const array_head = count > 0 ? code.slice(0, count) : code;

19✔

4168

                        const as_list = Pair.fromArray(array_head, false);

19✔

4169

                        if (!bindings['...'].symbols[name]) {

19✔

4170

                            bindings['...'].symbols[name] = new Pair(as_list, nil);

7✔

4171

                        } else {

19✔

4172

                            bindings['...'].symbols[name].append(new Pair(as_list, nil));

12✔

4173

12✔

4177

                } else if (Array.isArray(pattern[0])) {

21✔

4178

                    log('<<< a 3');

2✔

4179

                    const names = [...pattern_names];

2✔

4180

                    let node = code;

2✔

4181

                    const new_state = { ...state, pattern_names: names, ellipsis: true };

2✔

4185

2✔

4186

                if (pattern.length > 2) {

21✔

4187

                    const pat = pattern.slice(2);

12✔

4188

                    return traverse(pat, code.slice(-pat.length), state);

12✔

4189

12✔

4190

                return true;

9✔

4191

9✔

4192

            const first = traverse(pattern[0], code[0], state);

29✔

4193

            log({first, pattern: pattern[0], code: code[0]});

29✔

4194

            const rest = traverse(pattern.slice(1), code.slice(1), state);

29✔

4195

            log({first, rest});

29✔

4196

            return first && rest;

62✔

4197

62✔

4198

        // pattern (a b (x ...)) and (x ...) match nil

7,165✔

4199

        if (is_pair(pattern) &&

8,712✔

4200

            is_pair(pattern.car) &&

8,712✔

4201

            is_pair(pattern.car.cdr) &&

8,712✔

4202

            LSymbol.is(pattern.car.cdr.car, ellipsis_symbol)) {

8,712✔

4203

            log('>> 0');

386✔

4204

            if (is_nil(code)) {

386✔

4205

                log({ pattern });

7✔

4206

                if (pattern.car.car instanceof LSymbol) {

7✔

4207

                    let name = pattern.car.car.valueOf();

7✔

4212

                    bindings['...'].symbols[name] = code;

7✔

4213

7✔

4214

7✔

4215

386✔

4216

        if (is_pair(pattern) &&

8,712✔

4217

            is_pair(pattern.cdr) &&

8,712✔

4218

            LSymbol.is(pattern.cdr.car, ellipsis_symbol)) {

8,712✔

4219

            log('>> 1 (a)');

918✔

4220

            // pattern (... ???) - SRFI-46

918✔

4221

            if (!is_nil(pattern.cdr.cdr)) {

918✔

4222

                if (is_pair(pattern.cdr.cdr)) {

26✔

4223

                    log('>> 1 (b)');

22✔

4224

                    // if we have (x ... a b) we need to remove two from the end

22✔

4225

                    const list_len = pattern.cdr.cdr.length();

22✔

4226

                    const improper_list = !is_nil(pattern.last_pair().cdr);

22✔

4227

                    if (!is_pair(code)) {

22✔

4228

                        return false;

3✔

4229

3✔

4230

                    let code_len = code.length();

19✔

4231

                    let list = code;

19✔

4232

                    const trailing = improper_list ? 1 : 1;

22✔

4233

                    while (code_len - trailing > list_len) {

22✔

4234

                        list = list.cdr;

33✔

4235

                        code_len--;

33✔

4236

33✔

4237

                    const rest = list.cdr;

19✔

4238

                    list.cdr = nil;

19✔

4239

                    const new_sate = { ...state, trailing: improper_list };

19✔

4243

22✔

4244

26✔

4245

            if (pattern.car instanceof LSymbol) {

918✔

4246

                let name = pattern.car.__name__;

773✔

4247

                if (bindings['...'].symbols[name] &&

773✔

4251

                log('>> 1 (next)');

773✔

4252

                if (is_nil(code)) {

773✔

4253

                    log('>> 2');

182✔

4254

                    if (ellipsis) {

182✔

4255

                        log('NIL');

4✔

4256

                        bindings['...'].symbols[name] = nil;

4✔

4257

                    } else {

182✔

4258

                        log('NULL');

178✔

4259

                        bindings['...'].symbols[name] = null;

178✔

4260

178✔

4261

                } else if (is_pair(code) && (is_pair(code.car) || is_nil(code.car))) {

773✔

4262

                    log('>> 3 ' + ellipsis);

179✔

4263

                    if (ellipsis) {

179✔

4264

                        if (bindings['...'].symbols[name]) {

7✔

4265

                            let node = bindings['...'].symbols[name];

4✔

4266

                            if (is_nil(node)) {

4✔

4267

                                node = new Pair(nil, new Pair(code, nil));

1✔

4268

                            } else {

4✔

4269

                                node = node.append(new Pair(code, nil));

3✔

4270

3✔

4271

                            bindings['...'].symbols[name] = node;

4✔

4272

                        } else {

7✔

4273

                            bindings['...'].symbols[name] = new Pair(code, nil);

3✔

4274

3✔

4275

                    } else {

179✔

4276

                        log('>> 4');

172✔

4277

                        bindings['...'].symbols[name] = new Pair(code, nil);

172✔

4278

172✔

4279

                } else {

591✔

4280

                    log('>> 6');

412✔

4281

                    if (is_pair(code)) {

412✔

4282

                        log('>> 7 ' + ellipsis);

328✔

4283

                        // cons (a . b) => (var ... . x)

328✔

4284

                        if (!is_pair(code.cdr) && !is_nil(code.cdr)) {

328✔

4285

                            log('>> 7 (b)');

1✔

4288

                            } else if (!bindings['...'].symbols[name]) {

1✔

4289

                                bindings['...'].symbols[name] = new Pair(code.car, nil);

1✔

4290

                                return traverse(pattern.cdr.cdr, code.cdr, state);

1✔

4291

1✔

4292

1✔

4293

                        // code as improper list

327✔

4294

                        const last_pair = code.last_pair();

327✔

4295

                        log({ last_pair });

327✔

4296

                        if (!is_nil(last_pair.cdr)) {

328✔

4297

                            log('>> 7 (c)')

2✔

4298

                            if (is_nil(pattern.cdr.cdr)) {

2✔

4299

                                // case (a ...) for (a b . x)

1✔

4300

                                return false;

1✔

4301

                            } else {

1✔

4302

                                log('>> 7 (d)');

1✔

4303

                                // case (a ... . b) for (a b . x)

1✔

4304

                                const copy = code.clone();

1✔

4305

                                copy.last_pair().cdr = nil;

1✔

4306

                                bindings['...'].symbols[name] = copy;

1✔

4307

                                return traverse(pattern.cdr.cdr, last_pair.cdr, state);

1✔

4308

1✔

4309

2✔

4310

                        pattern_names.push(name);

325✔

4311

                        if (!bindings['...'].symbols[name]) {

328✔

4312

                            log('>> 7 (e)');

296✔

4313

                            bindings['...'].symbols[name] = new Pair(

296✔

4314

                                code,

296✔

4315

nil

296✔

4316

);

296✔

4317

                        } else {

328✔

4318

                            log('>> 7 (f)');

29✔

4319

                            const node = bindings['...'].symbols[name];

29✔

4320

                            bindings['...'].symbols[name] = node.append(

29✔

4321

                                new Pair(

29✔

4322

                                    code,

29✔

4323

nil

29✔

4324

29✔

4325

);

29✔

4326

29✔

4327

                        log({ IIIIII: bindings['...'].symbols[name] });

325✔

4328

                    } else if (pattern.car instanceof LSymbol &&

412✔

4329

                               is_pair(pattern.cdr) &&

84✔

4330

                               LSymbol.is(pattern.cdr.car, ellipsis_symbol)) {

84✔

4331

                        // empty ellipsis with rest  (a b ... . d) #290

84✔

4332

                        log('>> 8');

84✔

4333

                        bindings['...'].symbols[name] = null;

84✔

4334

                        return traverse(pattern.cdr.cdr, code, state);

84✔

4340

412✔

4341

                return true;

686✔

4342

            } else if (is_pair(pattern.car)) {

918✔

4343

                var names = [...pattern_names];

135✔

4344

                if (is_nil(code)) {

135✔

4345

                    log('>> 10');

26✔

4346

                    bindings['...'].lists.push(nil);

26✔

4347

                    return true;

26✔

4348

26✔

4349

                log('>> 11');

109✔

4350

                let node = code;

109✔

4351

                const new_state = { ...state, pattern_names: names, ellipsis: true };

109✔

4352

                while (is_pair(node)) {

135✔

4353

                    if (!traverse(pattern.car, node.car, new_state)) {

150✔

4354

                        return false;

15✔

4355

15✔

4356

                    node = node.cdr;

135✔

4357

135✔

4358

                return true;

94✔

4359

            } if (Array.isArray(pattern.car) ) {

918✔

4360

                var names = [...pattern_names];

7✔

4361

                let node = code;

7✔

4362

                const new_state = { ...state, pattern_names: names, ellipsis: true };

7✔

4363

                while (is_pair(node)) {

7✔

4367

                    node = node.cdr;

18✔

4368

18✔

4369

                return true;

7✔

4370

7✔

4373

        if (pattern instanceof LSymbol) {

8,712✔

4377

            log('>> 12');

2,474✔

4378

            const name = pattern.__name__;

2,474✔

4382

            if (ellipsis) {

2,474✔

4383

                log(bindings['...'].symbols[name]);

257✔

4384

                bindings['...'].symbols[name] ??= [];

257✔

4385

                bindings['...'].symbols[name].push(code);

257✔

4386

            } else {

2,474✔

4387

                bindings.symbols[name] = code;

2,217✔

4388

2,217✔

4389

            return true;

2,474✔

4390

2,474✔

4391

        if (is_pair(pattern) && is_pair(code)) {

8,712✔

4392

            log('>> 13');

3,678✔

4393

            log({

3,678✔

4394

                a: 13,

3,678✔

4395

                code,

3,678✔

4396

                pattern

3,678✔

4397

});

3,678✔

4398

            const rest_pattern = pattern.car instanceof LSymbol &&

3,678✔

4399

                pattern.cdr instanceof LSymbol;

3,678✔

4400

            if (trailing && rest_pattern) {

3,678✔

4401

                log('>> 13 (a)');

2✔

4402

                // handle (x ... y . z)

2✔

4403

                if (!is_nil(code.cdr)) {

2✔

4404

                    return false;

1✔

4405

1✔

4406

                const car = pattern.car.valueOf();

1✔

4407

                const cdr = pattern.cdr.valueOf();

1✔

4408

                bindings.symbols[car] = code.car;

1✔

4409

                bindings.symbols[cdr] = nil;

1✔

4410

                return true;

1✔

4411

                //return is_pair(code.cdr) && code.cdr.length() > 1;

1✔

4412

1✔

4413

            if (is_nil(code.cdr)) {

3,678✔

4414

                log('>> 13 (b)');

796✔

4415

                // last item in in call using in recursive calls on

796✔

4416

                // last element of the list

796✔

4417

                // case of pattern (p . rest) and code (0)

796✔

4418

                if (rest_pattern) {

796✔

4419

                    // fix for SRFI-26 in recursive call of (b) ==> (<> . x)

13✔

4420

                    // where <> is symbol

13✔

4421

                    if (!traverse(pattern.car, code.car, state)) {

13✔

4422

                        return false;

1✔

4423

1✔

4424

                    log('>> 14');

12✔

4425

                    let name = pattern.cdr.valueOf();

12✔

4426

                    if (!(name in bindings.symbols)) {

13✔

4427

                        bindings.symbols[name] = nil;

11✔

4428

11✔

4429

                    name = pattern.car.valueOf();

12✔

4433

                    return true;

12✔

4434

12✔

4435

796✔

4436

            log({

3,663✔

4437

                pattern,

3,663✔

4438

                code

3,663✔

4439

});

3,663✔

4440

            // case (x y) ===> (var0 var1 ... warn) where var1 match nil

3,663✔

4441

            // trailing: true start processing of (var ... x . y)

3,663✔

4442

            if (is_pair(pattern.cdr) &&

3,678✔

4443

                is_pair(pattern.cdr.cdr) &&

3,678✔

4444

                pattern.cdr.car instanceof LSymbol &&

3,678✔

4445

                LSymbol.is(pattern.cdr.cdr.car, ellipsis_symbol) &&

3,678✔

4446

                is_pair(pattern.cdr.cdr.cdr) &&

3,678✔

4447

                !LSymbol.is(pattern.cdr.cdr.cdr.car, ellipsis_symbol) &&

3,678✔

4448

                traverse(pattern.car, code.car, state) &&

3,678✔

4449

                traverse(pattern.cdr.cdr.cdr, code.cdr, {...state, trailing: true })) {

3,678✔

4450

                const name = pattern.cdr.car.__name__;

4✔

4451

                log({

4✔

4452

                    pattern,

4✔

4453

                    code,

4✔

4454

                    name

4✔

4455

});

4✔

4459

                bindings['...'].symbols[name] = null;

4✔

4460

                return true;

4✔

4461

4✔

4462

            log('recur');

3,659✔

4463

            log({

3,659✔

4464

                pattern,

3,659✔

4465

                code

3,659✔

4466

});

3,659✔

4467

            const car = traverse(pattern.car, code.car, state);

3,659✔

4468

            const cdr = traverse(pattern.cdr, code.cdr, state);

3,659✔

4469

            log({

3,659✔

4470

                $car_code: code.car,

3,659✔

4471

                $car_pattern: pattern.car,

3,659✔

4472

                car,

3,659✔

4473

                $cdr_code: code.cdr,

3,659✔

4474

                $cdr_pattern: pattern.cdr,

3,659✔

4475

cdr

3,659✔

4476

});

3,659✔

4477

            if (car && cdr) {

3,678✔

4478

                return true;

2,228✔

4479

2,228✔

4484

        } else if (is_pair(pattern.car) &&

95✔

4488

        } else {

95✔

4489

            return false;

95✔

4490

95✔

4491

8,712✔

4492

    /* eslint-enable complexity */

1,011✔

4493

    if (traverse(pattern, code)) {

1,011✔

4494

        return bindings;

487✔

4495

487✔

4496

1,011✔

4497

// ----------------------------------------------------------------------

1✔

4498

// :: This function is called after syntax-rules macro is evaluated

1✔

4499

// :: and if there are any gensyms added by macro they need to restored

1✔

4500

// :: to original symbols

1✔

4501

// ----------------------------------------------------------------------

1✔

4502

function clear_gensyms(node, gensyms) {

477✔

4503

    function traverse(node) {

477✔

4504

        if (is_pair(node)) {

4,541✔

4505

            if (!gensyms.length) {

2,046✔

4506

                return node;

14✔

4507

14✔

4508

            const car = traverse(node.car);

2,032✔

4509

            const cdr = traverse(node.cdr);

2,032✔

4510

            // TODO: check if it's safe to modify the list

2,032✔

4511

            //       some funky modify of code can happen in macro

2,032✔

4512

            return new Pair(car, cdr);

2,032✔

4513

        } else if (node instanceof LSymbol) {

4,541✔

4514

            var replacement = gensyms.find((gensym) => {

849✔

4515

                return gensym.gensym === node;

1,386✔

4516

});

849✔

4517

            if (replacement) {

849✔

4518

                return LSymbol(replacement.name);

34✔

4519

34✔

4520

            return node;

815✔

4521

        } else {

2,495✔

4522

            return node;

1,646✔

4523

1,646✔

4524

4,541✔

4525

    return traverse(node);

477✔

4526

477✔

4527

// ----------------------------------------------------------------------

1✔

4528

function transform_syntax(options = {}) {

487✔

4529

    const {

487✔

4530

        bindings,

487✔

4531

        expr,

487✔

4532

        scope,

487✔

4533

        symbols,

487✔

4534

        names,

487✔

4535

        ellipsis: ellipsis_symbol } = options;

487✔

4536

    const gensyms = {};

487✔

4537

    function valid_symbol(symbol) {

487✔

4538

        if (symbol instanceof LSymbol) {

2,282✔

4539

            return true;

2,282✔

4540

2,282✔

4542

2,282✔

4543

    function transform(symbol) {

487✔

4548

        const name = symbol.valueOf();

2,282✔

4549

        if (name === ellipsis_symbol) {

2,282✔

4550

            throw new Error('syntax: internal error, ellipis not transformed');

2✔

4551

2✔

4552

        // symbols are gensyms from nested syntax-rules

2,280✔

4553

        var n_type = typeof name;

2,280✔

4554

        if (['string', 'symbol'].includes(n_type)) {

2,280✔

4555

            if (name in bindings.symbols) {

2,280✔

4556

                return bindings.symbols[name];

834✔

4557

            } else if (n_type === 'string' && name.match(/\./)) {

2,280✔

4558

                // calling method on pattern symbol #83

23✔

4559

                const parts = name.split('.');

23✔

4560

                const first = parts[0];

23✔

4561

                if (first in bindings.symbols) {

23✔

4562

                    return Pair.fromArray([

8✔

4563

                        LSymbol('.'),

8✔

4564

                        bindings.symbols[first]

8✔

4565

                    ].concat(parts.slice(1).map(x => LString(x))));

8✔

4566

8✔

4567

23✔

4568

2,280✔

4569

        if (symbols.includes(name)) {

2,282✔

4570

            return symbol;

96✔

4571

96✔

4572

        return rename(name, symbol);

1,342✔

4573

2,282✔

4574

    function rename(name, symbol) {

487✔

4575

        if (!gensyms[name]) {

1,342✔

4576

            const ref = scope.ref(name);

1,049✔

4577

            // nested syntax-rules needs original symbol to get renamed again

1,049✔

4578

            if (typeof name === 'symbol' && !ref) {

1,049✔

4579

                name = symbol.literal();

8✔

4580

8✔

4581

            if (gensyms[name]) {

1,049✔

4582

                return gensyms[name];

2✔

4583

2✔

4584

            const gensym_name = gensym(name);

1,047✔

4585

            if (ref) {

1,049✔

4586

                const value = scope.get(name);

900✔

4587

                scope.set(gensym_name, value);

900✔

4588

            } else {

1,049✔

4589

                const value = scope.get(name, { throwError: false });

147✔

4590

                // value is not in scope, but it's JavaScript object

147✔

4591

                if (typeof value !== 'undefined') {

147✔

4592

                    scope.set(gensym_name, value);

7✔

4593

7✔

4594

147✔

4595

            // keep names so they can be restored after evaluation

1,047✔

4596

            // if there are free symbols as output

1,047✔

4597

            // kind of hack

1,047✔

4598

            names.push({

1,047✔

4599

                name, gensym: gensym_name

1,047✔

4600

});

1,047✔

4601

            gensyms[name] = gensym_name;

1,047✔

4602

            // we need to check if name is a string, because it can be

1,047✔

4603

            // gensym from nested syntax-rules

1,047✔

4604

            if (typeof name === 'string' && name.match(/\./)) {

1,049✔

4605

                const [first, ...rest] = name.split('.').filter(Boolean);

12✔

4606

                // save JavaScript dot notation for Env::get

12✔

4607

                if (gensyms[first]) {

12✔

4608

                    hidden_prop(gensym_name, '__object__', [gensyms[first], ...rest]);

2✔

4609

2✔

4610

12✔

4611

1,049✔

4612

        return gensyms[name];

1,340✔

4613

1,342✔

4614

    function transform_ellipsis_expr(expr, bindings, state, next = () => {}) {

487✔

4615

        const { nested } = state;

1,438✔

4616

        log({ bindings, expr });

1,438✔

4620

        if (expr instanceof LSymbol) {

1,438✔

4621

            let name = expr.valueOf();

272✔

4625

            log('[t 1');

272✔

4626

            if (bindings[name]) {

272✔

4627

                if (is_pair(bindings[name])) {

187✔

4628

                    const { car, cdr } = bindings[name];

33✔

4629

                    if (nested) {

33✔

4630

                        const { car: caar, cdr: cadr } = car;

33✔

4631

                        if (!is_nil(cadr)) {

33✔

4632

                            next(name, new Pair(cadr, nil));

19✔

4633

19✔

4634

                        return caar;

33✔

4635

33✔

4640

                } else if (bindings[name] instanceof Array) {

187✔

4641

                    next(name, bindings[name].slice(1));

154✔

4642

                    return bindings[name][0];

154✔

4643

154✔

4644

187✔

4645

            return transform(expr);

85✔

4646

85✔

4647

        const is_array = Array.isArray(expr);

1,166✔

4648

        if (is_pair(expr) || is_array) {

1,438✔

4649

            const first = is_array ? expr[0] : expr.car;

1,038✔

4650

            const second = is_array ? expr[1] : is_pair(expr.cdr) && expr.cdr.car;

1,038✔

4651

            if (first instanceof LSymbol &&

1,038✔

4652

                LSymbol.is(second, ellipsis_symbol)) {

1,038✔

4653

                let rest = is_array ? expr.slice(2) : expr.cdr.cdr;

733✔

4654

                log('[t 2');

733✔

4655

                const name = first.valueOf();

733✔

4656

                const item = bindings[name];

733✔

4659

                } else if (name in bindings) {

733✔

4660

                    log({ name, binding: bindings[name] });

733✔

4661

                    if (is_pair(item)) {

733✔

4662

                        log('[t 2 Pair ' + nested);

683✔

4663

                        const { car, cdr } = item;

683✔

4665

                        if (nested) {

683✔

4666

                            if (!is_nil(cdr)) {

59✔

4667

                                log('|| next 1');

34✔

4668

                                next(name, cdr);

34✔

4669

34✔

4671

                                const rest = transform_ellipsis_expr(rest_expr, bindings, state, next);

5✔

4674

                                } else if (is_pair(car)) {

5✔

4675

                                    return car.append(rest);

5✔

4679

5✔

4680

                            return car;

54✔

4681

                        } else if (is_pair(car)) {

683✔

4682

                            if (!is_nil(car.cdr)) {

621✔

4683

                                log('|| next 2');

392✔

4684

                                next(name, new Pair(car.cdr, cdr));

392✔

4685

392✔

4686

                            // wrap with Value to handle undefined

621✔

4687

                            return new Value(car.car);

621✔

4688

                        } else if (is_nil(cdr)) {

624✔

4689

                            return car;

2✔

4690

                        } else {

3✔

4691

                            const last_pair = expr.last_pair();

1✔

4692

                            if (last_pair.cdr instanceof LSymbol) {

1✔

4693

                                log('|| next 3');

1✔

4694

                                next(name, item.last_pair());

1✔

4695

                                return car;

1✔

4696

1✔

4697

1✔

4698

                    } else if (item instanceof Array) {

733✔

4699

                        log('[t 2 Array ' + nested);

47✔

4703

                        } else {

47✔

4704

                            const rest = item.slice(1);

47✔

4705

                            if (rest.length) {

47✔

4706

                                next(name, rest);

23✔

4707

23✔

4708

                            return item[0];

47✔

4709

47✔

4710

                    } else {

50✔

4711

                        return item;

3✔

4712

3✔

4713

733✔

4714

733✔

4715

            log('[t 3 recur ', expr);

305✔

4717

            const head = transform_ellipsis_expr(first, bindings, state, next);

1,038✔

4718

            const rest = transform_ellipsis_expr(rest_expr, bindings, state, next);

1,038✔

4719

            log( { head, rest });

1,038✔

4723

            return new Pair(

303✔

4724

                head,

303✔

4725

                rest

303✔

4726

);

303✔

4727

303✔

4728

        return expr;

128✔

4729

1,438✔

4730

    function have_binding(binding, skip_nulls) {

487✔

4731

        const values = Object.values(binding);

1,215✔

4732

        const symbols = Object.getOwnPropertySymbols(binding);

1,215✔

4733

        if (symbols.length) {

1,215✔

4734

            values.push(...symbols.map(x => binding[x]));

52✔

4735

52✔

4736

        return values.length && values.every(x => {

1,215✔

4737

            if (x === null) {

1,078✔

4738

                return !skip_nulls;

80✔

4739

80✔

4740

            return is_pair(x) || is_nil(x) || (Array.isArray(x) && x.length);

1,078✔

4741

});

1,215✔

4742

1,215✔

4743

    function get_names(object) {

487✔

4744

        return Object.keys(object).concat(Object.getOwnPropertySymbols(object));

406✔

4745

406✔

4746

    /* eslint-disable complexity */

487✔

4747

    function traverse(expr, { disabled } = {}) {

487✔

4748

        log('traverse>> ', expr);

7,383✔

4749

        const is_array = Array.isArray(expr);

7,383✔

4753

        if (is_pair(expr) || is_array) {

7,383✔

4754

            log('>> 0');

3,842✔

4755

            const first = is_array ? expr[0] : expr.car;

3,842✔

4756

            let second, rest_second;

3,842✔

4757

            if (is_array) {

3,842✔

4758

                second = expr[1];

1✔

4759

                rest_second = expr.slice(2);

1✔

4760

            } else if (is_pair(expr.cdr)) {

3,842✔

4761

                second = expr.cdr.car;

2,651✔

4762

                rest_second = expr.cdr.cdr;

2,651✔

4763

2,651✔

4764

            log({ first, second, rest_second });

3,842✔

4765

            // escape ellispsis from R7RS e.g. (... ...)

3,842✔

4766

            if (!disabled && is_pair(first) &&

3,842✔

4767

                LSymbol.is(first.car, ellipsis_symbol)) {

3,842✔

4768

                return new Pair(

6✔

4769

                    first.cdr.car,

6✔

4770

                    traverse(expr.cdr)

6✔

4771

);

6✔

4772

6✔

4773

            if (second && LSymbol.is(second, ellipsis_symbol) && !disabled) {

3,842✔

4774

                log('>> 1');

460✔

4775

                const symbols = bindings['...'].symbols;

460✔

4776

                // skip expand list of pattern was (x y ... z)

460✔

4777

                // and code was (x z) so y == null

460✔

4778

                const values = Object.values(symbols);

460✔

4779

                if (values.length && values.every(x => x === null)) {

460✔

4780

                    log('>>> 1 (a)');

54✔

4781

                    return traverse(rest_second, { disabled });

54✔

4782

54✔

4783

                var keys = get_names(symbols);

406✔

4784

                // case of list as first argument ((x . y) ...) or (x ... ...)

406✔

4785

                // we need to recursively process the list

406✔

4786

                // if we have pattern (_ (x y z ...) ...) and code (foo (1 2) (1 2))

406✔

4787

                // x an y will be arrays of [1 1] and [2 2] and z will be array

406✔

4788

                // of rest, x will also have it's own mapping to 1 and y to 2

406✔

4789

                // in case of usage outside of ellipsis list e.g.: (x y)

406✔

4790

                var is_spread = first instanceof LSymbol &&

460✔

4791

                    LSymbol.is(rest_second.car, ellipsis_symbol);

460✔

4792

                if (is_pair(first) || is_spread) {

460✔

4793

                    log('>>> 1 (b)');

89✔

4794

                    // lists is free ellipsis on pairs ((???) ...)

89✔

4795

                    // TODO: will this work in every case? Do we need to handle

89✔

4796

                    // nesting here?

89✔

4797

                    if (is_nil(bindings['...'].lists[0])) {

89✔

4798

                        if (!is_spread) {

14✔

4799

                            return traverse(rest_second, { disabled });

14✔

4800

14✔

4804

                    var new_expr = first;

75✔

4805

                    if (is_spread) {

89✔

4806

                        log('>>> 1 (c)'); // TODO: array

6✔

4807

                        new_expr = new Pair(

6✔

4808

                            first,

6✔

4809

                            new Pair(

6✔

4810

                                second,

6✔

4811

nil

6✔

4812

6✔

4813

);

6✔

4814

6✔

4815

                    log('>> 2');

75✔

4816

                    let result;

75✔

4817

                    if (keys.length) {

75✔

4818

                        log('>> 2 (a)');

75✔

4819

                        let bind = { ...symbols };

75✔

4821

                        while (true) {

75✔

4822

                            log({ bind });

227✔

4823

                            if (!have_binding(bind)) {

227✔

4824

                                break;

74✔

4825

74✔

4826

                            const new_bind = {};

153✔

4827

                            const next = (key, value) => {

153✔

4828

                                // ellipsis decide if what should be the next value

207✔

4829

                                // there are two cases ((a . b) ...) and (a ...)

207✔

4830

                                new_bind[key] = value;

207✔

4831

};

153✔

4832

                            const car = transform_ellipsis_expr(

153✔

4833

                                new_expr,

153✔

4834

                                bind,

153✔

4835

                                { nested: true },

153✔

4836

                                next

153✔

4837

);

153✔

4838

                            // undefined can be null caused by null binding

153✔

4839

                            // on empty ellipsis

153✔

4840

                            if (car !== undefined) {

227✔

4844

                                if (is_spread) {

152✔

4851

                                    } else {

18✔

4852

                                        if (is_nil(result)) {

18✔

4853

                                            result = car;

6✔

4854

                                        } else {

18✔

4855

                                            result = result.append(car);

12✔

4856

12✔

4857

18✔

4860

                                } else {

134✔

4861

                                    result = new Pair(

134✔

4862

                                        car,

134✔

4863

                                        result

134✔

4864

);

134✔

4865

134✔

4866

152✔

4867

                            bind = new_bind;

152✔

4868

152✔

4869

                        if (!is_nil(result) && !is_spread && !is_array) {

75✔

4870

                            result = result.reverse();

68✔

4871

68✔

4872

                        // case of (list) ... (rest code)

74✔

4881

                        if (!is_nil(expr.cdr.cdr) &&

75✔

4882

                            !LSymbol.is(expr.cdr.cdr.car, ellipsis_symbol)) {

75✔

4883

                            const rest = traverse(expr.cdr.cdr, { disabled });

2✔

4884

                            return result.append(rest);

2✔

4885

2✔

4886

                        return result;

72✔

4903

                } else if (first instanceof LSymbol) {

460✔

4904

                    log('>> 4');

317✔

4908

                    } else {

317✔

4909

                        log('>> 4 (b)');

317✔

4910

317✔

4911

                    // case: (x ...)

317✔

4912

                    let name = first.__name__;

317✔

4913

                    let bind = { [name]: symbols[name] };

317✔

4914

                    log({bind});

317✔

4915

                    const is_null = symbols[name] === null;

317✔

4916

                    let result = is_array ? [] : nil;

317✔

4917

                    while (true) {

317✔

4918

                        if (!have_binding(bind, true)) {

988✔

4919

                            log({ bind });

317✔

4920

                            break;

317✔

4921

317✔

4922

                        const new_bind = {};

671✔

4923

                        const next = (key, value) => {

671✔

4924

                            new_bind[key] = value;

416✔

4925

};

671✔

4926

                        let value = transform_ellipsis_expr(

671✔

4927

                            expr,

671✔

4928

                            bind,

671✔

4929

                            { nested: false },

671✔

4930

                            next

671✔

4931

);

671✔

4932

                        log({ value });

671✔

4933

                        if (typeof value !== 'undefined') {

671✔

4934

                            if (value instanceof Value) {

671✔

4935

                                value = value.valueOf();

621✔

4936

621✔

4937

                            if (is_array) {

671✔

4938

                                result.push(value);

3✔

4939

                            } else {

671✔

4940

                                result = new Pair(

668✔

4941

                                    value,

668✔

4942

                                    result

668✔

4943

);

668✔

4944

668✔

4945

671✔

4946

                        bind = new_bind;

671✔

4947

671✔

4948

                    if (!is_nil(result) && !is_array) {

317✔

4949

                        result = result.reverse();

254✔

4950

254✔

4951

                    // case if (x ... y ...) second spread is not processed

317✔

4952

                    // and (??? . x) last symbol

317✔

4953

                    // by ellipsis transformation

317✔

4954

                    if (is_pair(expr.cdr)) {

317✔

4955

                        if (is_pair(expr.cdr.cdr) ||

316✔

4956

                            expr.cdr.cdr instanceof LSymbol) {

316✔

4957

                            const node = traverse(expr.cdr.cdr, { disabled });

67✔

4958

                            log({node});

67✔

4959

                            if (is_null) {

67✔

4960

                                return node;

12✔

4961

12✔

4962

                            if (is_nil(result)) {

67✔

4963

                                result = node;

3✔

4964

                            } else {

67✔

4965

                                result.append(node);

52✔

4966

52✔

4967

                            log({result, node});

55✔

4968

55✔

4969

316✔

4970

                    log('<<<< 2');

305✔

4971

                    log({ result });

305✔

4972

                    return result;

305✔

4973

305✔

4974

460✔

4975

            const head = traverse(first, { disabled });

3,376✔

4976

            let rest;

3,376✔

4977

            let is_syntax;

3,376✔

4978

            if ((first instanceof LSymbol)) {

3,842✔

4979

                const value = scope.get(first, { throwError: false });

2,078✔

4980

                is_syntax = value instanceof Macro &&

2,078✔

4981

                    value.__name__ === 'syntax-rules';

2,078✔

4982

2,078✔

4983

            if (is_syntax) {

3,842✔

4984

                if (expr.cdr.car instanceof LSymbol) {

31✔

4985

                    rest = new Pair(

9✔

4986

                        traverse(expr.cdr.car, { disabled }),

9✔

4987

                        new Pair(

9✔

4988

                            expr.cdr.cdr.car,

9✔

4989

                            traverse(expr.cdr.cdr.cdr, { disabled })

9✔

4990

9✔

4991

);

9✔

4992

                } else {

31✔

4993

                    rest = new Pair(

22✔

4994

                        expr.cdr.car,

22✔

4995

                        traverse(expr.cdr.cdr, { disabled })

22✔

4996

);

22✔

4997

22✔

4998

                log('REST >>>> ', rest);

30✔

4999

            } else {

3,842✔

5000

                rest = traverse(expr.cdr, { disabled });

3,337✔

5001

3,337✔

5002

            log({

3,363✔

5003

                a: true,

3,363✔

5004

                car: toString(expr.car),

3,363✔

5005

                cdr: toString(expr.cdr),

3,363✔

5006

                head: toString(head),

3,363✔

5007

                rest: toString(rest)

3,363✔

5008

});

3,363✔

5009

            return new Pair(

3,363✔

5010

                head,

3,363✔

5011

                rest

3,363✔

5012

);

3,363✔

5013

3,363✔

5014

        if (expr instanceof LSymbol) {

7,383✔

5018

            const symbols = Object.keys(bindings['...'].symbols);

2,198✔

5019

            const name = expr.literal(); // TODO: slow

2,198✔

5020

            if (symbols.includes(name)) {

2,198✔

5021

                const msg = `missing ellipsis symbol next to name \`${name}'`;

1✔

5022

                throw new Error(`syntax-rules: ${msg}`);

1✔

5023

1✔

5024

            const value = transform(expr);

2,197✔

5025

            if (typeof value !== 'undefined') {

2,198✔

5026

                return value;

2,196✔

5027

2,196✔

5028

2,198✔

5029

        return expr;

1,343✔

5030

7,383✔

5031

    return traverse(expr, {});

487✔

5032

487✔

5033

// ----------------------------------------------------------------------

1✔

5034

// :: Check for nullish values

1✔

5035

// ----------------------------------------------------------------------

1✔

5036

function is_null(value) {

11,513,418✔

5037

    return is_undef(value) || is_nil(value) || value === null;

11,513,418✔

5038

11,513,418✔

5039

// ----------------------------------------------------------------------

1✔

5040

function is_nil(value) {

24,698,073✔

5041

    return value === nil;

24,698,073✔

5042

24,698,073✔

5043

// ----------------------------------------------------------------------

1✔

5044

function is_function(o) {

329,408,378✔

5045

    return typeof o === 'function' && typeof o.bind === 'function';

329,408,378✔

5046

329,408,378✔

5047

// ----------------------------------------------------------------------------

1✔

5048

function is_directive(token) {

85,367✔

5049

    return directives.includes(token);

85,367✔

5050

85,367✔

5051

// ----------------------------------------------------------------------------

1✔

5052

function is_false(o) {

1,353,940✔

5053

    return o === false || o === null;

1,353,940✔

5054

1,353,940✔

5055

// ----------------------------------------------------------------------------

1✔

5056

function is_string(o) {

14,400,984✔

5057

    return typeof o === 'string';

14,400,984✔

5058

14,400,984✔

5059

// ----------------------------------------------------------------------------

1✔

5060

function is_prototype(obj) {

636,422✔

5061

    return obj &&

636,422✔

5062

        typeof obj === 'object' &&

636,422✔

5063

        obj.hasOwnProperty &&

636,422✔

5064

        obj.hasOwnProperty("constructor") &&

636,422✔

5065

        typeof obj.constructor === "function" &&

636,422✔

5066

        obj.constructor.prototype === obj;

636,422✔

5067

636,422✔

5068

// ----------------------------------------------------------------------

1✔

5069

function is_continuation(o) {

26✔

5070

    return o instanceof Continuation;

26✔

5071

26✔

5072

// ----------------------------------------------------------------------

1✔

5073

function is_context(o) {

1,367,680✔

5074

    return o instanceof LambdaContext;

1,367,680✔

5075

1,367,680✔

5076

// ----------------------------------------------------------------------

1✔

5077

function is_parameter(o) {

150✔

5078

    return o instanceof Parameter;

150✔

5079

150✔

5080

// ----------------------------------------------------------------------

1✔

5081

function is_pair(o) {

576,830,068✔

5082

    return o instanceof Pair;

576,830,068✔

5083

576,830,068✔

5084

// ----------------------------------------------------------------------

1✔

5085

function is_env(o) {

11,437,044✔

5086

    return o instanceof Environment;

11,437,044✔

5087

11,437,044✔

5088

// ----------------------------------------------------------------------

1✔

5089

function is_callable(o) {

1,012✔

5091

1,012✔

5092

// ----------------------------------------------------------------------

1✔

5093

function is_macro(o) {

2✔

5094

    return o instanceof Macro || o instanceof SyntaxParameter;

2✔

5095

2✔

5096

// ----------------------------------------------------------------------

1✔

5097

function is_promise(o) {

269,676,435✔

5098

    if (o instanceof QuotedPromise) {

269,676,435✔

5099

        return false;

316✔

5100

316✔

5101

    if (o instanceof Promise) {

269,676,435✔

5102

        return true;

24,744✔

5103

24,744✔

5104

    return !!o && is_function(o.then);

269,676,435✔

5105

269,676,435✔

5106

// ----------------------------------------------------------------------

1✔

5107

function is_undef(value) {

11,513,496✔

5108

    return typeof value === 'undefined';

11,513,496✔

5109

11,513,496✔

5110

// -------------------------------------------------------------------------

1✔

5111

function get_proto(obj) {

40✔

5112

    return Object.getPrototypeOf(obj);

40✔

5113

40✔

5114

// -------------------------------------------------------------------------

1✔

5115

function is_iterator(obj, symbol) {

80✔

5116

    if (has_own_symbol(obj, symbol) || has_own_symbol(get_proto(obj), symbol)) {

80✔

5117

        return is_function(obj[symbol]);

40✔

5118

40✔

5119

80✔

5120

// -------------------------------------------------------------------------

1✔

5121

function is_instance(obj) {

2,806✔

5122

    if (!obj) {

2,806✔

5123

        return false;

99✔

5124

99✔

5125

    if (typeof obj !== 'object') {

2,806✔

5126

        return false;

345✔

5127

345✔

5128

    // __instance__ is read only for instances

2,362✔

5129

    if (obj.__instance__) {

2,806✔

5130

        obj.__instance__ = false;

9✔

5131

        return obj.__instance__;

9✔

5132

9✔

5133

    return false;

2,353✔

5134

2,806✔

5135

// -------------------------------------------------------------------------

1✔

5136

function self_evaluated(obj) {

1,643,498✔

5137

    var type = typeof obj;

1,643,498✔

5138

    return ['string', 'function'].includes(type) ||

1,643,498✔

5139

        typeof obj === 'symbol' ||

1,643,498✔

5140

        obj instanceof QuotedPromise ||

1,643,498✔

5141

        obj instanceof LSymbol ||

1,643,498✔

5142

        obj instanceof LNumber ||

1,643,498✔

5143

        obj instanceof LString ||

1,643,498✔

5144

        obj instanceof RegExp;

1,643,498✔

5145

1,643,498✔

5146

// -------------------------------------------------------------------------

1✔

5147

function is_native(obj) {

352✔

5148

    return obj instanceof LNumber ||

352✔

5149

        obj instanceof LString ||

352✔

5150

        obj instanceof LCharacter;

352✔

5151

352✔

5152

// -------------------------------------------------------------------------

1✔

5153

function has_own_symbol(obj, symbol) {

120✔

5157

    return typeof obj === 'object' &&

120✔

5158

        symbol in Object.getOwnPropertySymbols(obj);

120✔

5159

120✔

5160

// ----------------------------------------------------------------------

1✔

5161

// :: Function utilities

1✔

5162

// ----------------------------------------------------------------------

1✔

5163

function box(object) {

15,705,780✔

5164

    // We only need to box lips data and arrays. Object don't need

15,705,780✔

5165

    // to be boxed, but values from objects will be boxed when accessed.

15,705,780✔

5166

    switch (typeof object) {

15,705,780✔

5167

        case 'string':

15,705,780✔

5168

            return LString(object);

157,648✔

5171

        case 'number':

15,705,780✔

5174

            } else {

86,240✔

5175

                return LNumber(object);

86,240✔

5176

86,240✔

5177

15,705,780✔

5178

    return object;

15,461,892✔

5179

15,705,780✔

5180

// ----------------------------------------------------------------------

1✔

5181

function map_object(object, fn) {

106✔

5182

    const props = Object.getOwnPropertyNames(object);

106✔

5183

    const symbols = Object.getOwnPropertySymbols(object);

106✔

5184

    const result = {};

106✔

5185

    props.concat(symbols).forEach(key => {

106✔

5186

        const value = fn(object[key]);

411✔

5187

        result[key] = value;

411✔

5188

});

106✔

5189

    return result;

106✔

5190

106✔

5191

// ----------------------------------------------------------------------

1✔

5192

function unbox(object) {

378,639✔

5193

    var lips_type = [LString, LNumber, LCharacter].some(x => object instanceof x);

378,639✔

5194

    if (lips_type) {

378,639✔

5195

        return object.valueOf();

107,019✔

5196

107,019✔

5197

    if (object instanceof Array) {

378,639✔

5198

        return object.map(unbox);

108✔

5199

108✔

5200

    if (object instanceof QuotedPromise) {

378,639✔

5201

        delete object.then;

4✔

5202

4✔

5203

    if (is_plain_object(object)) {

378,639✔

5204

        return map_object(object, unbox);

106✔

5205

106✔

5206

    return object;

271,406✔

5207

378,639✔

5208

// ----------------------------------------------------------------------

1✔

5209

function patch_value(value, context) {

14,626,362✔

5210

    if (is_pair(value)) {

14,626,362✔

5211

        value.mark_cycles();

1,183,409✔

5212

        return quote(value);

1,183,409✔

5213

1,183,409✔

5214

    if (is_function(value)) {

14,626,362✔

5215

        // original function can be restored using unbind function

5,541,145✔

5216

        // only real JS function require to be bound

5,541,145✔

5217

        if (context) {

5,541,145✔

5218

            return bind(value, context);

124,587✔

5219

124,587✔

5220

5,541,145✔

5221

    return box(value);

13,318,366✔

5222

14,626,362✔

5223

// ----------------------------------------------------------------------

1✔

5224

// :: Function gets original function that was binded with props

1✔

5225

// ----------------------------------------------------------------------

1✔

5226

function unbind(obj) {

652,850✔

5227

    if (is_bound(obj)) {

652,850✔

5228

        return obj[__fn__];

22,919✔

5229

22,919✔

5230

    return obj;

629,931✔

5231

652,850✔

5232

// ----------------------------------------------------------------------

1✔

5233

// :: Function binds with context that can be optionally unbind

1✔

5234

// :: get original function with unbind

1✔

5235

// ----------------------------------------------------------------------

1✔

5236

function bind(fn, context) {

124,587✔

5240

    const bound = fn.bind(context);

124,587✔

5241

    const props = Object.getOwnPropertyNames(fn);

124,587✔

5242

    for (var prop of props) {

124,587✔

5243

        if (filter_fn_names(prop)) {

365,313✔

5244

            try {

40,245✔

5245

                bound[prop] = fn[prop];

40,245✔

5249

40,245✔

5250

365,313✔

5251

    hidden_prop(bound, '__fn__', fn);

124,587✔

5252

    hidden_prop(bound, '__context__', context);

124,587✔

5253

    hidden_prop(bound, '__bound__', true);

124,587✔

5254

    if (is_native_function(fn)) {

124,587✔

5255

        hidden_prop(bound, '__native__', true);

46,532✔

5256

46,532✔

5257

    if (is_plain_object(context) && is_lambda(fn)) {

124,587✔

5258

        hidden_prop(bound, '__method__', true);

17✔

5259

17✔

5260

    bound.valueOf = function() {

124,587✔

5262

};

124,587✔

5263

    return bound;

124,587✔

5264

124,587✔

5265

// ----------------------------------------------------------------------

1✔

5266

// Function used to check if function should not get unboxed arguments,

1✔

5267

// so you can call Object.getPrototypeOf for lips data types

1✔

5268

// this is case, see dir function and #73

1✔

5269

// ----------------------------------------------------------------------

1✔

5270

function is_object_bound(obj) {

121,943✔

5271

    return is_bound(obj) && obj[Symbol.for('__context__')] === Object;

121,943✔

5272

121,943✔

5273

// ----------------------------------------------------------------------

1✔

5274

function is_bound(obj) {

3,516,277✔

5275

    return !!(is_function(obj) && obj[__fn__]);

3,516,277✔

5276

3,516,277✔

5277

// ----------------------------------------------------------------------

1✔

5278

function lips_context(obj) {

121,663✔

5279

    if (is_function(obj)) {

121,663✔

5280

        var context = obj[__context__];

121,663✔

5281

        if (context && (context === lips ||

121,663✔

5282

                        (context.constructor &&

121,419✔

5283

                         context.constructor.__class__))) {

121,663✔

5284

            return true;

70,639✔

5285

70,639✔

5286

121,663✔

5287

    return false;

51,024✔

5288

121,663✔

5289

// ----------------------------------------------------------------------

1✔

5290

function is_port(obj) {

1,317,146✔

5291

    return obj instanceof InputPort || obj instanceof OutputPort;

1,317,146✔

5292

1,317,146✔

5293

// ----------------------------------------------------------------------

1✔

5294

function is_port_method(obj) {

1,317,146✔

5295

    if (is_function(obj)) {

1,317,146✔

5296

        if (is_port(obj[__context__])) {

1,317,146✔

5297

            return true;

50✔

5298

50✔

5299

1,317,146✔

5300

    return false;

1,317,096✔

5301

1,317,146✔

5302

// ----------------------------------------------------------------------

1✔

5303

// Hidden props

1✔

5304

// ----------------------------------------------------------------------

1✔

5305

const __context__ = Symbol.for('__context__');

1✔

5306

const __fn__ = Symbol.for('__fn__');

1✔

5307

const __data__ = Symbol.for('__data__');

1✔

5308

const __ref__ = Symbol.for('__ref__');

1✔

5309

const __cycles__ = Symbol.for('__cycles__');

1✔

5310

const __class__ = Symbol.for('__class__');

1✔

5311

const __method__ = Symbol.for('__method__');

1✔

5312

const __prototype__ = Symbol.for('__prototype__');

1✔

5313

const __lambda__ = Symbol.for('__lambda__');

1✔

5314

// ----------------------------------------------------------------------

1✔

5315

// :: Function bind fn with context but it also move all props

1✔

5316

// :: mostly used for Object function

1✔

5317

// ----------------------------------------------------------------------

1✔

5318

var exluded_names = ['name', 'length', 'caller', 'callee', 'arguments', 'prototype'];

1✔

5319

function filter_fn_names(name) {

365,313✔

5320

    return !exluded_names.includes(name);

365,313✔

5321

365,313✔

5322

// ----------------------------------------------------------------------

1✔

5323

function enumerable(object, name, value) {

685,744✔

5324

    Object.defineProperty(object, name, {

685,744✔

5325

        value,

685,744✔

5326

        enumerable: true

685,744✔

5327

});

685,744✔

5328

685,744✔

5329

// ----------------------------------------------------------------------

1✔

5330

function hidden_prop(obj, name, value) {

1,704,684✔

5331

    Object.defineProperty(obj, Symbol.for(name), {

1,704,684✔

5332

        get: () => value,

1,704,684✔

5333

        set: () => {},

1,704,684✔

5334

        configurable: false,

1,704,684✔

5335

        enumerable: false

1,704,684✔

5336

});

1,704,684✔

5337

1,704,684✔

5338

// ----------------------------------------------------------------------

1✔

5339

function set_fn_length(fn, length) {

71,499✔

5340

    try {

71,499✔

5341

        Object.defineProperty(fn, 'length', {

71,499✔

5342

            get: function() {

71,499✔

5343

                return length;

15✔

5344

15✔

5345

});

71,499✔

5346

        return fn;

71,499✔

5356

71,499✔

5357

// ----------------------------------------------------------------------

1✔

5358

function is_lambda(obj) {

5,754,839✔

5359

    return obj && obj[__lambda__];

5,754,839✔

5360

5,754,839✔

5361

// ----------------------------------------------------------------------

1✔

5362

function is_method(obj) {

1,246,507✔

5363

    return obj && obj[__method__];

1,246,507✔

5364

1,246,507✔

5365

// ----------------------------------------------------------------------

1✔

5366

function is_raw_lambda(fn) {

5,478,924✔

5367

    return is_lambda(fn) && !fn[__prototype__] &&

5,478,924✔

5368

        !is_method(fn) && !is_port_method(fn);

5,478,924✔

5369

5,478,924✔

5370

// ----------------------------------------------------------------------

1✔

5371

function is_native_function(fn) {

363,144✔

5372

    var native = Symbol.for('__native__');

363,144✔

5373

    return is_function(fn) &&

363,144✔

5374

        fn.toString().match(/\{\s*\[native code\]\s*\}/) &&

363,144✔

5376

         (!fn.name.match(/^bound /) && !fn[native]));

363,144✔

5377

363,144✔

5378

// ----------------------------------------------------------------------

1✔

5379

// :: function that return macro for let, let* and letrec

1✔

5380

// ----------------------------------------------------------------------

1✔

5381

function let_macro(symbol) {

4✔

5382

    var name;

4✔

5383

    switch (symbol) {

4✔

5384

        case Symbol.for('letrec'):

4✔

5385

            name = 'letrec';

2✔

5386

            break;

2✔

5387

        case Symbol.for('let'):

4✔

5388

            name = 'let';

1✔

5389

            break;

1✔

5390

        case Symbol.for('let*'):

4✔

5391

            name = 'let*';

1✔

5392

            break;

1✔

5395

4✔

5396

    return Macro.defmacro(name, function(code, options) {

4✔

5397

        let { dynamic_env } = options;

454,812✔

5398

        const { error, macro_expand, use_dynamic } = options

454,812✔

5399

        var args;

454,812✔

5400

        // named let:

454,812✔

5401

        // (let loop ((x 10)) (iter (- x 1))) -> (letrec ((loop (lambda (x) ...

454,812✔

5402

        if (code.car instanceof LSymbol) {

454,812✔

5406

            var params;

825✔

5410

            } else {

825✔

5411

                params = code.cdr.car.map(pair => pair.car);

825✔

5412

                args = code.cdr.car.map(pair => pair.cdr.car);

825✔

5413

825✔

5414

            return new Pair(

825✔

5415

                Pair.fromArray([

825✔

5416

                    LSymbol('letrec'),

825✔

5417

                    [[code.car, Pair(

825✔

5418

                        LSymbol('lambda'),

825✔

5419

                        Pair(params, code.cdr.cdr))]],

825✔

5420

                    code.car]),

825✔

5421

                args);

825✔

5422

        } else if (macro_expand) {

454,812✔

5423

            // Macro.defmacro are special macros that should return lips code

1✔

5424

            // here we use evaluate, so we need to check special flag set by

1✔

5425

            // macroexpand to prevent evaluation of code in normal let

1✔

5426

            return;

1✔

5427

1✔

5428

        var self = this;

453,986✔

5429

        args = global_env.get('list->array')(code.car);

453,986✔

5430

        var env = self.inherit(name);

453,986✔

5431

        var values, var_body_env;

453,986✔

5432

        if (name === 'let*') {

454,812✔

5433

            var_body_env = env;

163,754✔

5434

        } else if (name === 'let') {

454,812✔

5435

            values = []; // collect potential promises

289,379✔

5436

289,379✔

5437

        var i = 0;

453,986✔

5438

        function exec() {

453,986✔

5439

            var output = hygienic_begin([env], code.cdr);

453,973✔

5440

            return evaluate(output, {

453,973✔

5441

                env,

453,973✔

5442

                dynamic_env: env,

453,973✔

5443

                use_dynamic,

453,973✔

5444

                error

453,973✔

5445

});

453,973✔

5446

453,973✔

5447

        function check_duplicates(name) {

453,986✔

5451

422,989✔

5452

        return (function loop() {

453,986✔

5453

            var pair = args[i++];

1,449,485✔

5454

            dynamic_env = name === 'let*' ? env : self;

1,449,485✔

5455

            if (!pair) {

1,449,485✔

5456

                if (values && values.length) {

453,974✔

5457

                    var v = values.map(x => x.value);

289,338✔

5458

                    // resolve all promises

289,338✔

5459

                    var promises = v.filter(is_promise);

289,338✔

5460

                    if (promises.length) {

289,338✔

5461

                        return promise_all(v).then((arr) => {

1,801✔

5462

                            for (var i = 0, len = arr.length; i < len; ++i) {

1,800✔

5463

                                const name = values[i].name;

2,010✔

5464

                                check_duplicates(name);

2,010✔

5465

                                env.set(name, arr[i]);

2,010✔

5466

2,010✔

5467

                        }).then(exec);

1,801✔

5468

                    } else {

289,338✔

5469

                        for (let { name, value } of values) {

287,537✔

5470

                            check_duplicates(name);

420,979✔

5471

                            env.set(name, value);

420,979✔

5472

420,979✔

5473

287,537✔

5474

289,338✔

5475

                return exec();

452,173✔

5476

            } else {

1,449,485✔

5477

                if (name === 'let') {

995,511✔

5478

                    var_body_env = self;

423,004✔

5479

                } else if (name === 'letrec') {

995,511✔

5480

                    var_body_env = env;

988✔

5481

988✔

5482

                var value = evaluate(pair.cdr.car, {

995,511✔

5483

                    env: var_body_env,

995,511✔

5484

                    dynamic_env,

995,511✔

5485

                    use_dynamic,

995,511✔

5486

                    error

995,511✔

5487

});

995,511✔

5488

                if (name === 'let*') {

995,511✔

5489

                    var_body_env = env = var_body_env.inherit('let*[' + i + ']');

571,518✔

5490

571,518✔

5491

                if (values) {

995,511✔

5492

                    values.push({ name: pair.car, value });

422,993✔

5493

                    return loop();

422,993✔

5494

                } else {

995,511✔

5495

                    return unpromise(value, function(value) {

572,506✔

5496

                        env.set(pair.car, value);

572,506✔

5497

                        return loop();

572,506✔

5498

});

572,506✔

5499

572,506✔

5500

995,511✔

5501

        })();

453,986✔

5502

});

4✔

5503

4✔

5504

// -------------------------------------------------------------------------

1✔

5505

function parallel(name, fn) {

1✔

5506

    return new Macro(name, function(code, { use_dynamic, error } = {}) {

1✔

5521

});

1✔

5522

1✔

5523

// -------------------------------------------------------------------------

1✔

5524

function guard_math_call(fn, ...args) {

164,717✔

5525

    args.forEach(arg => {

164,717✔

5526

        typecheck('', arg, 'number');

398,603✔

5527

});

164,717✔

5528

    return fn(...args);

164,717✔

5529

164,717✔

5530

// ----------------------------------------------------------------------

1✔

5531

function pipe(...fns) {

1✔

5532

    fns.forEach((fn, i) => {

1✔

5533

        typecheck('pipe', fn, 'function', i + 1);

2✔

5534

});

1✔

5535

    return (...args) => {

1✔

5536

        return fns.reduce((args, f) => [f.apply(this, args)], args)[0];

39✔

5537

};

1✔

5538

1✔

5539

// -------------------------------------------------------------------------

1✔

5540

function compose(...fns) {

1✔

5541

    fns.forEach((fn, i) => {

1✔

5542

        typecheck('compose', fn, 'function', i + 1);

2✔

5543

});

1✔

5544

    return pipe(...fns.reverse());

1✔

5545

1✔

5546

// -------------------------------------------------------------------------

1✔

5547

// :: fold functions generator

1✔

5548

// -------------------------------------------------------------------------

1✔

5549

function fold(name, fold) {

2✔

5550

    var self = this;

2✔

5551

    return function recur(fn, init, ...lists) {

2✔

5552

        typecheck(name, fn, 'function');

14✔

5553

        if (lists.some(is_null)) {

14✔

5557

            return init;

2✔

5558

        } else {

14✔

5559

            return fold.call(self, recur, fn, init, ...lists);

12✔

5560

12✔

5561

};

2✔

5562

2✔

5563

// -------------------------------------------------------------------------

1✔

5564

function limit_math_op(n, fn) {

63,860✔

5565

    // + 1 so it include function in guard_math_call

63,860✔

5566

    return limit(n + 1, curry(guard_math_call, fn));

63,860✔

5567

63,860✔

5568

// -------------------------------------------------------------------------

1✔

5569

// :: some functional magic

1✔

5570

// -------------------------------------------------------------------------

1✔

5571

var single_math_op = curry(limit_math_op, 1);

1✔

5572

var binary_math_op = curry(limit_math_op, 2);

1✔

5573

// -------------------------------------------------------------------------

1✔

5574

function reduce_math_op(fn, init = null) {

2✔

5575

    return function(...args) {

2✔

5576

        if (init !== null) {

45,066✔

5577

            args = [init, ...args];

45,066✔

5578

45,066✔

5579

        return args.reduce(binary_math_op(fn));

45,066✔

5580

};

2✔

5581

2✔

5582

// -------------------------------------------------------------------------

1✔

5583

function curry(fn, ...init_args) {

63,884✔

5584

    typecheck('curry', fn, 'function');

63,884✔

5585

    var len = fn.length;

63,884✔

5586

    return function() {

63,884✔

5587

        var args = init_args.slice();

229,607✔

5588

        // HACK: we use IIFE here to get rid of the name of the function.

229,607✔

5589

        // The JavaScript is smart and add name property to a function

229,607✔

5590

        // if it's assigned to a variable, with IIFE we can get rid of it.

229,607✔

5591

        // we need this so the curried function display as #<procedure>

229,607✔

5592

        const curried = (() => {

229,607✔

5593

            return (...more_args) => {

229,607✔

5594

                args = args.concat(more_args);

229,607✔

5595

                if (args.length >= len) {

229,607✔

5596

                    return fn.apply(this, args);

229,607✔

5600

};

229,607✔

5601

        })()

229,607✔

5602

        return curried(...arguments);

229,607✔

5603

};

63,884✔

5604

63,884✔

5605

// -------------------------------------------------------------------------

1✔

5606

// return function with limited number of arguments

1✔

5607

function limit(n, fn) {

63,860✔

5608

    typecheck('limit', fn, 'function', 2);

63,860✔

5609

    return function(...args) {

63,860✔

5610

        return fn(...args.slice(0, n));

164,717✔

5611

};

63,860✔

5612

63,860✔

5613

// -------------------------------------------------------------------------

1✔

5614

// :: Character object representation

1✔

5615

// -------------------------------------------------------------------------

1✔

5616

function LCharacter(char) {

1,046✔

5617

    if (typeof this !== 'undefined' && !(this instanceof LCharacter) ||

1,046✔

5618

        typeof this === 'undefined') {

1,046✔

5619

        return new LCharacter(char);

523✔

5620

523✔

5621

    if (char instanceof LString) {

1,046✔

5622

        char = char.valueOf();

118✔

5623

118✔

5624

    var name;

523✔

5625

    if (Array.from(char).length > 1) {

1,046✔

5626

        // this is name

7✔

5627

        char = char.toLowerCase();

7✔

5628

        if (LCharacter.__names__[char]) {

7✔

5629

            name = char;

7✔

5630

            char = LCharacter.__names__[char];

7✔

5636

    } else {

1,046✔

5637

        name = LCharacter.__rev_names__[char];

516✔

5638

516✔

5639

    enumerable(this, '__char__', char);

523✔

5640

    if (name) {

1,046✔

5641

        enumerable(this, '__name__', name);

108✔

5642

108✔

5643

1,046✔

5644

LCharacter.__names__ = characters;

1✔

5645

LCharacter.__rev_names__ = {};

1✔

5646

Object.keys(LCharacter.__names__).forEach(key => {

1✔

5647

    var value = LCharacter.__names__[key];

41✔

5648

    LCharacter.__rev_names__[value] = key;

41✔

5649

});

1✔

5650

LCharacter.prototype.toUpperCase = function() {

1✔

5651

    return LCharacter(this.__char__.toUpperCase());

7✔

5652

};

1✔

5653

LCharacter.prototype.toLowerCase = function() {

1✔

5654

    return LCharacter(this.__char__.toLowerCase());

42✔

5655

};

1✔

5656

LCharacter.prototype.toString = function() {

1✔

5657

    return '#\\' + (this.__name__ || this.__char__);

25✔

5658

};

1✔

5659

LCharacter.prototype.valueOf = LCharacter.prototype.serialize = function() {

1✔

5660

    return this.__char__;

459✔

5661

};

1✔

5662

// -------------------------------------------------------------------------

1✔

5663

// :: String wrapper that handle copy and in place change

1✔

5664

// -------------------------------------------------------------------------

1✔

5665

function LString(string) {

409,668✔

5666

    if (typeof this !== 'undefined' && !(this instanceof LString) ||

409,668✔

5667

        typeof this === 'undefined') {

409,668✔

5668

        return new LString(string);

204,834✔

5669

204,834✔

5675

    } else {

409,668✔

5676

        this.__string__ = string.valueOf();

204,834✔

5677

204,834✔

5678

409,668✔

5679

1✔

5680

    const ignore = ['length', 'constructor'];

1✔

5681

    const _keys = Object.getOwnPropertyNames(String.prototype).filter(name => {

1✔

5682

        return !ignore.includes(name);

52✔

5683

});

1✔

5684

    const wrap = (fn) => function(...args) {

1✔

5685

        return fn.apply(this.__string__, args);

717,560✔

5686

};

1✔

5687

    for (let key of _keys) {

1✔

5688

        LString.prototype[key] = wrap(String.prototype[key]);

50✔

5689

50✔

5690

1✔

5691

LString.prototype[Symbol.iterator] = function*() {

1✔

5692

    const chars = Array.from(this.__string__);

1✔

5693

    for (const char of chars) {

1✔

5694

        yield LCharacter(char);

5✔

5695

5✔

5696

};

1✔

5697

LString.prototype.serialize = function() {

1✔

5698

    return this.valueOf();

1✔

5699

};

1✔

5700

LString.isString = function(x) {

1✔

5701

    return x instanceof LString || typeof x === 'string';

196,300✔

5702

};

1✔

5703

LString.prototype.freeze = function() {

1✔

5704

    const string = this.__string__;

46,719✔

5705

    delete this.__string__;

46,719✔

5706

    read_only(this, '__string__', string);

46,719✔

5707

};

1✔

5708

LString.prototype.get = function(n) {

1✔

5709

    typecheck('LString::get', n, 'number');

39✔

5710

    return Array.from(this.__string__)[n.valueOf()];

39✔

5711

};

1✔

5712

LString.prototype.cmp = function(string) {

1✔

5713

    typecheck('LString::cmp', string, 'string');

22,436✔

5714

    var a = this.valueOf();

22,436✔

5715

    var b = string.valueOf();

22,436✔

5716

    if (a < b) {

22,436✔

5717

        return -1;

6,594✔

5718

    } else if (a === b) {

22,436✔

5719

        return 0;

8,299✔

5720

    } else {

15,842✔

5721

        return 1;

7,543✔

5722

7,543✔

5723

};

1✔

5724

LString.prototype.lower = function() {

1✔

5725

    return LString(this.__string__.toLowerCase());

28✔

5726

};

1✔

5727

LString.prototype.upper = function() {

1✔

5729

};

1✔

5730

LString.prototype.set = function(n, char) {

1✔

5731

    typecheck('LString::set', n, 'number');

1✔

5732

    typecheck('LString::set', char, ['string', 'character']);

1✔

5733

    n = n.valueOf();

1✔

5734

    if (char instanceof LCharacter) {

1✔

5735

        char = char.__char__;

1✔

5736

1✔

5737

    var string = [];

1✔

5741

    string.push(char);

1✔

5742

    if (n < this.__string__.length - 1) {

1✔

5743

        string.push(this.__string__.substring(n + 1));

1✔

5744

1✔

5745

    this.__string__ = string.join('');

1✔

5746

};

1✔

5747

Object.defineProperty(LString.prototype, "length", {

1✔

5748

    get: function() {

1✔

5749

        return this.__string__.length;

4✔

5750

4✔

5751

});

1✔

5752

LString.prototype.clone = function() {

1✔

5754

};

1✔

5755

LString.prototype.fill = function(char) {

1✔

5762

};

1✔

5763

// -------------------------------------------------------------------------

1✔

5764

// :: Number wrapper that handle BigNumbers

1✔

5765

// -------------------------------------------------------------------------

1✔

5766

function LNumber(n, force = false) {

1,586,741✔

5767

    if (n instanceof LNumber) {

1,586,741✔

5768

        return n;

1,268,542✔

5769

1,268,542✔

5770

    if (typeof this !== 'undefined' && !(this instanceof LNumber) ||

1,586,741✔

5771

        typeof this === 'undefined') {

1,586,741✔

5772

        return new LNumber(n, force);

159,007✔

5773

159,007✔

5777

    var _type = LNumber.getType(n);

159,192✔

5778

    if (LNumber.types[_type]) {

1,586,741✔

5779

        return LNumber.types[_type](n, force);

4,118✔

5780

4,118✔

5781

    var parsable = n instanceof Array && LString.isString(n[0]) &&

1,586,741✔

5782

        LNumber.isNumber(n[1]);

1,586,741✔

5789

    // prevent infinite loop https://github.com/indutny/bn.js/issues/186

155,074✔

5793

    var value;

155,074✔

5794

    if (parsable) {

1,586,741✔

5795

        var [str, radix] = n;

4,493✔

5802

        var sign = str.match(/^([+-])/);

4,493✔

5803

        var minus = false;

4,493✔

5804

        if (sign) {

4,493✔

5805

            str = str.replace(/^[+-]/, '');

517✔

5806

            if (sign[1] === '-') {

517✔

5807

                minus = true;

182✔

5808

182✔

5809

517✔

5810

4,493✔

5811

    if (Number.isNaN(n)) {

1,586,741✔

5812

        return LFloat(n);

544✔

5813

    } else if (parsable && Number.isNaN(parseInt(str, radix))) {

1,586,741✔

5814

        return nan;

1✔

5815

    } else if (typeof BigInt !== 'undefined') {

154,530✔

5816

        if (typeof n !== 'bigint') {

154,529✔

5817

            if (parsable) {

154,013✔

5818

                let prefix;

4,492✔

5819

                // default number base (radix) supported by BigInt constructor

4,492✔

5820

                switch (radix) {

4,492✔

5821

                    case 8:

4,492✔

5822

                        prefix = '0o';

32✔

5823

                        break;

32✔

5824

                    case 16:

4,492✔

5825

                        prefix = '0x';

99✔

5826

                        break;

99✔

5827

                    case 2:

4,492✔

5828

                        prefix = '0b';

98✔

5829

                        break;

98✔

5830

                    case 10:

4,492✔

5831

                        prefix = '';

4,263✔

5832

                        break;

4,263✔

5833

4,492✔

5840

                } else {

4,492✔

5841

                    value = BigInt(prefix + str);

4,492✔

5842

4,492✔

5843

            } else {

154,013✔

5844

                value = BigInt(n);

149,521✔

5845

149,521✔

5846

            if (minus) {

154,013✔

5847

                value *= BigInt(-1);

182✔

5848

182✔

5849

        } else {

154,529✔

5850

            value = n;

516✔

5851

516✔

5852

        return LBigInteger(value, true);

154,529✔

5863

1,586,741✔

5864

1✔

5865

// -------------------------------------------------------------------------

1✔

5866

LNumber.prototype.constant = function(value, type) {

1✔

5867

    enumerable(this, '__value__', value);

335,401✔

5868

    enumerable(this, '__type__', type);

335,401✔

5869

};

1✔

5870

// -------------------------------------------------------------------------

1✔

5871

LNumber.types = {

1✔

5872

    float: function(n, force = false) {

1✔

5873

        return new LFloat(n, force);

2,284✔

5874

},

1✔

5875

    complex: function(n, force = false) {

1✔

5879

        return new LComplex(n, force);

1,529✔

5880

},

1✔

5881

    rational: function(n, force = false) {

1✔

5882

        if (!LNumber.isRational(n)) {

412✔

5883

            n = { num: n, denom: 1 };

23✔

5884

23✔

5885

        return new LRational(n, force);

412✔

5886

412✔

5887

};

1✔

5888

// -------------------------------------------------------------------------

1✔

5889

LNumber.prototype.serialize = function() {

1✔

5890

    return this.__value__;

1✔

5891

};

1✔

5892

// -------------------------------------------------------------------------

1✔

5893

LNumber.prototype.isNaN = function() {

1✔

5894

    return Number.isNaN(this.__value__);

648✔

5895

};

1✔

5896

// -------------------------------------------------------------------------

1✔

5897

LNumber.prototype.gcd = function(b) {

1✔

5898

    // ref: https://rosettacode.org/wiki/Greatest_common_divisor#JavaScript

76✔

5899

    var a = this.abs();

76✔

5900

    b = b.abs();

76✔

5901

    if (b.cmp(a) === 1) {

76✔

5902

        var temp = a;

65✔

5903

        a = b;

65✔

5904

        b = temp;

65✔

5905

65✔

5906

    while (true) {

76✔

5907

        a = a.rem(b);

109✔

5908

        if (a.cmp(0) === 0) {

109✔

5909

            return b;

69✔

5910

69✔

5911

        b = b.rem(a);

40✔

5912

        if (b.cmp(0) === 0) {

109✔

5913

            return a;

7✔

5914

7✔

5915

109✔

5916

};

1✔

5917

// -------------------------------------------------------------------------

1✔

5918

LNumber.isFloat = function isFloat(n) {

1✔

5919

    return n instanceof LFloat || (Number(n) === n && n % 1 !== 0);

159,483✔

5920

};

1✔

5921

// -------------------------------------------------------------------------

1✔

5922

LNumber.isNumber = function(n) {

1✔

5923

    return n instanceof LNumber ||

16,049,221✔

5924

        (LNumber.isNative(n) || LNumber.isBN(n));

16,049,221✔

5925

};

1✔

5926

// -------------------------------------------------------------------------

1✔

5927

LNumber.isComplex = function(n) {

1✔

5928

    if (!n) {

334,654✔

5929

        return false;

24,256✔

5930

24,256✔

5931

    var ret = n instanceof LComplex ||

334,654✔

5932

        ((LNumber.isNumber(n.im) || LNumber.isRational(n.im) || Number.isNaN(n.im)) &&

309,353✔

5934

    return ret;

334,654✔

5935

};

1✔

5936

// -------------------------------------------------------------------------

1✔

5937

LNumber.isRational = function(n) {

1✔

5938

    if (!n) {

461,658✔

5939

        return false;

327,388✔

5940

327,388✔

5941

    return n instanceof LRational ||

461,658✔

5942

        (LNumber.isNumber(n.num) && LNumber.isNumber(n.denom));

461,658✔

5943

};

1✔

5944

// -------------------------------------------------------------------------

1✔

5945

LNumber.isInteger = function(n) {

1✔

5949

    if (LNumber.isFloat(n)) {

29✔

5950

        return false;

7✔

5951

7✔

5952

    if (LNumber.isRational(n)) {

29✔

5953

        return false;

3✔

5954

3✔

5955

    if (LNumber.isComplex(n)) {

29✔

5956

        return false;

14✔

5957

14✔

5958

    return true;

5✔

5959

};

1✔

5960

// -------------------------------------------------------------------------

1✔

5961

LNumber.isNative = function(n) {

1✔

5962

    return typeof n === 'bigint' || typeof n === 'number';

15,932,001✔

5963

};

1✔

5964

// -------------------------------------------------------------------------

1✔

5965

LNumber.isBigInteger = function(n) {

1✔

5967

        LNumber.isBN(n);

322,632✔

5968

};

1✔

5969

// -------------------------------------------------------------------------

1✔

5970

LNumber.isBN = function(n) {

1✔

5972

};

1✔

5973

// -------------------------------------------------------------------------

1✔

5974

LNumber.getArgsType = function(a, b) {

1✔

5982

};

1✔

5983

// -------------------------------------------------------------------------

1✔

5984

LNumber.prototype.toString = function(radix) {

1✔

5988

    if (radix >= 2 && radix < 36) {

22,807✔

5989

        return this.__value__.toString(radix);

22✔

5990

22✔

5991

    return this.__value__.toString();

22,785✔

5992

};

1✔

5993

// -------------------------------------------------------------------------

1✔

5994

LNumber.prototype.asType = function(n) {

1✔

5995

    var _type = LNumber.getType(this);

155✔

5996

    return LNumber.types[_type] ? LNumber.types[_type](n) : LNumber(n);

155✔

5997

};

1✔

5998

// -------------------------------------------------------------------------

1✔

5999

LNumber.prototype.isBigNumber = function() {

1✔

6001

        typeof BN !== 'undefined' && !(this.value instanceof BN);

21✔

6002

};

1✔

6003

// -------------------------------------------------------------------------

1✔

6004

['floor', 'ceil', 'round'].forEach(fn => {

1✔

6005

    LNumber.prototype[fn] = function() {

3✔

6006

        if (this.float || LNumber.isFloat(this.__value__)) {

27✔

6007

            return LNumber(Math[fn](this.__value__));

4✔

6008

        } else {

27✔

6009

            return LNumber(Math[fn](this.valueOf()));

23✔

6010

23✔

6011

};

3✔

6012

});

1✔

6013

// -------------------------------------------------------------------------

1✔

6014

LNumber.prototype.valueOf = function() {

1✔

6015

    if (LNumber.isNative(this.__value__)) {

70,232✔

6016

        return Number(this.__value__);

70,232✔

6020

};

1✔

6021

// -------------------------------------------------------------------------

1✔

6022

// Type coercion matrix

1✔

6023

// -------------------------------------------------------------------------

1✔

6024

const matrix = (function() {

1✔

6025

    var i = (a, b) => [a, b];

1✔

6026

    return {

1✔

6027

        bigint: {

1✔

6028

            bigint: i,

1✔

6029

            float: (a, b) => [LFloat(a.valueOf(), true), b],

1✔

6030

            rational: (a, b) => [{ num: a, denom: 1 }, b],

1✔

6031

            complex: (a, b) => [{ im: 0, re: a }, b]

1✔

6032

},

1✔

6033

        integer: {

1✔

6034

            integer: i,

1✔

6035

            float: (a, b) => [LFloat(a.valueOf(), true), b],

1✔

6036

            rational: (a, b) => [{ num: a, denom: 1 }, b],

1✔

6037

            complex: (a, b) => [{ im: 0, re: a }, b]

1✔

6038

},

1✔

6039

        float: {

1✔

6040

            bigint: (a, b) => [a, b && LFloat(b.valueOf(), true)],

1✔

6041

            integer: (a, b) => [a, b && LFloat(b.valueOf(), true)],

1✔

6042

            float: i,

1✔

6043

            rational: (a, b) => [a, b && LFloat(b.valueOf(), true)],

1✔

6044

            complex: (a, b) => [{ re: a, im: LFloat(0, true) }, b]

1✔

6045

},

1✔

6046

        complex: {

1✔

6047

            bigint: complex('bigint'),

1✔

6048

            integer: complex('integer'),

1✔

6049

            float: complex('float'),

1✔

6050

            rational: complex('rational'),

1✔

6051

            complex: (a, b) => {

1✔

6052

                const [a_re, b_re] = LNumber.coerce(a.__re__, b.__re__);

268✔

6053

                const [a_im, b_im] = LNumber.coerce(a.__im__, b.__im__);

268✔

6054

                return [

268✔

6055

                    { im: a_im, re: a_re },

268✔

6056

                    { im: b_im, re: b_re }

268✔

6057

];

268✔

6058

268✔

6059

},

1✔

6060

        rational: {

1✔

6061

            bigint: (a, b) => [a, b && { num: b, denom: 1 }],

1✔

6062

            integer: (a, b) => [a, b && { num: b, denom: 1 }],

1✔

6063

            float: (a, b) => [LFloat(a.valueOf()), b],

1✔

6064

            rational: i,

1✔

6065

            complex: (a, b) => {

1✔

6066

                return [

38✔

6067

38✔

6068

                        im: coerce(a.__type__, b.__im__.__type__, 0)[0],

38✔

6069

                        re: coerce(a.__type__, b.__re__.__type__, a)[0]

38✔

6070

},

38✔

6071

38✔

6072

                        im: coerce(a.__type__, b.__im__.__type__, b.__im__)[0],

38✔

6073

                        re: coerce(a.__type__, b.__re__.__type__, b.__re__)[0]

38✔

6074

38✔

6075

];

38✔

6076

38✔

6077

1✔

6078

};

1✔

6079

    function complex(type) {

1✔

6080

        return (a, b) => {

4✔

6081

            return [

341✔

6082

341✔

6083

                    im: coerce(type, a.__im__.__type__, 0, a.__im__)[1],

341✔

6084

                    re: coerce(type, a.__re__.__type__, 0, a.__re__)[1]

341✔

6085

},

341✔

6086

341✔

6087

                    im: coerce(type, a.__im__.__type__, 0, 0)[1],

341✔

6088

                    re: coerce(type, b.__type__, 0, b)[1]

341✔

6089

341✔

6090

];

341✔

6091

};

4✔

6092

4✔

6093

})();

1✔

6094

// -------------------------------------------------------------------------

1✔

6095

function coerce(type_a, type_b, a, b) {

1,516✔

6096

    return matrix[type_a][type_b](a, b);

1,516✔

6097

1,516✔

6098

// -------------------------------------------------------------------------

1✔

6099

LNumber.coerce = function(a, b) {

1✔

6100

    const a_type = LNumber.getType(a);

323,048✔

6101

    const b_type = LNumber.getType(b);

323,048✔

6107

    var tmp = matrix[a_type][b_type](a, b);

323,048✔

6108

    return tmp.map(n => LNumber(n, true));

323,048✔

6109

};

1✔

6110

// -------------------------------------------------------------------------

1✔

6111

LNumber.prototype.coerce = function(n) {

1✔

6115

    if (typeof n === 'number') {

322,292✔

6116

        n = LNumber(n);

6,461✔

6117

6,461✔

6118

    return LNumber.coerce(this, n);

322,292✔

6119

};

1✔

6120

// -------------------------------------------------------------------------

1✔

6121

LNumber.getType = function(n) {

1✔

6122

    if (n instanceof LNumber) {

805,443✔

6123

        return n.__type__;

646,251✔

6124

646,251✔

6125

    if (LNumber.isFloat(n)) {

805,443✔

6126

        return 'float';

2,200✔

6127

2,200✔

6128

    if (LNumber.isComplex(n)) {

805,443✔

6129

        return 'complex';

1,529✔

6130

1,529✔

6131

    if (LNumber.isRational(n)) {

805,443✔

6132

        return 'rational';

389✔

6133

389✔

6134

    if (typeof n === 'number') {

805,443✔

6135

        return 'integer';

150,065✔

6136

150,065✔

6137

    if ((typeof BigInt !== 'undefined' && typeof n !== 'bigint') ||

805,443✔

6139

        return 'bigint';

4,493✔

6140

4,493✔

6141

};

1✔

6142

// -------------------------------------------------------------------------

1✔

6143

LNumber.prototype.isFloat = function() {

1✔

6144

    return !!(LNumber.isFloat(this.__value__) || this.float);

10✔

6145

};

1✔

6146

// -------------------------------------------------------------------------

1✔

6147

var mapping = {

1✔

6148

    'add': '+',

1✔

6149

    'sub': '-',

1✔

6150

    'mul': '*',

1✔

6151

    'div': '/',

1✔

6152

    'rem': '%',

1✔

6153

    'or': '|',

1✔

6154

    'and': '&',

1✔

6155

    'neg': '~',

1✔

6156

    'shl': '>>',

1✔

6157

    'shr': '<<'

1✔

6158

};

1✔

6159

var rev_mapping = {};

1✔

6160

Object.keys(mapping).forEach((key) => {

1✔

6161

    rev_mapping[mapping[key]] = key;

10✔

6162

    LNumber.prototype[key] = function(n) {

10✔

6163

        return this.op(mapping[key], n);

169,908✔

6164

};

10✔

6165

});

1✔

6166

// -------------------------------------------------------------------------

1✔

6167

LNumber._ops = {

1✔

6168

    '*': function(a, b) {

1✔

6169

        return a * b;

12,775✔

6170

},

1✔

6171

    '+': function(a, b) {

1✔

6172

        return a + b;

88,320✔

6173

},

1✔

6174

    '-': function(a, b) {

1✔

6175

        if (typeof b === 'undefined') {

66,640✔

6176

            return -a;

133✔

6177

133✔

6178

        return a - b;

66,507✔

6179

},

1✔

6180

    '/': function(a, b) {

1✔

6181

        return a / b;

1,498✔

6182

},

1✔

6183

    '%': function(a, b) {

1✔

6184

        return a % b;

1,926✔

6185

},

1✔

6186

    '|': function(a, b) {

1✔

6188

},

1✔

6189

    '&': function(a, b) {

1✔

6191

},

1✔

6192

    '~': function(a) {

1✔

6194

},

1✔

6195

    '>>': function(a, b) {

1✔

6197

},

1✔

6198

    '<<': function(a, b) {

1✔

6201

};

1✔

6202

// -------------------------------------------------------------------------

1✔

6203

LNumber.prototype.op = function(op, n) {

1✔

6204

    if (typeof n === 'undefined') {

171,841✔

6205

        return LNumber(LNumber._ops[op](this.valueOf()));

133✔

6206

133✔

6207

    if (typeof n === 'number') {

171,841✔

6208

        n = LNumber(n);

48,805✔

6209

48,805✔

6210

    if (Number.isNaN(this.__value__) && !LNumber.isComplex(n) ||

171,841✔

6211

        !LNumber.isComplex(this) && Number.isNaN(n.__value__)) {

171,841✔

6212

        return LNumber(NaN);

283✔

6213

283✔

6214

    const [a, b] = this.coerce(n);

171,425✔

6215

    if (a._op) {

171,425✔

6216

        return a._op(op, b);

171,425✔

6217

171,425✔

6219

};

1✔

6220

// -------------------------------------------------------------------------

1✔

6221

LNumber.prototype.sqrt = function() {

1✔

6228

};

1✔

6229

// -------------------------------------------------------------------------

1✔

6230

var pow = function(a, b) {

1✔

6232

};

1✔

6233

// -------------------------------------------------------------------------

1✔

6234

// use native exponential operator if possible (it's way faster)

1✔

6235

// -------------------------------------------------------------------------

1✔

6236

var exp_op = new Function('a,b', 'return a ** b');

1✔

6237

try {

1✔

6238

    if (exp_op(2, 2) === 4) {

1✔

6239

        pow = exp_op;

1✔

6240

1✔

6244

// -------------------------------------------------------------------------

1✔

6245

LNumber.prototype.pow = function(n) {

1✔

6246

    var value;

110✔

6247

    const [a, b] = this.coerce(n);

110✔

6248

    if (LNumber.isNative(a.__value__) && LNumber.isNative(b.__value__)) {

110✔

6249

        value = pow(a.__value__, b.__value__);

110✔

6255

    return LNumber(value);

110✔

6256

};

1✔

6257

// -------------------------------------------------------------------------

1✔

6258

LNumber.prototype.abs = function() {

1✔

6259

    var value = this.__value__;

185✔

6260

    if (LNumber.isNative(this.__value__)) {

185✔

6261

        if (value < 0) {

185✔

6262

            value = -value;

33✔

6263

33✔

6267

    return new LNumber(value);

185✔

6268

};

1✔

6269

// -------------------------------------------------------------------------

1✔

6270

LNumber.prototype.isOdd = function() {

1✔

6271

    if (LNumber.isNative(this.__value__)) {

21✔

6272

        if (this.isBigNumber()) {

21✔

6273

            return this.__value__ % BigInt(2) === BigInt(1);

21✔

6274

21✔

6283

};

1✔

6284

// -------------------------------------------------------------------------

1✔

6285

LNumber.prototype.isEven = function() {

1✔

6286

    return !this.isOdd();

5✔

6287

};

1✔

6288

// -------------------------------------------------------------------------

1✔

6289

LNumber.prototype.cmp = function(n) {

1✔

6290

    const [a, b] = this.coerce(n);

149,470✔

6291

    function cmp(a, b) {

149,470✔

6292

        if (a.__value__ < b.__value__) {

149,470✔

6293

            return -1;

49,642✔

6294

        } else if (a.__value__ === b.__value__) {

149,470✔

6295

            return 0;

40,697✔

6296

        } else {

99,828✔

6297

            return 1;

59,131✔

6298

59,131✔

6299

149,470✔

6300

    if (a.__type__ === 'bigint') {

149,470✔

6301

        if (LNumber.isNative(a.__value__)) {

145,847✔

6302

            return cmp(a, b);

145,847✔

6306

    } else if (a instanceof LFloat) {

149,470✔

6307

        return cmp(a, b);

3,623✔

6308

3,623✔

6309

};

1✔

6310

// -------------------------------------------------------------------------

1✔

6311

// :: COMPLEX TYPE

1✔

6312

// -------------------------------------------------------------------------

1✔

6313

function LComplex(n, force = false) {

4,839✔

6314

    if (typeof this !== 'undefined' && !(this instanceof LComplex) ||

4,839✔

6315

        typeof this === 'undefined') {

4,839✔

6316

        return new LComplex(n, force);

1,655✔

6317

1,655✔

6330

    var im = n.im instanceof LNumber ? n.im : LNumber(n.im);

4,839✔

6331

    var re = n.re instanceof LNumber ? n.re : LNumber(n.re);

4,839✔

6332

    this.constant(im, re);

4,839✔

6333

4,839✔

6334

// -------------------------------------------------------------------------

1✔

6335

LComplex.prototype = Object.create(LNumber.prototype);

1✔

6336

LComplex.prototype.constructor = LComplex;

1✔

6337

// -------------------------------------------------------------------------

1✔

6338

LComplex.prototype.constant = function(im, re) {

1✔

6339

    enumerable(this, '__im__', im);

3,184✔

6340

    enumerable(this, '__re__', re);

3,184✔

6341

    enumerable(this, '__type__', 'complex');

3,184✔

6342

};

1✔

6343

// -------------------------------------------------------------------------

1✔

6344

LComplex.prototype.serialize = function() {

1✔

6345

    return {

1✔

6346

        re: this.__re__,

1✔

6347

        im: this.__im__

1✔

6348

};

1✔

6349

};

1✔

6350

// -------------------------------------------------------------------------

1✔

6351

LComplex.prototype.toRational = function(n) {

1✔

6352

    let im = this.__im__, re = this.__re__;

6✔

6353

    if (LNumber.isFloat(this.__im__)) {

6✔

6354

        im = LFloat(this.__im__).toRational(n);

4✔

6355

4✔

6356

    if (LNumber.isFloat(this.__re__)) {

6✔

6357

        re = LFloat(this.__re__).toRational(n);

4✔

6358

4✔

6359

    return LComplex({ im, re });

6✔

6360

};

1✔

6361

// -------------------------------------------------------------------------

1✔

6362

LComplex.prototype.pow = function(n) {

1✔

6363

    const cmp = n.cmp(0);

38✔

6367

    const angle = LNumber(Math.atan2(this.__im__.valueOf(), this.__re__.valueOf()));

38✔

6368

    const magnitude = LNumber(this.modulus());

38✔

6369

    if (LNumber.isComplex(n) && n.__im__.cmp(0) !== 0) {

38✔

6370

        // Complex exponent of a complex numbers

33✔

6371

        // equation taken from https://math.stackexchange.com/a/476998/31117

33✔

6372

        let p = n.mul(Math.log(magnitude.valueOf())).add(LComplex.i.mul(angle).mul(n));

33✔

6373

        if (!LNumber.isComplex(p)) {

33✔

6374

            return LFloat(Math.E).pow(p);

2✔

6375

2✔

6376

        const e = LFloat(Math.E).pow(p.__re__.valueOf());

31✔

6377

        return LComplex({

31✔

6378

            re: e.mul(Math.cos(p.__im__.valueOf())),

31✔

6379

            im: e.mul(Math.sin(p.__im__.valueOf()))

31✔

6380

});

31✔

6381

31✔

6382

    const positive = n.__re__.cmp(0) > 0;

5✔

6383

    n = n.__re__.valueOf();

5✔

6384

    if (LNumber.isInteger(n) && positive) {

38✔

6385

        let result = this;

1✔

6386

        while (--n) {

1✔

6387

            result = result.mul(this);

1✔

6388

1✔

6389

        return result;

1✔

6390

1✔

6391

    // equation taken from Wikipedia:

4✔

6392

    // https://w.wiki/97V3#Integer_and_fractional_exponents

4✔

6393

    const r = magnitude.pow(n);

4✔

6394

    const a = angle.mul(n);

4✔

6395

    return LComplex({ re: r.mul(Math.cos(a)), im: r.mul(Math.sin(a)) });

4✔

6396

};

1✔

6397

// -------------------------------------------------------------------------

1✔

6398

LComplex.prototype.add = function(n) {

1✔

6399

    return this.complex_op('add', n, function(a_re, b_re, a_im, b_im) {

215✔

6400

        return {

215✔

6401

            re: a_re.add(b_re),

215✔

6402

            im: a_im.add(b_im)

215✔

6403

};

215✔

6404

});

215✔

6405

};

1✔

6406

// -------------------------------------------------------------------------

1✔

6407

// :: factor is used in / and modulus

1✔

6408

// -------------------------------------------------------------------------

1✔

6409

LComplex.prototype.factor = function() {

1✔

6410

    // fix rounding when calculating (/ 1.0 1/10+1/10i)

131✔

6411

    if (this.__im__ instanceof LFloat || this.__im__ instanceof LFloat) {

131✔

6412

        let { __re__: re, __im__: im } = this;

50✔

6413

        let x, y;

50✔

6414

        if (re instanceof LFloat) {

50✔

6415

            x = re.toRational().mul(re.toRational());

43✔

6416

        } else {

50✔

6417

            x = re.mul(re);

7✔

6418

7✔

6419

        if (im instanceof LFloat) {

50✔

6420

            y = im.toRational().mul(im.toRational());

50✔

6424

        return x.add(y);

50✔

6425

    } else {

131✔

6426

        return this.__re__.mul(this.__re__).add(this.__im__.mul(this.__im__));

81✔

6427

81✔

6428

};

1✔

6429

// -------------------------------------------------------------------------

1✔

6430

LComplex.prototype.modulus = function() {

1✔

6431

    return this.factor().sqrt();

53✔

6432

};

1✔

6433

// -------------------------------------------------------------------------

1✔

6434

LComplex.prototype.conjugate = function() {

1✔

6435

    return LComplex({ re: this.__re__, im: this.__im__.sub() });

78✔

6436

};

1✔

6437

// -------------------------------------------------------------------------

1✔

6438

LComplex.prototype.sqrt = function() {

1✔

6439

    const r = this.modulus();

9✔

6440

    // code based ok Kawa Scheme source code (file DComplex.java)

9✔

6441

    // Copyright (c) 1997  Per M.A. Bothner.

9✔

6442

    // Released under MIT License

9✔

6443

    let re, im;

9✔

6446

    } else if (this.__re__.cmp(0) === 1) {

9✔

6447

        re = LFloat(0.5).mul(r.add(this.__re__)).sqrt();

4✔

6448

        im = this.__im__.div(re).div(2);

4✔

6449

    } else {

9✔

6450

        im = LFloat(0.5).mul(r.sub(this.__re__)).sqrt();

5✔

6454

        re = this.__im__.div(im).div(2);

5✔

6455

5✔

6456

    return LComplex({ im, re });

9✔

6457

};

1✔

6458

// -------------------------------------------------------------------------

1✔

6459

LComplex.prototype.div = function(n) {

1✔

6460

    if (LNumber.isNumber(n) && !LNumber.isComplex(n)) {

114✔

6464

        const re = this.__re__.div(n);

33✔

6465

        const im = this.__im__.div(n);

33✔

6466

        return LComplex({ re, im });

33✔

6470

    if (this.cmp(n) === 0) {

114✔

6471

        const [ a, b ] = this.coerce(n);

3✔

6472

        const ret = a.__im__.div(b.__im__);

3✔

6473

        return ret.coerce(b.__re__)[0];

3✔

6474

3✔

6475

    const [ a, b ] = this.coerce(n);

78✔

6476

    const denom = b.factor();

78✔

6477

    const conj = b.conjugate();

78✔

6478

    const num = a.mul(conj);

78✔

6479

    if (!LNumber.isComplex(num)) {

114✔

6480

        return num.div(denom);

1✔

6481

1✔

6482

    const re = num.__re__.op('/', denom);

77✔

6483

    const im = num.__im__.op('/', denom);

77✔

6484

    return LComplex({ re, im });

77✔

6485

};

1✔

6486

// -------------------------------------------------------------------------

1✔

6487

LComplex.prototype.sub = function(n) {

1✔

6488

    return this.complex_op('sub', n, function(a_re, b_re, a_im, b_im) {

37✔

6489

        return {

37✔

6490

            re: a_re.sub(b_re),

37✔

6491

            im: a_im.sub(b_im)

37✔

6492

};

37✔

6493

});

37✔

6494

};

1✔

6495

// -------------------------------------------------------------------------

1✔

6496

LComplex.prototype.mul = function(n) {

1✔

6497

    return this.complex_op('mul', n, function(a_re, b_re, a_im, b_im) {

266✔

6498

        var ret = {

266✔

6499

            re: a_re.mul(b_re).sub(a_im.mul(b_im)),

266✔

6500

            im: a_re.mul(b_im).add(b_re.mul(a_im))

266✔

6501

};

266✔

6502

        return ret;

266✔

6503

});

266✔

6504

};

1✔

6505

// -------------------------------------------------------------------------

1✔

6506

LComplex.prototype.complex_op = function(name, n, fn) {

1✔

6507

    const calc = (re, im) => {

518✔

6508

        var result = fn(this.__re__, re, this.__im__, im);

518✔

6509

        if ('im' in result && 're' in result) {

518✔

6510

            if (result.im.cmp(0) === 0) {

518✔

6511

                return result.re;

34✔

6512

34✔

6513

            return LComplex(result, true);

484✔

6514

484✔

6516

};

518✔

6517

    if (typeof n === 'undefined') {

518✔

6518

        return calc();

2✔

6519

2✔

6520

    if (LNumber.isNumber(n) && !LNumber.isComplex(n)) {

518✔

6521

        if (!(n instanceof LNumber)) {

155✔

6522

            n = LNumber(n);

34✔

6523

34✔

6524

        const im = n.asType(0);

155✔

6525

        n = { __im__: im, __re__: n };

155✔

6531

    return calc(re, im);

518✔

6532

};

1✔

6533

// -------------------------------------------------------------------------

1✔

6534

LComplex._op = {

1✔

6535

    '+': 'add',

1✔

6536

    '-': 'sub',

1✔

6537

    '*': 'mul',

1✔

6538

    '/': 'div'

1✔

6539

};

1✔

6540

// -------------------------------------------------------------------------

1✔

6541

LComplex.prototype._op = function(op, n) {

1✔

6542

    const fn = LComplex._op[op];

212✔

6543

    return this[fn](n);

212✔

6544

};

1✔

6545

// -------------------------------------------------------------------------

1✔

6546

LComplex.prototype.cmp = function(n) {

1✔

6547

    const [a, b] = this.coerce(n);

514✔

6548

    const [re_a, re_b] = a.__re__.coerce(b.__re__);

514✔

6549

    const re_cmp = re_a.cmp(re_b);

514✔

6550

    if (re_cmp !== 0) {

514✔

6551

        return re_cmp;

391✔

6552

    } else {

514✔

6553

        const [im_a, im_b] = a.__im__.coerce(b.__im__);

123✔

6554

        return im_a.cmp(im_b);

123✔

6555

123✔

6556

};

1✔

6557

// -------------------------------------------------------------------------

1✔

6558

LComplex.prototype.valueOf = function() {

1✔

6559

    return [this.__re__, this.__im__].map(x => x.valueOf());

26✔

6560

};

1✔

6561

// -------------------------------------------------------------------------

1✔

6562

LComplex.prototype.toString = function() {

1✔

6563

    var result;

119✔

6564

    if (this.__re__.cmp(0) !== 0) {

119✔

6565

        result = [toString(this.__re__)];

98✔

6566

    } else {

119✔

6567

        result = [];

21✔

6568

21✔

6569

    // NaN and inf already have sign

119✔

6570

    var im = this.__im__.valueOf();

119✔

6571

    var inf = [Number.NEGATIVE_INFINITY, Number.POSITIVE_INFINITY].includes(im);

119✔

6572

    var im_str = toString(this.__im__);

119✔

6573

    if (!inf && !Number.isNaN(im)) {

119✔

6574

        var zero_check = this.__im__.cmp(0);

99✔

6576

            result.push('-');

31✔

6577

        } else {

99✔

6578

            result.push('+');

68✔

6579

68✔

6580

        im_str = im_str.replace(/^-/, '');

99✔

6581

99✔

6582

    result.push(im_str);

119✔

6583

    result.push('i');

119✔

6584

    return result.join('');

119✔

6585

};

1✔

6586

// -------------------------------------------------------------------------

1✔

6587

// :: FLOAT TYPE

1✔

6588

// -------------------------------------------------------------------------

1✔

6589

function LFloat(n) {

24,058✔

6590

    if (typeof this !== 'undefined' && !(this instanceof LFloat) ||

24,058✔

6591

        typeof this === 'undefined') {

24,058✔

6592

        return new LFloat(n);

10,887✔

6593

10,887✔

6597

    if (n instanceof LNumber) {

24,058✔

6598

        return LFloat(n.valueOf());

402✔

6599

402✔

6600

    if (typeof n === 'number') {

12,769✔

6601

        if (Object.is(n, -0)) {

12,769✔

6602

            Object.defineProperty(this, '_minus', {

89✔

6603

                value: true

89✔

6604

});

89✔

6605

89✔

6606

        this.constant(n, 'float');

12,769✔

6607

12,769✔

6608

24,058✔

6609

// -------------------------------------------------------------------------

1✔

6610

LFloat.prototype = Object.create(LNumber.prototype);

1✔

6611

LFloat.prototype.constructor = LFloat;

1✔

6612

// -------------------------------------------------------------------------

1✔

6613

LFloat.prototype.toString = function(radix) {

1✔

6614

    if (this.__value__ === Number.NEGATIVE_INFINITY) {

161✔

6615

        return '-inf.0';

7✔

6616

7✔

6617

    if (this.__value__ === Number.POSITIVE_INFINITY) {

161✔

6618

        return '+inf.0';

12✔

6619

12✔

6620

    if (Number.isNaN(this.__value__)) {

161✔

6621

        return '+nan.0';

17✔

6622

17✔

6623

    radix &&= radix.valueOf();

125✔

6624

    var str = this.__value__.toString(radix);

125✔

6625

    if (!str.match(/e[+-]?[0-9]+$/i)) {

161✔

6626

        // compatibility with other scheme implementation

122✔

6627

        // In JavaScript scientific notation starts from 6 zeros

122✔

6628

        // in Kawa and Gauche it starts from 3 zeros

122✔

6629

        const number = str.replace(/^-/, '');

122✔

6630

        const sign = this.__value__ < 0 ? '-' : '';

122✔

6631

        if (str.match(/^-?0\.0{3}/)) {

122✔

6632

            const exponent = number.match(/^[.0]+/g)[0].length - 1;

1✔

6633

            const value = number.replace(/^[.0]+/, '').replace(/^([0-9a-f])/i, '$1.');

1✔

6634

            return `${sign}${value}e-${exponent.toString(radix)}`;

1✔

6635

1✔

6636

        // big numbers need decimal point shift to have on number

121✔

6637

        // before the decimal point

121✔

6638

        if (str.match(/^-?[0-9a-f]{7,}\.?/i)) {

122✔

6639

            const exponent = number.match(/^[0-9a-f]+/ig)[0].length - 1;

3✔

6640

            const value = number

3✔

6641

                  .replace(/\./, '')

3✔

6642

                  .replace(/^([0-9a-f])/i, '$1.')

3✔

6643

                  .replace(/0+$/, '')

3✔

6644

                  .replace(/\.$/, '.0');

3✔

6645

            return `${sign}${value}e+${exponent.toString(radix)}`;

3✔

6646

3✔

6647

        if (!LNumber.isFloat(this.__value__)) {

122✔

6648

            var result = str + '.0';

58✔

6649

            return this._minus ? ('-' + result) : result;

58✔

6650

58✔

6651

122✔

6652

    return str.replace(/^([0-9]+)e/, '$1.0e');

63✔

6653

};

1✔

6654

// -------------------------------------------------------------------------

1✔

6655

LFloat.prototype._op = function(op, n) {

1✔

6656

    if (n instanceof LNumber) {

2,578✔

6657

        n = n.__value__;

2,578✔

6658

2,578✔

6659

    const fn = LNumber._ops[op];

2,578✔

6663

    return LFloat(fn(this.__value__, n), true);

2,578✔

6664

};

1✔

6665

// -------------------------------------------------------------------------

1✔

6666

// same approximation as in guile scheme

1✔

6667

LFloat.prototype.toRational = function(n = null) {

1✔

6668

    if (n === null) {

204✔

6669

        return toRational(this.__value__.valueOf());

204✔

6670

204✔

6672

};

1✔

6673

// -------------------------------------------------------------------------

1✔

6674

LFloat.prototype.sqrt = function() {

1✔

6675

    var value = this.valueOf();

12✔

6676

    if (this.cmp(0) < 0) {

12✔

6677

        var im = LFloat(Math.sqrt(-value));

1✔

6678

        return LComplex({ re: 0, im });

1✔

6679

1✔

6680

    return LFloat(Math.sqrt(value));

11✔

6681

};

1✔

6682

// -------------------------------------------------------------------------

1✔

6683

LFloat.prototype.abs = function() {

1✔

6689

};

1✔

6690

// -------------------------------------------------------------------------

1✔

6691

// ref: https://rosettacode.org/wiki/Convert_decimal_number_to_rational

1✔

6692

// -------------------------------------------------------------------------

1✔

6693

var toRational = approxRatio(1e-10);

1✔

6694

function approxRatio(eps) {

1✔

6695

    return function(n) {

1✔

6696

        const gcde = (e, x, y) => {

204✔

6697

                const _gcd = (a, b) => (b < e ? a : _gcd(b, a % b));

204✔

6698

                if (Number.isNaN(x) || Number.isNaN(y)) {

204✔

6699

                    return NaN;

4✔

6700

4✔

6701

                return _gcd(Math.abs(x), Math.abs(y));

200✔

6702

},

204✔

6704

        return LRational({ num: Math.floor(n / c), denom: Math.floor(1 / c) });

204✔

6705

};

1✔

6706

1✔

6707

// -------------------------------------------------------------------------

1✔

6708

// :: Source: Kawa gnu.math.RatNum.java

1✔

6709

// :: This algorithm is by Alan Bawden. It has been transcribed

1✔

6710

// :: with permission from Kawa copyright M.A. Bothner.

1✔

6711

// :: which was transcribed from from C-Gambit, copyright Marc Feeley.

1✔

6712

// -------------------------------------------------------------------------

1✔

6733

// -------------------------------------------------------------------------

1✔

6747

// -------------------------------------------------------------------------

1✔

6748

function LRational(n, force = false) {

3,232✔

6749

    if (typeof this !== 'undefined' && !(this instanceof LRational) ||

3,232✔

6750

        typeof this === 'undefined') {

3,232✔

6751

        return new LRational(n, force);

1,410✔

6752

1,410✔

6756

    var num, denom;

1,822✔

6760

    } else {

3,232✔

6761

        num = LNumber(n.num);

1,822✔

6762

        denom = LNumber(n.denom);

1,822✔

6763

1,822✔

6764

    if (!force && denom.cmp(0) !== 0) {

3,232✔

6765

        var is_integer = num.op('%', denom).cmp(0) === 0;

1,435✔

6766

        if (is_integer) {

1,435✔

6767

            return LNumber(num.div(denom));

236✔

6768

236✔

6769

1,435✔

6770

    this.constant(num, denom);

1,586✔

6771

3,232✔

6772

// -------------------------------------------------------------------------

1✔

6773

LRational.prototype = Object.create(LNumber.prototype);

1✔

6774

LRational.prototype.constructor = LRational;

1✔

6775

// -------------------------------------------------------------------------

1✔

6776

LRational.prototype.constant = function(num, denom) {

1✔

6777

    enumerable(this, '__num__', num);

1,586✔

6778

    enumerable(this, '__denom__', denom);

1,586✔

6779

    enumerable(this, '__type__', 'rational');

1,586✔

6780

};

1✔

6781

// -------------------------------------------------------------------------

1✔

6782

LRational.prototype.serialize = function() {

1✔

6787

};

1✔

6788

// -------------------------------------------------------------------------

1✔

6789

LRational.prototype.pow = function(n) {

1✔

6790

    if (LNumber.isRational(n)) {

2✔

6791

        // nth root

2✔

6792

        return pow(this.valueOf(), n.valueOf());

2✔

6793

2✔

6811

};

1✔

6812

// -------------------------------------------------------------------------

1✔

6813

LRational.prototype.sqrt = function() {

1✔

6814

    const num = this.__num__.sqrt();

30✔

6815

    const denom = this.__denom__.sqrt();

30✔

6816

    if (num instanceof LFloat || denom instanceof LFloat) {

30✔

6817

        return num.div(denom);

4✔

6818

4✔

6819

    return LRational({ num, denom });

26✔

6820

};

1✔

6821

// -------------------------------------------------------------------------

1✔

6822

LRational.prototype.abs = function() {

1✔

6832

};

1✔

6833

// -------------------------------------------------------------------------

1✔

6834

LRational.prototype.cmp = function(n) {

1✔

6835

    return LNumber(this.valueOf(), true).cmp(n);

503✔

6836

};

1✔

6837

// -------------------------------------------------------------------------

1✔

6838

LRational.prototype.toString = function() {

1✔

6839

    var gcd = this.__num__.gcd(this.__denom__);

76✔

6840

    var num, denom;

76✔

6841

    if (gcd.cmp(1) !== 0) {

76✔

6842

        num = this.__num__.div(gcd);

4✔

6846

        denom = this.__denom__.div(gcd);

4✔

6850

    } else {

76✔

6851

        num = this.__num__;

72✔

6852

        denom = this.__denom__;

72✔

6853

72✔

6854

    const minus = this.cmp(0) < 0;

76✔

6855

    if (minus) {

76✔

6862

    return num.toString() + '/' + denom.toString();

76✔

6863

};

1✔

6864

// -------------------------------------------------------------------------

1✔

6865

LRational.prototype.valueOf = function(exact) {

1✔

6866

    if (this.__denom__.cmp(0) === 0) {

1,012✔

6867

        if (this.__num__.cmp(0) < 0) {

2✔

6868

            return Number.NEGATIVE_INFINITY;

1✔

6869

1✔

6870

        return Number.POSITIVE_INFINITY;

1✔

6871

1✔

6875

    return LFloat(this.__num__.valueOf()).div(this.__denom__.valueOf());

1,010✔

6876

};

1✔

6877

// -------------------------------------------------------------------------

1✔

6878

LRational.prototype.mul = function(n) {

1✔

6879

    if (!(n instanceof LNumber)) {

346✔

6880

        n = LNumber(n); // handle (--> 1/2 (mul 2))

18✔

6881

18✔

6882

    if (LNumber.isRational(n)) {

346✔

6883

        var num = this.__num__.mul(n.__num__);

269✔

6884

        var denom = this.__denom__.mul(n.__denom__);

269✔

6885

        return LRational({ num, denom });

269✔

6886

269✔

6887

    const [a, b] = LNumber.coerce(this, n);

77✔

6888

    return a.mul(b);

77✔

6889

};

1✔

6890

// -------------------------------------------------------------------------

1✔

6891

LRational.prototype.div = function(n) {

1✔

6895

    if (LNumber.isRational(n)) {

65✔

6896

        var num = this.__num__.mul(n.__denom__);

39✔

6897

        var denom = this.__denom__.mul(n.__num__);

39✔

6898

        return LRational({ num, denom });

39✔

6899

39✔

6900

    const [a, b] = LNumber.coerce(this, n);

26✔

6901

    const ret = a.div(b);

26✔

6902

    return ret;

26✔

6903

};

1✔

6904

// -------------------------------------------------------------------------

1✔

6905

LRational.prototype._op = function(op, n) {

1✔

6906

    return this[rev_mapping[op]](n);

187✔

6907

};

1✔

6908

// -------------------------------------------------------------------------

1✔

6909

LRational.prototype.sub = function(n) {

1✔

6910

    if (typeof n === 'undefined') {

80✔

6911

        return this.mul(-1);

18✔

6912

18✔

6916

    if (LNumber.isRational(n)) {

80✔

6917

        var num = n.__num__.sub();

21✔

6918

        var denom = n.__denom__;

21✔

6919

        return this.add(LRational({ num, denom }));

21✔

6920

21✔

6923

    } else {

80✔

6924

        n = n.sub();

41✔

6925

41✔

6926

    const [a, b] = LNumber.coerce(this, n);

41✔

6927

    return a.add(b);

41✔

6928

};

1✔

6929

// -------------------------------------------------------------------------

1✔

6930

LRational.prototype.add = function(n) {

1✔

6931

    if (!(n instanceof LNumber)) {

341✔

6932

        n = LNumber(n); // handle (--> 1/2 (add 1))

1✔

6933

1✔

6934

    if (LNumber.isRational(n)) {

341✔

6935

        const a_denom = this.__denom__;

247✔

6936

        const b_denom = n.__denom__;

247✔

6937

        const a_num = this.__num__;

247✔

6938

        const b_num = n.__num__;

247✔

6939

        let denom, num;

247✔

6940

        if (a_denom !== b_denom) {

247✔

6941

            num = b_denom.mul(a_num).add(b_num.mul(a_denom));

247✔

6942

            denom = a_denom.mul(b_denom);

247✔

6947

        return LRational({ num, denom });

247✔

6948

247✔

6949

    if (LNumber.isFloat(n)) {

341✔

6950

        return LFloat(this.valueOf()).add(n);

18✔

6951

18✔

6952

    const [a, b] = LNumber.coerce(this, n);

76✔

6953

    return a.add(b);

76✔

6954

};

1✔

6955

// -------------------------------------------------------------------------

1✔

6956

function LBigInteger(n, native) {

645,264✔

6957

    if (typeof this !== 'undefined' && !(this instanceof LBigInteger) ||

645,264✔

6958

        typeof this === 'undefined') {

645,264✔

6959

        return new LBigInteger(n, native);

322,632✔

6960

322,632✔

6967

    this.constant(n, 'bigint');

322,632✔

6968

    Object.defineProperty(this, '_native', {

322,632✔

6969

        value: native

322,632✔

6970

});

322,632✔

6971

645,264✔

6972

// -------------------------------------------------------------------------

1✔

6973

LBigInteger.prototype = Object.create(LNumber.prototype);

1✔

6974

LBigInteger.prototype.constructor = LBigInteger;

1✔

6975

// -------------------------------------------------------------------------

1✔

6976

LBigInteger.bn_op = {

1✔

6977

    '+': 'iadd',

1✔

6978

    '-': 'isub',

1✔

6979

    '*': 'imul',

1✔

6980

    '/': 'idiv',

1✔

6981

    '%': 'imod',

1✔

6982

    '|': 'ior',

1✔

6983

    '&': 'iand',

1✔

6984

    '~': 'inot',

1✔

6985

    '<<': 'ishrn',

1✔

6986

    '>>': 'ishln'

1✔

6987

};

1✔

6988

LBigInteger.prototype.serialize = function() {

1✔

6989

    return this.__value__.toString();

3✔

6990

};

1✔

6991

// -------------------------------------------------------------------------

1✔

6992

LBigInteger.prototype._op = function(op, n) {

1✔

7004

    const ret = LNumber._ops[op](this.__value__, n.__value__);

168,448✔

7005

    if (op === '/') {

168,448✔

7006

        var is_integer = this.op('%', n).cmp(0) === 0;

344✔

7007

        if (is_integer) {

344✔

7008

            return LNumber(ret);

267✔

7009

267✔

7010

        return LRational({ num: this, denom: n });

77✔

7011

77✔

7012

    // use native calculation because it's real bigint value

168,103✔

7013

    return LBigInteger(ret, true);

168,103✔

7014

};

1✔

7015

// -------------------------------------------------------------------------

1✔

7016

LBigInteger.prototype.sqrt = function() {

1✔

7017

    var value;

90✔

7018

    var minus = this.cmp(0) < 0;

90✔

7019

    if (LNumber.isNative(this.__value__)) {

90✔

7020

        value = LNumber(Math.sqrt(minus ? -this.valueOf() : this.valueOf()));

90✔

7024

    if (minus) {

90✔

7025

        return LComplex({ re: 0, im: value });

2✔

7026

2✔

7027

    return value;

88✔

7028

};

1✔

7029

// -------------------------------------------------------------------------

1✔

7030

LNumber.NaN = LNumber(NaN);

1✔

7031

LComplex.i = LComplex({ im: 1, re: 0 });

1✔

7032

// -------------------------------------------------------------------------

1✔

7033

// :: Port abstraction - read should be a function that return next line

1✔

7034

// -------------------------------------------------------------------------

1✔

7035

function InputPort(read, env = global_env) {

4✔

7036

    if (typeof this !== 'undefined' && !(this instanceof InputPort) ||

4✔

7037

        typeof this === 'undefined') {

4✔

7038

        return new InputPort(read);

2✔

7039

2✔

7040

    typecheck('InputPort', read, 'function');

2✔

7041

    read_only(this, '__type__', text_port);

2✔

7042

    var parser;

2✔

7043

    Object.defineProperty(this, '__parser__', {

2✔

7044

        enumerable: true,

2✔

7045

        get: function() {

2✔

7046

            return parser;

20✔

7047

},

2✔

7048

        set: function(value) {

2✔

7052

});

2✔

7053

    this._read = read;

2✔

7054

    this._with_parser = this._with_init_parser.bind(this, async () => {

2✔

7055

        if (!this.char_ready()) {

7✔

7056

            const line = await this._read();

3✔

7057

            parser = new Parser({ env });

3✔

7058

            parser.prepare(line);

3✔

7059

3✔

7060

        return this.__parser__;

7✔

7061

});

2✔

7062

    this.char_ready = function() {

2✔

7063

        return !!this.__parser__ && this.__parser__.__lexer__.peek() !== eof;

7✔

7064

};

2✔

7065

    this._make_defaults();

2✔

7066

4✔

7067

InputPort.prototype._make_defaults = function() {

1✔

7068

    this.read = this._with_parser((parser) => {

181✔

7069

        return parser.read_object();

18✔

7070

});

181✔

7071

    this.read_line = this._with_parser((parser) => {

181✔

7072

        return parser.__lexer__.read_line();

7✔

7073

});

181✔

7074

    this.read_char = this._with_parser((parser) => {

181✔

7075

        return parser.__lexer__.read_char();

143✔

7076

});

181✔

7077

    this.read_string = this._with_parser((parser, number) => {

181✔

7082

        return parser.__lexer__.read_string(number.valueOf());

3✔

7083

});

181✔

7084

    this.peek_char = this._with_parser((parser) => {

181✔

7085

        return parser.__lexer__.peek_char();

19✔

7086

});

181✔

7087

};

1✔

7088

InputPort.prototype._with_init_parser = function(make_parser, fn) {

1✔

7089

    var self = this;

905✔

7090

    return async function(...args) {

905✔

7091

        var parser = await make_parser.call(self);

190✔

7092

        return fn(parser, ...args);

190✔

7093

};

905✔

7094

};

1✔

7095

InputPort.prototype.is_open = function() {

1✔

7096

    return this._with_parser !== null;

4✔

7097

};

1✔

7098

InputPort.prototype.close = function() {

1✔

7099

    this.__parser__ = null;

9✔

7100

    // make content garbage collected, we assign null,

9✔

7101

    // because the value is in prototype

9✔

7102

    this._with_parser = null;

9✔

7103

    ['read', 'close', 'read_char', 'peek-char', 'read_line'].forEach(name => {

9✔

7104

        this[name] = function() {

45✔

7105

            throw new Error('input-port: port is closed');

3✔

7106

};

45✔

7107

});

9✔

7108

    this.char_ready = function() {

9✔

7110

};

9✔

7111

};

1✔

7112

InputPort.prototype.toString = function() {

1✔

7113

    return '#<input-port>';

1✔

7114

};

1✔

7115

// -------------------------------------------------------------------------

1✔

7116

function OutputPort(write) {

2✔

7117

    if (typeof this !== 'undefined' && !(this instanceof OutputPort) ||

2✔

7121

    typecheck('OutputPort', write, 'function');

2✔

7122

    read_only(this, '__type__', text_port);

2✔

7123

    this.write = write;

2✔

7124

2✔

7125

OutputPort.prototype.is_open = function() {

1✔

7126

    return this._closed !== true;

4✔

7127

};

1✔

7128

OutputPort.prototype.close = function() {

1✔

7129

    Object.defineProperty(this, '_closed', {

10✔

7130

        get: () => true,

10✔

7131

        set: () => {},

10✔

7132

        configurable: false,

10✔

7133

        enumerable: false

10✔

7134

});

10✔

7135

    this.write = function() {

10✔

7136

        throw new Error('output-port: port is closed');

4✔

7137

};

10✔

7138

};

1✔

7139

OutputPort.prototype.flush = function() {

1✔

7141

};

1✔

7142

OutputPort.prototype.toString = function() {

1✔

7144

};

1✔

7145

// -------------------------------------------------------------------------

1✔

7146

class BufferedOutputPort extends OutputPort {

1✔

7147

    constructor(fn) {

1✔

7148

        super((...args) => this._write(...args));

2✔

7149

        typecheck('BufferedOutputPort', fn, 'function');

2✔

7150

        read_only(this, '_fn', fn, { hidden: true });

2✔

7151

        read_only(this, '_buffer', [], { hidden: true });

2✔

7152

2✔

7153

    flush() {

1✔

7154

        if (this._buffer.length) {

1✔

7155

            this._fn(this._buffer.join(''));

1✔

7156

            this._buffer.length = 0;

1✔

7157

1✔

7158

1✔

7159

    _write(...args) {

1✔

7160

        if (args.length) {

1✔

7161

            args.forEach(arg => {

1✔

7162

                this._buffer.push(arg);

1✔

7163

});

1✔

7164

            const last_value = this._buffer[this._buffer.length - 1];

1✔

7165

            if (last_value.match(/\n$/)) {

1✔

7166

                this._buffer[this._buffer.length - 1] = last_value.replace(/\n$/, '');

1✔

7167

                this.flush();

1✔

7168

1✔

7169

1✔

7170

1✔

7171

1✔

7172

// -------------------------------------------------------------------------

1✔

7173

function OutputStringPort(toString) {

23✔

7174

    if (typeof this !== 'undefined' && !(this instanceof OutputStringPort) ||

23✔

7178

    typecheck('OutputStringPort', toString, 'function');

23✔

7179

    read_only(this, '__type__', text_port);

23✔

7180

    read_only(this, '__buffer__', []);

23✔

7181

    this.write = (x) => {

23✔

7184

        } else {

34✔

7185

            x = x.valueOf();

34✔

7186

34✔

7187

        this.__buffer__.push(x);

34✔

7188

};

23✔

7189

23✔

7190

OutputStringPort.prototype = Object.create(OutputPort.prototype);

1✔

7191

OutputStringPort.prototype.constructor = OutputStringPort;

1✔

7192

OutputStringPort.prototype.toString = function() {

1✔

7194

};

1✔

7195

OutputStringPort.prototype.valueOf = function() {

1✔

7196

    return this.__buffer__.map(x => x.valueOf()).join('');

22✔

7197

};

1✔

7198

// -------------------------------------------------------------------------

1✔

7199

function OutputFilePort(filename, fd) {

12✔

7200

    if (typeof this !== 'undefined' && !(this instanceof OutputFilePort) ||

12✔

7201

        typeof this === 'undefined') {

12✔

7202

        return new OutputFilePort(filename, fd);

6✔

7203

6✔

7204

    typecheck('OutputFilePort', filename, 'string');

6✔

7205

    read_only(this, '__filename__', filename);

6✔

7206

    read_only(this, '_fd', fd.valueOf(), { hidden: true });

6✔

7207

    read_only(this, '__type__', text_port);

6✔

7208

    this.write = (x) => {

6✔

7211

        } else {

17✔

7212

            x = x.valueOf();

17✔

7213

17✔

7214

        this.fs().write(this._fd, x, function(err) {

17✔

7218

});

17✔

7219

};

6✔

7220

12✔

7221

OutputFilePort.prototype = Object.create(OutputPort.prototype);

1✔

7222

OutputFilePort.prototype.constructor = OutputFilePort;

1✔

7223

OutputFilePort.prototype.fs = function() {

1✔

7224

    if (!this._fs) {

24✔

7225

        this._fs = this.internal('fs');

7✔

7226

7✔

7227

    return this._fs;

24✔

7228

};

1✔

7229

OutputFilePort.prototype.internal = function(name) {

1✔

7230

    return user_env.get('**internal-env**').get(name);

8✔

7231

};

1✔

7232

OutputFilePort.prototype.close = function() {

1✔

7233

    return new Promise((resolve, reject) => {

7✔

7234

        this.fs().close(this._fd, (err) => {

7✔

7237

            } else {

7✔

7238

                read_only(this, '_fd', null, { hidden: true });

7✔

7239

                OutputPort.prototype.close.call(this);

7✔

7240

                resolve();

7✔

7241

7✔

7242

});

7✔

7243

});

7✔

7244

};

1✔

7245

OutputFilePort.prototype.toString = function() {

1✔

7247

};

1✔

7248

// -------------------------------------------------------------------------

1✔

7249

function InputStringPort(string, env = global_env) {

22✔

7250

    if (typeof this !== 'undefined' && !(this instanceof InputStringPort) ||

22✔

7254

    typecheck('InputStringPort', string, 'string');

22✔

7255

    string = string.valueOf();

22✔

7256

    this._with_parser = this._with_init_parser.bind(this, () => {

22✔

7257

        if (!this.__parser__) {

44✔

7258

            this.__parser__ = new Parser({ env });

16✔

7259

            this.__parser__.prepare(string);

16✔

7260

16✔

7261

        return this.__parser__;

44✔

7262

});

22✔

7263

    read_only(this, '__type__', text_port);

22✔

7264

    this._make_defaults();

22✔

7265

22✔

7266

InputStringPort.prototype.char_ready = function() {

1✔

7268

};

1✔

7269

InputStringPort.prototype = Object.create(InputPort.prototype);

1✔

7270

InputStringPort.prototype.constructor = InputStringPort;

1✔

7271

InputStringPort.prototype.toString = function() {

1✔

7272

    return `#<input-port (string)>`;

2✔

7273

};

1✔

7274

// -------------------------------------------------------------------------

1✔

7275

function ParserInputPort(parser, env = global_env) {

157✔

7276

    if (typeof this !== 'undefined' && !(this instanceof ParserInputPort) ||

157✔

7280

    this._with_parser = this._with_init_parser.bind(this, () => {

157✔

7281

        return parser;

139✔

7282

});

157✔

7283

    read_only(this, '__type__', text_port);

157✔

7284

    this._make_defaults();

157✔

7285

157✔

7286

1✔

7287

ParserInputPort.prototype.char_ready = function() {

1✔

7289

};

1✔

7290

ParserInputPort.prototype = Object.create(InputPort.prototype);

1✔

7291

ParserInputPort.prototype.constructor = ParserInputPort;

1✔

7292

ParserInputPort.prototype.toString = function() {

1✔

7294

};

1✔

7295

// -------------------------------------------------------------------------

1✔

7296

function InputByteVectorPort(bytevectors) {

9✔

7297

    if (typeof this !== 'undefined' && !(this instanceof InputByteVectorPort) ||

9✔

7301

    typecheck('InputByteVectorPort', bytevectors, 'uint8array');

9✔

7302

    read_only(this, '__vector__', bytevectors);

9✔

7303

    read_only(this, '__type__', binary_port);

9✔

7304

    var index = 0;

9✔

7305

    Object.defineProperty(this, '__index__', {

9✔

7306

        enumerable: true,

9✔

7307

        get: function() {

9✔

7308

            return index;

292✔

7309

},

9✔

7310

        set: function(value) {

9✔

7311

            typecheck('InputByteVectorPort::__index__', value, 'number');

46✔

7322

            index = value;

46✔

7323

46✔

7324

});

9✔

7325

9✔

7326

InputByteVectorPort.prototype = Object.create(InputPort.prototype);

1✔

7327

InputByteVectorPort.prototype.constructor = InputByteVectorPort;

1✔

7328

InputByteVectorPort.prototype.toString = function() {

1✔

7329

    return `#<input-port (bytevector)>`;

1✔

7330

};

1✔

7331

InputByteVectorPort.prototype.close = function() {

1✔

7332

    read_only(this, '__vector__', nil);

4✔

7333

    const err = function() {

4✔

7334

        throw new Error('Input-binary-port: port is closed');

1✔

7335

};

4✔

7336

    ['read_u8', 'close', 'peek_u8', 'read_u8_vector'].forEach(name => {

4✔

7337

        this[name] = err;

16✔

7338

});

4✔

7339

    this.u8_ready = this.char_ready = function() {

4✔

7340

        return false;

2✔

7341

};

4✔

7342

};

1✔

7343

InputByteVectorPort.prototype.u8_ready = function() {

1✔

7345

};

1✔

7346

InputByteVectorPort.prototype.peek_u8 = function() {

1✔

7347

    if (this.__index__ >= this.__vector__.length) {

99✔

7348

        return eof;

4✔

7349

4✔

7350

    return this.__vector__[this.__index__];

95✔

7351

};

1✔

7352

InputByteVectorPort.prototype.skip = function() {

1✔

7353

    if (this.__index__ <= this.__vector__.length) {

46✔

7354

        ++this.__index__;

46✔

7355

46✔

7356

};

1✔

7357

InputByteVectorPort.prototype.read_u8 = function() {

1✔

7358

    const byte = this.peek_u8();

46✔

7359

    this.skip();

46✔

7360

    return byte;

46✔

7361

};

1✔

7362

InputByteVectorPort.prototype.read_u8_vector = function(len) {

1✔

7363

    if (typeof len === 'undefined') {

3✔

7364

        len = this.__vector__.length;

1✔

7365

    } else if (len > this.__index__ + this.__vector__.length) {

3✔

7366

        len = this.__index__ + this.__vector__.length;

1✔

7367

1✔

7371

    return this.__vector__.slice(this.__index__, len);

3✔

7372

};

1✔

7373

// -------------------------------------------------------------------------

1✔

7374

function OutputByteVectorPort() {

1✔

7375

    if (typeof this !== 'undefined' && !(this instanceof OutputByteVectorPort) ||

1✔

7379

    read_only(this, '__type__', binary_port);

1✔

7380

    read_only(this, '_buffer', [], { hidden: true });

1✔

7381

    this.write = function(x) {

1✔

7382

        typecheck('write', x, ['number', 'uint8array']);

7✔

7383

        if (LNumber.isNumber(x)) {

7✔

7384

            this._buffer.push(x.valueOf());

6✔

7385

        } else {

7✔

7386

            this._buffer.push(...Array.from(x));

1✔

7387

1✔

7388

};

1✔

7389

    Object.defineProperty(this, '__buffer__', {

1✔

7390

        enumerable: true,

1✔

7391

        get: function() {

1✔

7392

            return Uint8Array.from(this._buffer);

2✔

7393

2✔

7394

});

1✔

7395

1✔

7396

OutputByteVectorPort.prototype = Object.create(OutputPort.prototype);

1✔

7397

OutputByteVectorPort.prototype.constructor = OutputByteVectorPort;

1✔

7398

OutputByteVectorPort.prototype.close = function() {

1✔

7399

    OutputPort.prototype.close.call(this);

1✔

7400

    read_only(this, '_buffer', null, { hidden: true });

1✔

7401

};

1✔

7402

OutputByteVectorPort.prototype._close_guard = function() {

1✔

7406

};

1✔

7407

OutputByteVectorPort.prototype.write_u8 = function(byte) {

1✔

7408

    typecheck('OutputByteVectorPort::write_u8', byte, 'number');

7✔

7409

    this.write(byte);

7✔

7410

};

1✔

7411

OutputByteVectorPort.prototype.write_u8_vector = function(vector) {

1✔

7412

    typecheck('OutputByteVectorPort::write_u8_vector', vector, 'uint8array');

1✔

7413

    this.write(vector);

1✔

7414

};

1✔

7415

OutputByteVectorPort.prototype.toString = function() {

1✔

7417

};

1✔

7418

OutputByteVectorPort.prototype.valueOf = function() {

1✔

7419

    return this.__buffer__;

2✔

7420

};

1✔

7421

// -------------------------------------------------------------------------

1✔

7422

function InputFilePort(content, filename) {

12✔

7423

    if (typeof this !== 'undefined' && !(this instanceof InputFilePort) ||

12✔

7427

    InputStringPort.call(this, content);

12✔

7428

    typecheck('InputFilePort', filename, 'string');

12✔

7429

    read_only(this, '__filename__', filename);

12✔

7430

12✔

7431

InputFilePort.prototype = Object.create(InputStringPort.prototype);

1✔

7432

InputFilePort.prototype.constructor = InputFilePort;

1✔

7433

InputFilePort.prototype.toString = function() {

1✔

7434

    return `#<input-port (${this.__filename__})>`;

2✔

7435

};

1✔

7436

// -------------------------------------------------------------------------

1✔

7437

function InputBinaryFilePort(content, filename) {

3✔

7438

    if (typeof this !== 'undefined' && !(this instanceof InputBinaryFilePort) ||

3✔

7442

    InputByteVectorPort.call(this, content);

3✔

7443

    typecheck('InputBinaryFilePort', filename, 'string');

3✔

7444

    read_only(this, '__filename__', filename);

3✔

7445

3✔

7446

InputBinaryFilePort.prototype = Object.create(InputByteVectorPort.prototype);

1✔

7447

InputBinaryFilePort.prototype.constructor = InputBinaryFilePort;

1✔

7448

InputBinaryFilePort.prototype.toString = function() {

1✔

7449

    return `#<input-binary-port (${this.__filename__})>`;

1✔

7450

};

1✔

7451

// -------------------------------------------------------------------------

1✔

7452

function OutputBinaryFilePort(filename, fd) {

2✔

7453

    if (typeof this !== 'undefined' && !(this instanceof OutputBinaryFilePort) ||

2✔

7454

        typeof this === 'undefined') {

2✔

7455

        return new OutputBinaryFilePort(filename, fd);

1✔

7456

1✔

7457

    typecheck('OutputBinaryFilePort', filename, 'string');

1✔

7458

    read_only(this, '__filename__', filename);

1✔

7459

    read_only(this, '_fd', fd.valueOf(), { hidden: true });

1✔

7460

    read_only(this, '__type__', binary_port);

1✔

7461

    let fs;

1✔

7462

    this.write = (x) => {

1✔

7463

        typecheck('write', x, ['number', 'uint8array']);

1✔

7464

        let buffer;

1✔

7465

        if (!fs) {

1✔

7466

            fs = this.internal('fs');

1✔

7467

1✔

7470

        } else {

1✔

7471

            buffer = new Uint8Array(Array.from(x));

1✔

7472

1✔

7473

        return new Promise((resolve, reject) => {

1✔

7474

            fs.write(this._fd, buffer, function(err) {

1✔

7477

                } else {

1✔

7478

                    resolve();

1✔

7479

1✔

7480

});

1✔

7481

});

1✔

7482

};

1✔

7483

2✔

7484

OutputBinaryFilePort.prototype = Object.create(OutputFilePort.prototype);

1✔

7485

OutputBinaryFilePort.prototype.constructor = OutputBinaryFilePort;

1✔

7486

OutputBinaryFilePort.prototype.write_u8 = function(byte) {

1✔

7487

    typecheck('OutputByteVectorPort::write_u8', byte, 'number');

1✔

7488

    this.write(byte);

1✔

7489

};

1✔

7490

OutputBinaryFilePort.prototype.write_u8_vector = function(vector) {

1✔

7491

    typecheck('OutputByteVectorPort::write_u8_vector', vector, 'uint8array');

1✔

7492

    this.write(vector);

1✔

7493

};

1✔

7494

// -------------------------------------------------------------------------

1✔

7495

const binary_port = Symbol.for('binary');

1✔

7496

const text_port = Symbol.for('text');

1✔

7497

var eof = new EOF();

1✔

7498

function EOF() {}

1✔

7499

EOF.prototype.toString = function() {

1✔

7501

};

1✔

7502

// -------------------------------------------------------------------------

1✔

7503

// Simpler way to create interpreter with interaction-environment

1✔

7504

// -------------------------------------------------------------------------

1✔

7533

// -------------------------------------------------------------------------

1✔

7534

Interpreter.prototype.exec = async function(arg, options = {}) {

1✔

7557

};

1✔

7558

// -------------------------------------------------------------------------

1✔

7559

Interpreter.prototype.get = function(value) {

1✔

7568

};

1✔

7569

// -------------------------------------------------------------------------

1✔

7570

Interpreter.prototype.set = function(name, value) {

1✔

7572

};

1✔

7573

// -------------------------------------------------------------------------

1✔

7574

Interpreter.prototype.constant = function(name, value) {

1✔

7576

};

1✔

7577

// -------------------------------------------------------------------------

1✔

7578

// Lips Exception used in error function

1✔

7579

// -------------------------------------------------------------------------

1✔

7580

function LipsError(message, args) {

3✔

7581

    this.name = 'LipsError';

3✔

7582

    this.message = message;

3✔

7583

    this.args = args;

3✔

7584

    this.stack = (new Error()).stack;

3✔

7585

3✔

7586

LipsError.prototype = new Error();

1✔

7587

LipsError.prototype.constructor = LipsError;

1✔

7588

// -------------------------------------------------------------------------

1✔

7589

// :: Fake exception to handle try catch to break the execution

1✔

7590

// :: of body expression #163

1✔

7591

// -------------------------------------------------------------------------

1✔

7592

class IgnoreException extends Error { }

1✔

7593

// -------------------------------------------------------------------------

1✔

7594

// :: Environment constructor (parent and name arguments are optional)

1✔

7595

// -------------------------------------------------------------------------

1✔

7596

function Environment(obj, parent, name) {

8,065,861✔

7607

    this.__docs__ = new Map();

8,065,861✔

7608

    this.__env__ = obj;

8,065,861✔

7609

    this.__parent__ = parent;

8,065,861✔

7611

8,065,861✔

7612

// -------------------------------------------------------------------------

1✔

7613

Environment.prototype.list = function() {

1✔

7615

};

1✔

7616

// -------------------------------------------------------------------------

1✔

7617

Environment.prototype.fs = function() {

1✔

7619

};

1✔

7620

// -------------------------------------------------------------------------

1✔

7621

Environment.prototype.unset = function(name) {

1✔

7629

};

1✔

7630

// -------------------------------------------------------------------------

1✔

7631

Environment.prototype.inherit = function(name, obj = {}) {

1✔

7639

};

1✔

7640

// -------------------------------------------------------------------------

1✔

7641

// :: Lookup function for variable doc strings

1✔

7642

// -------------------------------------------------------------------------

1✔

7643

Environment.prototype.doc = function(name, value = null, dump = false) {

1✔

7650

    if (value) {

16✔

7651

        if (!dump) {

16✔

7652

            value = trim_lines(value);

2✔

7653

2✔

7654

        this.__docs__.set(name, value);

16✔

7655

        return this;

16✔

7656

16✔

7663

};

1✔

7664

// -------------------------------------------------------------------------

1✔

7665

// :: Function creates frame environment for usage in functions

1✔

7666

// :: frames are used to it's easier to find environments of the functions

1✔

7667

// :: in scope chain, they are dummy environments just for lookup

1✔

7668

// -------------------------------------------------------------------------

1✔

7669

Environment.prototype.new_frame = function(fn, args) {

1✔

7670

    var frame = this.inherit('__frame__');

5,568,023✔

7671

    frame.set('parent.frame', doc('parent.frame', function(n = 1) {

5,568,023✔

7672

        n = n.valueOf();

19✔

7673

        var scope = frame.__parent__;

19✔

7677

        if (n <= 0) {

19✔

7678

            return scope;

14✔

7679

14✔

7680

        var parent_frame = scope.get('parent.frame');

5✔

7681

        return parent_frame(n - 1);

5✔

7682

    }, global_env.__env__['parent.frame'].__doc__));

5,568,023✔

7683

    args.callee = fn;

5,568,023✔

7684

    frame.set('arguments', args);

5,568,023✔

7685

    return frame;

5,568,023✔

7686

};

1✔

7687

// -------------------------------------------------------------------------

1✔

7688

Environment.prototype._lookup = function(symbol) {

1✔

7689

    if (symbol instanceof LSymbol) {

132,499,946✔

7690

        symbol = symbol.__name__;

9✔

7691

9✔

7695

    if (this.__env__.hasOwnProperty(symbol)) {

132,499,946✔

7696

        return Value(this.__env__[symbol]);

14,541,296✔

7697

14,541,296✔

7698

    if (this.__parent__) {

132,499,946✔

7699

        return this.__parent__._lookup(symbol);

111,433,468✔

7700

111,433,468✔

7701

};

1✔

7702

// -------------------------------------------------------------------------

1✔

7703

Environment.prototype.toString = function() {

1✔

7705

};

1✔

7706

// -------------------------------------------------------------------------

1✔

7707

Environment.prototype.clone = function() {

1✔

7715

};

1✔

7716

// -------------------------------------------------------------------------

1✔

7717

Environment.prototype.merge = function(env, name = 'merge') {

1✔

7718

    typecheck('Environment::merge', env, 'environment');

484✔

7719

    return this.inherit(name, env.__env__);

484✔

7720

};

1✔

7721

// -------------------------------------------------------------------------

1✔

7722

// Value returned in lookup if found value in env and in promise_all

1✔

7723

// -------------------------------------------------------------------------

1✔

7724

function Value(value) {

29,083,214✔

7725

    if (typeof this !== 'undefined' && !(this instanceof Value) ||

29,083,214✔

7726

        typeof this === 'undefined') {

29,083,214✔

7727

        return new Value(value);

14,541,296✔

7728

14,541,296✔

7729

    this.value = value;

14,541,918✔

7730

29,083,214✔

7731

// -------------------------------------------------------------------------

1✔

7732

Value.isUndefined = function(x) {

1✔

7733

    return x instanceof Value && typeof x.value === 'undefined';

14,409,059✔

7734

};

1✔

7735

// -------------------------------------------------------------------------

1✔

7736

Value.prototype.valueOf = function() {

1✔

7737

    return this.value;

14,540,034✔

7738

};

1✔

7739

// -------------------------------------------------------------------------

1✔

7740

// :: Different object than value used as object for (values)

1✔

7741

// -------------------------------------------------------------------------

1✔

7742

function Values(values) {

61✔

7743

    if (!values.length) {

61✔

7744

        return;

1✔

7745

1✔

7746

    if (values.length === 1) {

61✔

7747

        return values[0];

14✔

7748

14✔

7749

    if (typeof this !== 'undefined' && !(this instanceof Values) ||

61✔

7750

        typeof this === 'undefined') {

61✔

7751

        return new Values(values);

23✔

7752

23✔

7753

    this.__values__ = values;

23✔

7754

61✔

7755

Values.prototype.toString = function() {

1✔

7757

};

1✔

7758

Values.prototype.valueOf = function() {

1✔

7759

    return this.__values__;

19✔

7760

};

1✔

7761

// -------------------------------------------------------------------------

1✔

7762

Environment.prototype.get = function(symbol, options = {}) {

1✔

7763

    // we keep original environment as context for bind

20,822,831✔

7764

    // so print will get user stdout

20,822,831✔

7765

    typecheck('Environment::get', symbol, ['symbol', 'string']);

20,822,831✔

7766

    const { throwError = true } = options;

20,822,831✔

7767

    var name = symbol;

20,822,831✔

7768

    if (name instanceof LSymbol || name instanceof LString) {

20,822,831✔

7769

        name = name.valueOf();

10,025,248✔

7770

10,025,248✔

7771

    var value = this._lookup(name);

20,822,831✔

7772

    if (value instanceof Value) {

20,822,831✔

7773

        if (Value.isUndefined(value)) {

14,409,059✔

7774

            return undefined;

1,884✔

7775

1,884✔

7776

        return patch_value(value.valueOf());

14,407,175✔

7777

14,407,175✔

7778

    var parts;

6,413,772✔

7779

    if (symbol instanceof LSymbol && symbol[LSymbol.object]) {

20,822,831✔

7780

        // dot notation symbols from syntax-rules that are gensyms

9✔

7781

        parts = symbol[LSymbol.object];

9✔

7782

    } else if (typeof name === 'string') {

20,822,831✔

7783

        parts = name.split('.').filter(Boolean);

243,638✔

7784

243,638✔

7785

    if (parts && parts.length > 0) {

20,822,831✔

7786

        var [first, ...rest] = parts;

243,647✔

7787

        value = this._lookup(first);

243,647✔

7788

        if (rest.length) {

243,647✔

7789

            try {

134,642✔

7790

                if (value instanceof Value) {

134,642✔

7791

                    value = value.valueOf();

132,237✔

7792

                } else {

134,642✔

7793

                    value = get(root, first);

2,405✔

7794

                    if (is_function(value)) {

2,405✔

7795

                        value = unbind(value);

2,250✔

7796

2,250✔

7797

2,405✔

7798

                if (typeof value !== 'undefined') {

134,642✔

7799

                    // object accessor

134,632✔

7800

                    return get(value, ...rest);

134,632✔

7801

134,632✔

7808

        value = get(root, name);

109,015✔

7809

109,015✔

7810

    if (typeof value !== 'undefined') {

20,822,831✔

7811

        return value;

338✔

7812

338✔

7813

    if (throwError) {

20,822,831✔

7814

        throw new Error("Unbound variable `" + name.toString() + "'");

17✔

7815

17✔

7816

};

1✔

7817

// -------------------------------------------------------------------------

1✔

7818

Environment.prototype.set = function(name, value, doc = null) {

1✔

7819

    typecheck('Environment::set', name, ['string', 'symbol']);

15,415,262✔

7820

    if (LNumber.isNumber(value)) {

15,415,262✔

7821

        value = LNumber(value);

313,864✔

7822

313,864✔

7823

    if (name instanceof LSymbol) {

15,415,262✔

7824

        name = name.__name__;

2,839,003✔

7825

2,839,003✔

7826

    if (name instanceof LString) {

15,415,262✔

7827

        name = name.valueOf();

12✔

7828

12✔

7829

    this.__env__[name] = value;

15,415,262✔

7830

    if (doc) {

15,415,262✔

7831

        this.doc(name, doc, true);

14✔

7832

14✔

7833

    return this;

15,415,262✔

7834

};

1✔

7835

// -------------------------------------------------------------------------

1✔

7836

// For internal use only

1✔

7837

// -------------------------------------------------------------------------

1✔

7838

Environment.prototype.constant = function(name, value) {

1✔

7847

    } else {

1✔

7848

        enumerable(this.__env__, name, value);

1✔

7849

1✔

7850

    return this;

1✔

7851

};

1✔

7852

// -------------------------------------------------------------------------

1✔

7853

Environment.prototype.has = function(name) {

1✔

7854

    return this.__env__.hasOwnProperty(name);

158,627✔

7855

};

1✔

7856

// -------------------------------------------------------------------------

1✔

7857

Environment.prototype.ref = function(name) {

1✔

7858

    var env = this;

73,807✔

7859

    while (true) {

73,807✔

7860

        if (!env) {

159,981✔

7861

            break;

1,354✔

7862

1,354✔

7863

        if (env.has(name)) {

159,981✔

7864

            return env;

72,453✔

7865

72,453✔

7866

        env = env.__parent__;

86,174✔

7867

86,174✔

7868

};

1✔

7869

// -------------------------------------------------------------------------

1✔

7870

Environment.prototype.parents = function() {

1✔

7878

};

1✔

7879

// -------------------------------------------------------------------------

1✔

7880

// :: Quote function used to pause evaluation from Macro

1✔

7881

// -------------------------------------------------------------------------

1✔

7882

function quote(value) {

2,796,829✔

7886

    if (is_pair(value) || value instanceof LSymbol) {

2,796,829✔

7887

        value[__data__] = true;

2,020,620✔

7888

2,020,620✔

7889

    return value;

2,796,829✔

7890

2,796,829✔

7891

// -------------------------------------------------------------------------

1✔

7892

// :: Unquote is used for multiple backticks and unquote

1✔

7893

// -------------------------------------------------------------------------

1✔

7899

Unquote.prototype.toString = function() {

1✔

7901

};

1✔

7902

// -------------------------------------------------------------------------------

1✔

7903

const native_lambda = _parse(tokenize(`(lambda ()

1✔

7904

                                        "[native code]"

1✔

7905

                                        (throw "Invalid Invocation"))`))[0];

1✔

7906

// -------------------------------------------------------------------------------

1✔

7907

var get = doc('get', function get(object, ...args) {

1✔

7908

    var value;

328,021✔

7909

    var len = args.length;

328,021✔

7910

    while (args.length) {

328,021✔

7911

        // if arg is symbol someone probably want to get __fn__ from binded function

328,057✔

7912

        if (is_function(object) && typeof args[0] !== 'symbol') {

328,057✔

7913

            object = unbind(object);

2,315✔

7914

2,315✔

7915

        var arg = args.shift();

328,057✔

7916

        var name = unbox(arg);

328,057✔

7917

        // the value was set to false to prevent resolving

328,057✔

7918

        // by Real Promises #153

328,057✔

7919

        if (name === 'then' && object instanceof QuotedPromise) {

328,057✔

7920

            value = QuotedPromise.prototype.then;

4✔

7924

        } else {

328,053✔

7925

            value = object[name];

328,053✔

7926

328,053✔

7927

        if (typeof value === 'undefined') {

328,057✔

7931

            return value;

108,879✔

7932

        } else {

328,057✔

7933

            var context;

219,178✔

7934

            if (args.length - 1 < len) {

219,178✔

7935

                context = object;

219,178✔

7936

219,178✔

7937

            value = patch_value(value, context);

219,178✔

7938

219,178✔

7939

        object = value;

219,178✔

7940

219,178✔

7941

    return value;

219,142✔

7942

}, `(. obj . args)

1✔

7943

    (get obj . args)

1✔

7944

1✔

7945

    This function uses an object as a base and keeps using arguments to get the

1✔

7946

    property of JavaScript object. Arguments need to be a strings.

1✔

7947

    e.g. \`(. console "log")\` if you use any function inside LIPS it

1✔

7948

    will be weakly bound (can be rebound), so you can call this log function

1✔

7949

    without problem unlike in JavaScript when you use

1✔

7950

    \`var log = console.log\`.

1✔

7951

    \`get\` is an alias because . doesn't work everywhere, e.g. you can't

1✔

7952

    pass it as an argument.`);

1✔

7953

// -------------------------------------------------------------------------

1✔

7954

// Function gets internal protected data

1✔

7955

// -------------------------------------------------------------------------

1✔

7956

function get_internal(env) {

307✔

7957

    return interaction(env, '**internal-env**');

307✔

7958

307✔

7959

// -------------------------------------------------------------------------

1✔

7960

function internal(env, name) {

150✔

7961

    const internal_env = get_internal(env);

150✔

7962

    return internal_env.get(name);

150✔

7963

150✔

7964

// -------------------------------------------------------------------------

1✔

7965

// Get variable from interaction environment

1✔

7966

// -------------------------------------------------------------------------

1✔

7967

function interaction(env, name) {

307✔

7968

    var interaction_env = env.get('**interaction-environment**');

307✔

7969

    return interaction_env.get(name);

307✔

7970

307✔

7971

// -------------------------------------------------------------------------

1✔

7972

var internal_env = new Environment({

1✔

7973

    stdout: new BufferedOutputPort(function(...args) {

1✔

7974

        console.log(...args);

1✔

7975

}),

1✔

7976

    // ------------------------------------------------------------------

1✔

7977

    stderr: new BufferedOutputPort(function(...args) {

1✔

7979

}),

1✔

7980

    'command-line': [],

1✔

7981

    // ------------------------------------------------------------------

1✔

7982

    stdin: InputPort(function() {

1✔

7984

}),

1✔

7985

    // those will be compiled by babel regex plugin

1✔

7986

    'letter-unicode-regex': /\p{L}/u,

1✔

7987

    'numeral-unicode-regex': /\p{N}/u,

1✔

7988

    'space-unicode-regex': /\s/u

1✔

7989

}, undefined, 'internal');

1✔

7990

// ----------------------------------------------------------------------

1✔

7991

const nan = LNumber(NaN);

1✔

7992

const constants = {

1✔

7993

    '#t': true,

1✔

7994

    '#f': false,

1✔

7995

    '#true': true,

1✔

7996

    '#false': false,

1✔

7997

    '+inf.0': Number.POSITIVE_INFINITY,

1✔

7998

    '-inf.0': Number.NEGATIVE_INFINITY,

1✔

7999

    '+nan.0': nan,

1✔

8000

    '-nan.0': nan,

1✔

8001

    ...parsable_contants

1✔

8002

};

1✔

8003

// -------------------------------------------------------------------------

1✔

8004

var global_env = new Environment({

1✔

8005

    eof,

1✔

8006

    undefined, // undefined as parser constant breaks most of the unit tests

1✔

8007

    // ---------------------------------------------------------------------

1✔

8008

    'peek-char': doc('peek-char', function(port = null) {

1✔

8009

        if (port === null) {

19✔

8010

            port = internal(this, 'stdin');

11✔

8011

11✔

8012

        typecheck_text_port('peek-char', port, 'input-port');

19✔

8013

        return port.peek_char();

19✔

8014

    }, `(peek-char port)

1✔

8015

1✔

8016

        This function reads and returns a character from the string

1✔

8017

        port, or, if there is no more data in the string port, it

1✔

8018

        returns an EOF.`),

1✔

8019

    // ------------------------------------------------------------------

1✔

8020

    'read-line': doc('read-line', function(port = null) {

1✔

8021

        if (port === null) {

7✔

8022

            port = internal(this, 'stdin');

1✔

8023

1✔

8024

        typecheck_text_port('read-line', port, 'input-port');

7✔

8025

        return port.read_line();

7✔

8026

    }, `(read-line port)

1✔

8027

1✔

8028

        This function reads and returns the next line from the input

1✔

8029

        port.`),

1✔

8030

    // ------------------------------------------------------------------

1✔

8031

    'read-char': doc('read-char', function(port = null) {

1✔

8032

        if (port === null) {

143✔

8033

            port = internal(this, 'stdin');

136✔

8034

136✔

8035

        typecheck_text_port('read-char', port, 'input-port');

143✔

8036

        return port.read_char();

143✔

8037

    }, `(read-char port)

1✔

8038

1✔

8039

        This function reads and returns the next character from the

1✔

8040

        input port.`),

1✔

8041

    // ------------------------------------------------------------------

1✔

8042

    read: doc('read', async function read(arg = null) {

1✔

8043

        const { env } = this;

21✔

8044

        var port;

21✔

8045

        if (arg === null) {

21✔

8046

            port = internal(env, 'stdin');

1✔

8047

        } else {

21✔

8048

            port = arg;

20✔

8049

20✔

8050

        typecheck_text_port('read', port, 'input-port');

21✔

8051

        return port.read.call(env);

21✔

8052

    }, `(read [port])

1✔

8053

1✔

8054

        This function, if called with a port, it will parse the next

1✔

8055

        item from the port. If called without an input, it will read

1✔

8056

        a string from standard input (using the browser's prompt or

1✔

8057

        a user defined input method) and parse it. This function can be

1✔

8058

        used together with \`eval\` to evaluate code from port.`),

1✔

8059

    // ------------------------------------------------------------------

1✔

8060

    pprint: doc('pprint', function pprint(arg) {

1✔

8068

    }, `(pprint expression)

1✔

8069

1✔

8070

        This function will pretty print its input to stdout. If it is called

1✔

8071

        with a non-list, it will just call the print function on its

1✔

8072

        input.`),

1✔

8073

    // ------------------------------------------------------------------

1✔

8074

    print: doc('print', function print(...args) {

1✔

8084

    }, `(print . args)

1✔

8085

1✔

8086

        This function converts each input into a string and prints

1✔

8087

        the result to the standard output (by default it's the

1✔

8088

        console but it can be defined in user code). This function

1✔

8089

        calls \`(newline)\` after printing each input.`),

1✔

8090

    // ------------------------------------------------------------------

1✔

8091

    format: doc('format', function format(str, ...args) {

1✔

8092

        typecheck('format', str, 'string');

170✔

8093

        const re = /(~[as%~])/g;

170✔

8094

        let m = str.match(/(~[as])/g);

170✔

8098

        var i = 0;

170✔

8099

        var repr = global_env.get('repr');

170✔

8100

        str = str.replace(re, (x) => {

170✔

8101

            const chr = x[1];

228✔

8106

            } else {

228✔

8107

                const arg = args[i++];

228✔

8108

                if (chr === 'a') {

228✔

8109

                    return repr(arg);

228✔

8113

228✔

8114

});

170✔

8115

        m = str.match(/~([\S])/);

170✔

8119

        return str;

170✔

8120

    }, `(format string n1 n2 ...)

1✔

8121

1✔

8122

        This function accepts a string template and replaces any

1✔

8123

        escape sequences in its inputs:

1✔

8124

1✔

8125

        * ~a value as if printed with \`display\`

1✔

8126

        * ~s value as if printed with \`write\`

1✔

8127

        * ~% newline character

1✔

8128

        * ~~ literal tilde '~'

1✔

8129

1✔

8130

        If there are missing inputs or other escape characters it

1✔

8131

        will error.`),

1✔

8132

    // ------------------------------------------------------------------

1✔

8133

    newline: doc('newline', function newline(port = null) {

1✔

8134

        const display = global_env.get('display');

1✔

8135

        const { use_dynamic } = this;

1✔

8136

        const env = global_env;

1✔

8137

        const dynamic_env = global_env;

1✔

8138

        call_function(display, ['\n', port], { env, dynamic_env, use_dynamic });

1✔

8139

    }, `(newline [port])

1✔

8140

1✔

8141

        Write newline character to standard output or given port`),

1✔

8142

    // ------------------------------------------------------------------

1✔

8143

    display: doc('display', function display(arg, port = null) {

1✔

8144

        if (port === null) {

54✔

8145

            port = internal(this, 'stdout');

1✔

8146

        } else {

54✔

8147

            typecheck('display', port, 'output-port');

53✔

8148

53✔

8149

        let value = arg;

54✔

8150

        if (!(port instanceof OutputBinaryFilePort)) {

54✔

8151

            value = global_env.get('repr')(arg);

54✔

8152

54✔

8153

        port.write.call(global_env, value);

54✔

8154

    }, `(display string [port])

1✔

8155

1✔

8156

        This function outputs the string to the standard output or

1✔

8157

        the port if given. No newline.`),

1✔

8158

    // ------------------------------------------------------------------

1✔

8159

    'display-error': doc('display-error', function error(...args) {

1✔

8165

    }, `(display-error . args)

1✔

8166

1✔

8167

        Display an error message on stderr.`),

1✔

8168

    // ------------------------------------------------------------------

1✔

8169

    '%foldcase-string': doc(

1✔

8170

        '%foldcase-string',

1✔

8171

        foldcase_string,

1✔

8172

        `(%foldcase-string string)

1✔

8173

1✔

8174

         Same as string-foldcase but without typechecking`),

1✔

8175

    // ------------------------------------------------------------------

1✔

8176

    '%same-functions': doc('%same-functions', function(a, b) {

1✔

8183

        return unbind(a) === unbind(b);

2✔

8184

    }, `(%same-functions a b)

1✔

8185

1✔

8186

        A helper function that checks if the two input functions are

1✔

8187

        the same.`),

1✔

8188

    // ------------------------------------------------------------------

1✔

8189

    help: doc(new Macro('help', function(code, { dynamic_env, use_dynamic, error }) {

1✔

8217

    }), `(help object)

1✔

8218

1✔

8219

         This macro returns documentation for a function or macro.

1✔

8220

         You can save the function or macro in a variable and use it

1✔

8221

         here. But getting help for a variable requires passing the

1✔

8222

         variable in a \`quote\`.`),

1✔

8223

    // ------------------------------------------------------------------

1✔

8224

    cons: doc('cons', function cons(car, cdr) {

1✔

8225

        return new Pair(car, cdr);

287✔

8226

    }, `(cons left right)

1✔

8227

1✔

8228

        This function returns a new list with the first appended

1✔

8229

        before the second. If the second is not a list cons will

1✔

8230

        return a dotted pair.`),

1✔

8231

    // ------------------------------------------------------------------

1✔

8232

    car: doc('car', function car(list) {

1✔

8233

        typecheck('car', list, 'pair');

213,543✔

8234

        return list.car;

213,543✔

8235

    }, `(car pair)

1✔

8236

1✔

8237

        This function returns the car (item 1) of the list.`),

1✔

8238

    // ------------------------------------------------------------------

1✔

8239

    cdr: doc('cdr', function cdr(list) {

1✔

8240

        typecheck('cdr', list, 'pair');

159,068✔

8241

        return list.cdr;

159,068✔

8242

    }, `(cdr pair)

1✔

8243

1✔

8244

        This function returns the cdr (all but first) of the list.`),

1✔

8245

    // ------------------------------------------------------------------

1✔

8246

    'set!': doc(new Macro('set!', function(code, { use_dynamic, ...rest } = {}) {

1✔

8247

        const dynamic_env = this;

72,557✔

8248

        const env = this;

72,557✔

8249

        let ref;

72,557✔

8250

        const eval_args = { ...rest, env: this, dynamic_env, use_dynamic };

72,557✔

8251

        let value = evaluate(code.cdr.car, eval_args);

72,557✔

8252

        value = resolve_promises(value);

72,557✔

8253

        function set(object, key, value) {

72,557✔

8263

            env.get('set-obj!').call(env, object, key, value);

1,028✔

8264

            return value;

1,028✔

8265

1,028✔

8277

        var symbol = code.car.valueOf();

72,543✔

8278

        ref = this.ref(code.car.__name__);

72,543✔

8279

        // we don't return value because we only care about sync of set value

72,543✔

8280

        // when value is a promise

72,543✔

8281

        return unpromise(value, value => {

72,543✔

8282

            if (!ref) {

72,543✔

8283

                // case (set! fn.toString (lambda () "xxx"))

1,030✔

8284

                var parts = symbol.split('.');

1,030✔

8285

                if (parts.length > 1) {

1,030✔

8286

                    var key = parts.pop();

1,029✔

8287

                    var name = parts.join('.');

1,029✔

8288

                    var obj = this.get(name, { throwError: false });

1,029✔

8289

                    if (obj) {

1,029✔

8290

                        set(obj, key, value);

1,028✔

8291

                        return;

1,028✔

8292

1,028✔

8293

1,029✔

8294

                throw new Error('Unbound variable `' + symbol + '\'');

2✔

8295

2✔

8296

            ref.set(symbol, value);

71,513✔

8297

});

72,543✔

8298

    }), `(set! name value)

1✔

8299

1✔

8300

         Macro that can be used to set the value of the variable or slot (mutate it).

1✔

8301

         set! searches the scope chain until it finds first non empty slot and sets it.`),

1✔

8302

    // ------------------------------------------------------------------

1✔

8303

    'unset!': doc(new Macro('set!', function(code) {

1✔

8308

        const symbol = code.car;

1✔

8309

        var ref = this.ref(symbol);

1✔

8310

        if (ref) {

1✔

8311

            delete ref.__env__[symbol.__name__];

1✔

8312

1✔

8313

    }), `(unset! name)

1✔

8314

1✔

8315

         Function to delete the specified name from environment.

1✔

8316

         Trying to access the name afterwards will error.`),

1✔

8317

    // ------------------------------------------------------------------

1✔

8318

    'set-car!': doc('set-car!', function(slot, value) {

1✔

8319

        typecheck('set-car!', slot, 'pair');

1✔

8320

        slot.car = value;

1✔

8321

    }, `(set-car! obj value)

1✔

8322

1✔

8323

         Function that sets the car (first item) of the list/pair to specified value.

1✔

8324

         The old value is lost.`),

1✔

8325

    // ------------------------------------------------------------------

1✔

8326

    'set-cdr!': doc('set-cdr!', function(slot, value) {

1✔

8327

        typecheck('set-cdr!', slot, 'pair');

7✔

8328

        slot.cdr = value;

7✔

8329

    }, `(set-cdr! obj value)

1✔

8330

1✔

8331

         Function that sets the cdr (tail) of the list/pair to specified value.

1✔

8332

         It will destroy the list. The old tail is lost.`),

1✔

8333

    // ------------------------------------------------------------------

1✔

8334

    'empty?': doc('empty?', function(x) {

1✔

8336

    }, `(empty? object)

1✔

8337

1✔

8338

         Function that returns #t if value is nil (an empty list) or undefined.`),

1✔

8339

    // ------------------------------------------------------------------

1✔

8340

    gensym: doc(

1✔

8341

        'gensym',

1✔

8342

        gensym,

1✔

8343

        `(gensym)

1✔

8344

1✔

8345

         Generates a unique symbol that is not bound anywhere,

1✔

8346

         to use with macros as meta name.`),

1✔

8347

    // ------------------------------------------------------------------

1✔

8348

    load: doc('load', function load(file, env) {

1✔

8349

        typecheck('load', file, 'string');

3✔

8350

        var g_env = this;

3✔

8351

        if (g_env.__name__ === '__frame__') {

3✔

8352

            g_env = g_env.__parent__;

3✔

8353

3✔

8354

        if (!(env instanceof Environment)) {

3✔

8355

            if (g_env === global_env) {

3✔

8356

                // this is used for let-env + load

2✔

8357

                // this may be obsolete when there is env arg

2✔

8358

                env = g_env;

2✔

8359

            } else {

3✔

8360

                env = this.get('**interaction-environment**');

1✔

8361

1✔

8362

3✔

8363

        const package_name = '@lips';

3✔

8364

        const has_package = file.startsWith(package_name);

3✔

8365

        // TODO: move **module-path** to internal env

3✔

8366

        const PATH = '**module-path**';

3✔

8367

        var module_path = global_env.get(PATH, { throwError: false });

3✔

8368

        file = file.valueOf();

3✔

8372

        const IS_BIN = file.match(/\.xcb$/);

3✔

8373

        function run(code) {

3✔

8374

            if (IS_BIN) {

3✔

8375

                code = unserialize_bin(code);

1✔

8376

            } else {

3✔

8377

                if (type(code) === 'buffer') {

2✔

8378

                    code = code.toString();

2✔

8379

2✔

8380

                code = code.replace(/^(#!.*)/, function(_, shebang) {

2✔

8385

});

2✔

8389

2✔

8390

            return exec(code, { env });

3✔

8391

3✔

8392

        function fetch(file) {

3✔

8402

        function get_root_dir() {

3✔

8403

            const __dirname = global_env.get('__dirname');

3✔

8404

            return __dirname.replace(/[^/]+$/, '');

3✔

8405

3✔

8406

        if (is_node()) {

3✔

8407

            return new Promise(async (resolve, reject) => {

3✔

8408

                try {

3✔

8409

                    await node_ready;

3✔

8410

                    const path = nodeRequire('path');

3✔

8411

                    const fs = nodeRequire('fs');

3✔

8412

                    let cwd;

3✔

8413

                    const root_dir = get_root_dir();

3✔

8414

                    if (has_package) {

3✔

8415

                        file = file.replace(package_name, root_dir);

2✔

8416

2✔

8422

                    } else if (!file.startsWith('/')) {

3✔

8423

                        const cmd = g_env.get('command-line', { throwError: false });

1✔

8424

                        let args;

1✔

8425

                        if (cmd) {

1✔

8426

                            args = await cmd();

1✔

8427

1✔

8428

                        if (args && !is_nil(args)) {

1✔

8429

                            cwd = process.cwd();

1✔

8430

                            file = path.join(path.dirname(args.car.valueOf()), file);

1✔

8431

1✔

8432

1✔

8433

                    global_env.set(PATH, path.dirname(file));

3✔

8434

                    fs.readFile(file, function(err, data) {

3✔

8438

                        } else {

3✔

8439

                            try {

3✔

8440

                                run(data).then(() => {

3✔

8441

                                    resolve();

3✔

8442

                                    global_env.set(PATH, module_path);

3✔

8443

                                }).catch(reject);

3✔

8447

3✔

8448

});

3✔

8452

});

3✔

8453

3✔

8472

    }, `(load filename)

1✔

8473

        (load filename environment)

1✔

8474

1✔

8475

        Fetches the file (from disk or network) and evaluates its content as LIPS code.

1✔

8476

        If the second argument is provided and it's an environment the evaluation

1✔

8477

        will happen in that environment.`),

1✔

8478

    // ------------------------------------------------------------------

1✔

8479

    'while': doc(new Macro('while', function(code, args) {

1✔

8480

        const test = code.car;

17,385✔

8481

        const eval_args = { ...args, env: this };

17,385✔

8482

        const body = new Pair(new LSymbol('begin'), code.cdr);

17,385✔

8483

        return (function loop() {

17,385✔

8484

            return unpromise(evaluate(test, eval_args), test => {

43,852✔

8485

                if (test) {

43,852✔

8486

                    return unpromise(evaluate(body, eval_args), loop);

26,467✔

8487

26,467✔

8488

});

43,852✔

8489

        })();

17,385✔

8490

    }), `(while cond body)

1✔

8491

1✔

8492

         Creates a loop, it executes cond and body until cond expression is false.`),

1✔

8493

    // ------------------------------------------------------------------

1✔

8494

    'do': doc(new Macro('do', async function(code, { use_dynamic, error }) {

1✔

8495

        const self = this;

9✔

8496

        const dynamic_env = self;

9✔

8497

        let scope = self.inherit('do');

9✔

8498

        const vars = code.car;

9✔

8499

        const test = code.cdr.car;

9✔

8500

        let body = code.cdr.cdr;

9✔

8501

        if (!is_nil(body)) {

9✔

8502

            body = new Pair(LSymbol('begin'), body);

4✔

8503

4✔

8504

        let eval_args = { env: self, dynamic_env, use_dynamic, error };

9✔

8505

        let node = vars;

9✔

8506

        // init variables

9✔

8507

        while (!is_nil(node)) {

9✔

8508

            const item = node.car;

14✔

8509

            scope.set(item.car, await evaluate(item.cdr.car, eval_args));

14✔

8510

            node = node.cdr;

14✔

8511

14✔

8512

        eval_args = { env: scope, dynamic_env, error };

9✔

8513

        while ((await evaluate(test.car, eval_args)) === false) {

9✔

8514

            if (!is_nil(body)) {

29✔

8515

                await lips.evaluate(body, eval_args);

17✔

8516

16✔

8517

            let node = vars;

28✔

8518

            const next = {};

28✔

8519

            // next value of variables

28✔

8520

            while (!is_nil(node)) {

29✔

8521

                const item = node.car;

40✔

8522

                if (!is_nil(item.cdr.cdr)) {

40✔

8523

                    const value = await evaluate(item.cdr.cdr.car, eval_args);

30✔

8524

                    next[item.car.valueOf()] = value;

30✔

8525

30✔

8526

                node = node.cdr;

40✔

8527

40✔

8528

            const symbols = Object.getOwnPropertySymbols(next);

28✔

8529

            // new scope for new iteration

28✔

8530

            eval_args.env = scope = self.inherit('do');

28✔

8531

            Object.keys(next).concat(symbols).forEach(key => {

28✔

8532

                scope.set(key, next[key]);

30✔

8533

});

28✔

8534

28✔

8535

        if (!is_nil(test.cdr)) {

8✔

8536

            return await evaluate(test.cdr.car, eval_args);

8✔

8537

8✔

8538

    }), `(do ((<var> <init> <next>)) (test return) . body)

1✔

8539

1✔

8540

         Iteration macro that evaluates the expression body in scope of the variables.

1✔

8541

         On each loop it changes the variables according to the <next> expression and runs

1✔

8542

         test to check if the loop should continue. If test is a single value, the macro

1✔

8543

         will return undefined. If the test is a pair of expressions the macro will

1✔

8544

         evaluate and return the second expression after the loop exits.`),

1✔

8545

    // ------------------------------------------------------------------

1✔

8546

    'if': doc(new Macro('if', function(code, { error, use_dynamic }) {

1✔

8547

        const dynamic_env = this;

835,295✔

8548

        const env = this;

835,295✔

8549

        const eval_args = { env, dynamic_env, use_dynamic, error };

835,295✔

8550

        const resolve = (cond) => {

835,295✔

8551

            if (is_false(cond)) {

835,295✔

8552

                return evaluate(code.cdr.cdr.car, eval_args);

457,773✔

8553

            } else {

835,295✔

8554

                return evaluate(code.cdr.car, eval_args);

377,522✔

8555

377,522✔

8556

};

835,295✔

8560

        const cond = evaluate(code.car, eval_args);

835,295✔

8561

        return unpromise(cond, resolve);

835,295✔

8562

    }), `(if cond true-expr false-expr)

1✔

8563

1✔

8564

         Macro that evaluates cond expression and if the value is true, it

1✔

8565

         evaluates and returns true-expression, if not it evaluates and returns

1✔

8566

         false-expression.`),

1✔

8567

    // ------------------------------------------------------------------

1✔

8568

    'let-env': new Macro('let-env', function(code, options = {}) {

1✔

8569

        const { dynamic_env, use_dynamic, error } = options;

39✔

8570

        typecheck('let-env', code, 'pair');

39✔

8571

        const ret = evaluate(code.car, { env: this, dynamic_env, error, use_dynamic });

39✔

8572

        return unpromise(ret, function(value) {

39✔

8573

            typecheck('let-env', value, 'environment');

39✔

8574

            return evaluate(Pair(LSymbol('begin'), code.cdr), {

39✔

8575

                env: value, dynamic_env, error

39✔

8576

});

39✔

8577

});

39✔

8578

    }, `(let-env env . body)

1✔

8579

1✔

8580

        Special macro that evaluates body in context of given environment

1✔

8581

        object.`),

1✔

8582

    // ------------------------------------------------------------------

1✔

8583

    'letrec': doc(

1✔

8584

        let_macro(Symbol.for('letrec')),

1✔

8585

        `(letrec ((a value-a) (b value-b) ...) . body)

1✔

8586

1✔

8587

         Macro that creates a new environment, then evaluates and assigns values to

1✔

8588

         names and then evaluates the body in context of that environment.

1✔

8589

         Values are evaluated sequentially and the next value can access the

1✔

8590

         previous values/names.`),

1✔

8591

    // ---------------------------------------------------------------------

1✔

8592

    'letrec*': doc(

1✔

8593

        let_macro(Symbol.for('letrec')),

1✔

8594

        `(letrec* ((a value-a) (b value-b) ...) . body)

1✔

8595

1✔

8596

         Same as letrec but the order of execution of the binding is guaranteed,

1✔

8597

         so you can use recursive code as well as referencing the previous binding.

1✔

8598

1✔

8599

         In LIPS both letrec and letrec* behave the same.`),

1✔

8600

    // ---------------------------------------------------------------------

1✔

8601

    'let*': doc(

1✔

8602

        let_macro(Symbol.for('let*')),

1✔

8603

        `(let* ((a value-a) (b value-b) ...) . body)

1✔

8604

1✔

8605

         Macro similar to \`let\`, but the subsequent bindings after the first

1✔

8606

         are evaluated in the environment including the previous let variables,

1✔

8607

         so you can define one variable, and use it in the next's definition.`),

1✔

8608

    // ---------------------------------------------------------------------

1✔

8609

    'let': doc(

1✔

8610

        let_macro(Symbol.for('let')),

1✔

8611

        `(let ((a value-a) (b value-b) ...) . body)

1✔

8612

1✔

8613

         Macro that creates a new environment, then evaluates and assigns values to names,

1✔

8614

         and then evaluates the body in context of that environment.  Values are evaluated

1✔

8615

         sequentially but you can't access previous values/names when the next are

1✔

8616

         evaluated. You can only get them in the body of the let expression.  (If you want

1✔

8617

         to define multiple variables and use them in each other's definitions, use

1✔

8618

         \`let*\`.)`),

1✔

8619

    // ------------------------------------------------------------------

1✔

8620

    'begin*': doc(parallel('begin*', function(values) {

1✔

8622

    }), `(begin* . body)

1✔

8623

1✔

8624

         This macro is a parallel version of begin. It evaluates each expression

1✔

8625

         in the body and if it's a promise it will await it in parallel and return

1✔

8626

         the value of the last expression (i.e. it uses Promise.all()).`),

1✔

8627

    // ------------------------------------------------------------------

1✔

8628

    shuffle: doc('shuffle', function(arg) {

1✔

8629

        typecheck('shuffle', arg, ['pair', 'nil', 'array']);

4✔

8630

        const random = global_env.get('random')

4✔

8631

        if (is_nil(arg)) {

4✔

8632

            return nil;

1✔

8633

1✔

8634

        if (Array.isArray(arg)) {

4✔

8635

            return shuffle(arg.slice(), random);

1✔

8636

1✔

8637

        let arr = global_env.get('list->array')(arg);

2✔

8638

        arr = shuffle(arr, random);

2✔

8639

2✔

8640

        return global_env.get('array->list')(arr);

2✔

8641

    }, `(shuffle obj)

1✔

8642

1✔

8643

        Order items in vector or list in random order.`),

1✔

8644

    // ------------------------------------------------------------------

1✔

8645

    begin: doc(new Macro('begin', function(code, options) {

1✔

8646

        const eval_args = {...options, env: this };

1,183,035✔

8647

        const arr = global_env.get('list->array')(code);

1,183,035✔

8648

        let result;

1,183,035✔

8649

        return (function loop() {

1,183,035✔

8650

            if (arr.length) {

2,689,706✔

8651

                const code = arr.shift();

1,506,891✔

8652

                const ret = evaluate(code, eval_args);

1,506,891✔

8653

                return unpromise(ret, value => {

1,506,891✔

8654

                    result = value;

1,506,671✔

8655

                    return loop();

1,506,671✔

8656

});

1,506,891✔

8657

            } else {

2,689,706✔

8658

                return result;

1,182,815✔

8659

1,182,815✔

8660

        })();

1,183,035✔

8661

    }), `(begin . args)

1✔

8662

1✔

8663

         Macro that runs a list of expressions in order and returns the value

1✔

8664

         of the last one. It can be used in places where you can only have a

1✔

8665

         single expression, like (if).`),

1✔

8666

    // ------------------------------------------------------------------

1✔

8667

    'ignore': new Macro('ignore', function(code, options) {

1✔

8668

        const eval_args = { ...options, env: this, dynamic_env: this };

18✔

8669

        evaluate(new Pair(new LSymbol('begin'), code), eval_args);

18✔

8670

    }, `(ignore . body)

1✔

8671

1✔

8672

        Macro that will evaluate the expression and swallow any promises that may

1✔

8673

        be created. It will discard any value that may be returned by the last body

1✔

8674

        expression. The code should have side effects and/or when it's promise

1✔

8675

        it should resolve to undefined.`),

1✔

8676

    // ------------------------------------------------------------------

1✔

8677

    'call/cc': doc(Macro.defmacro('call/cc', function(code, eval_args = {}) {

1✔

8678

        const args = {

12✔

8679

            env: this,

12✔

8680

            ...eval_args

12✔

8681

};

12✔

8682

        return unpromise(evaluate(code.car, args), (result) => {

12✔

8683

            if (is_function(result)) {

12✔

8684

                return result(new Continuation(null));

12✔

8685

12✔

8686

});

12✔

8687

    }), `(call/cc proc)

1✔

8688

1✔

8689

         Call-with-current-continuation.

1✔

8690

1✔

8691

         NOT SUPPORTED BY LIPS RIGHT NOW`),

1✔

8692

    // ------------------------------------------------------------------

1✔

8693

    parameterize: doc(new Macro('parameterize', function(code, options) {

1✔

8694

        const { dynamic_env } = options;

7✔

8695

        const env = dynamic_env.inherit('parameterize').new_frame(null, {});

7✔

8696

        const eval_args = { ...options, env: this };

7✔

8697

        let params = code.car;

7✔

8702

        function next() {

7✔

8703

            const body = new Pair(new LSymbol('begin',), code.cdr);

7✔

8704

            return evaluate(body, { ...eval_args, dynamic_env: env });

7✔

8705

7✔

8706

        return (function loop() {

7✔

8707

            const pair = params.car;

7✔

8708

            const name = pair.car.valueOf();

7✔

8709

            return unpromise(evaluate(pair.cdr.car, eval_args), function(value) {

7✔

8710

                const param = dynamic_env.get(name, { throwError: false });

7✔

8714

                env.set(name, param.inherit(value));

7✔

8718

                } else {

7✔

8719

                    return next();

7✔

8720

7✔

8721

});

7✔

8722

        })();

7✔

8723

    }), `(parameterize ((name value) ...)

1✔

8724

1✔

8725

         Macro that change the dynamic variable created by make-parameter.`),

1✔

8726

    // ------------------------------------------------------------------

1✔

8727

    'make-parameter': doc(new Macro('make-parameter', function(code, eval_args) {

1✔

8728

        const dynamic_env = eval_args.dynamic_env;

6✔

8729

        const init = evaluate(code.car, eval_args);

6✔

8730

        let fn;

6✔

8731

        if (is_pair(code.cdr.car)) {

6✔

8732

            fn = evaluate(code.cdr.car, eval_args);

1✔

8733

1✔

8734

        return new Parameter(init, fn);

6✔

8735

    }), `(make-parameter init converter)

1✔

8736

1✔

8737

    Function creates new dynamic variable that can be custimized with parameterize

1✔

8738

    macro. The value should be assigned to a variable e.g.:

1✔

8739

1✔

8740

    (define radix (make-parameter 10))

1✔

8741

1✔

8742

    The result value is a procedure that return the value of dynamic variable.`),

1✔

8743

    // ------------------------------------------------------------------

1✔

8744

    'define-syntax-parameter': doc(new Macro('define-syntax-parameter', function(code, eval_args) {

1✔

8745

        const name = code.car;

10✔

8746

        const env = this;

10✔

8750

        const syntax = evaluate(code.cdr.car, { env, ...eval_args });

10✔

8751

        typecheck('define-syntax-parameter', syntax, 'syntax', 2);

10✔

8752

        syntax.__name__ = name.valueOf();

10✔

8756

        let __doc__;

10✔

8761

        env.set(code.car, new SyntaxParameter(syntax), __doc__, true);

10✔

8762

    }), `(define-syntax-parameter name syntax [__doc__])

1✔

8763

1✔

8764

         Binds <keyword> to the transformer obtained by evaluating <transformer spec>.

1✔

8765

         The transformer provides the default expansion for the syntax parameter,

1✔

8766

         and in the absence of syntax-parameterize, is functionally equivalent to

1✔

8767

         define-syntax.`),

1✔

8768

    // ------------------------------------------------------------------

1✔

8769

    'syntax-parameterize': doc(new Macro('syntax-parameterize', function(code, eval_args) {

1✔

8770

        const args = global_env.get('list->array')(code.car);

10✔

8771

        const env = this.inherit('syntax-parameterize');

10✔

8772

        while (args.length) {

10✔

8773

            const pair = args.shift();

11✔

8778

            let syntax = evaluate(pair.cdr.car, { ...eval_args, env: this });

11✔

8779

            const name = pair.car;

11✔

8780

            typecheck('syntax-parameterize', syntax, ['syntax']);

11✔

8781

            typecheck('syntax-parameterize', name, 'symbol');

11✔

8782

            syntax.__name__ = name.valueOf();

11✔

8786

            const parameter = new SyntaxParameter(syntax);

11✔

8787

            // used inside syntax-rules

11✔

8788

            if (name.is_gensym()) {

11✔

8789

                const symbol = name.literal();

9✔

8790

                const parent = this.get(symbol, { throwError: false });

9✔

8791

                if (parent instanceof SyntaxParameter) {

9✔

8792

                    // create anaphoric binding for literal symbol

6✔

8793

                    env.set(symbol, parameter);

6✔

8794

6✔

8795

9✔

8796

            env.set(name, parameter);

11✔

8797

11✔

8798

        const expr = hygienic_begin([

10✔

8799

            env, eval_args.dynamic_env

10✔

8800

        ], code.cdr);

10✔

8801

        return evaluate(expr, { ...eval_args, env });

10✔

8802

    }), `(syntax-parameterize (bindings) body)

1✔

8803

1✔

8804

         Macro work similar to let-syntax but the the bindnds will be exposed to the user.

1✔

8805

         With syntax-parameterize you can define anaphoric macros.`),

1✔

8806

    // ------------------------------------------------------------------

1✔

8807

    define: doc(Macro.defmacro('define', function(code, eval_args) {

1✔

8808

        var env = this;

1,254✔

8809

        if (is_pair(code.car) &&

1,254✔

8810

            code.car.car instanceof LSymbol) {

1,254✔

8811

            var new_code = new Pair(

461✔

8812

                new LSymbol("define"),

461✔

8813

                new Pair(

461✔

8814

                    code.car.car,

461✔

8815

                    new Pair(

461✔

8816

                        new Pair(

461✔

8817

                            new LSymbol("lambda"),

461✔

8818

                            new Pair(

461✔

8819

                                code.car.cdr,

461✔

8820

                                code.cdr

461✔

8821

461✔

8822

461✔

8823

461✔

8824

461✔

8825

);

461✔

8826

            return new_code;

461✔

8831

        eval_args.dynamic_env = this;

793✔

8832

        eval_args.env = env;

793✔

8833

        var value = code.cdr.car;

793✔

8834

        let new_expr;

793✔

8835

        if (is_pair(value)) {

1,254✔

8836

            value = evaluate(value, eval_args);

739✔

8837

            new_expr = true;

739✔

8838

        } else if (value instanceof LSymbol) {

1,254✔

8839

            value = env.get(value);

21✔

8840

21✔

8841

        typecheck('define', code.car, 'symbol');

792✔

8842

        return unpromise(value, value => {

792✔

8843

            if (env.__name__ === Syntax.__merge_env__) {

792✔

8844

                env = env.__parent__;

28✔

8845

28✔

8846

            if (new_expr &&

792✔

8847

                ((is_function(value) && is_lambda(value)) ||

738✔

8848

                 (value instanceof Syntax) || is_parameter(value))) {

792✔

8849

                value.__name__ = code.car.valueOf();

655✔

8853

655✔

8854

            let __doc__;

792✔

8855

            if (is_pair(code.cdr.cdr) &&

792✔

8856

                LString.isString(code.cdr.cdr.car)) {

792✔

8857

                __doc__ = code.cdr.cdr.car.valueOf();

14✔

8858

14✔

8859

            env.set(code.car, value, __doc__, true);

792✔

8860

});

792✔

8861

    }), `(define name expression)

1✔

8862

         (define name expression "doc string")

1✔

8863

         (define (function-name . args) . body)

1✔

8864

1✔

8865

         Macro for defining values. It can be used to define variables,

1✔

8866

         or functions. If the first argument is list it will create a function

1✔

8867

         with name being first element of the list. This form expands to

1✔

8868

         \`(define function-name (lambda args body))\``),

1✔

8869

    // ------------------------------------------------------------------

1✔

8870

    'set-obj!': doc('set-obj!', function(obj, key, value, options = null) {

1✔

8871

        var obj_type = typeof obj;

1,367✔

8876

        typecheck('set-obj!', key, ['string', 'symbol', 'number']);

1,367✔

8877

        obj = unbind(obj);

1,367✔

8878

        key = key.valueOf();

1,367✔

8881

        } else if (is_prototype(obj) && is_function(value)) {

1,367✔

8882

            obj[key] = unbind(value);

24✔

8883

            obj[key][__prototype__] = true;

24✔

8884

        } else if (is_function(value) || is_native(value) || is_nil(value)) {

1,367✔

8885

            obj[key] = value;

1,158✔

8886

        } else {

1,343✔

8887

            obj[key] = value && !is_prototype(value) ? value.valueOf() : value;

185✔

8888

185✔

8889

        if (props) {

1,362✔

8890

            const value = obj[key];

1,362✔

8891

            Object.defineProperty(obj, key, { ...options, value });

1,362✔

8892

1,362✔

8893

    }, `(set-obj! obj key value)

1✔

8894

        (set-obj! obj key value props)

1✔

8895

1✔

8896

        Function set a property of a JavaScript object. props should be a vector of pairs,

1✔

8897

        passed to Object.defineProperty.`),

1✔

8898

    // ------------------------------------------------------------------

1✔

8899

    'null-environment': doc('null-environment', function() {

1✔

8901

    }, `(null-environment)

1✔

8902

1✔

8903

        Returns a clean environment with only the standard library.`),

1✔

8904

    // ------------------------------------------------------------------

1✔

8905

    'values': doc('values', function values(...args) {

1✔

8906

        return Values(args);

38✔

8907

    }, `(values a1 a2 ...)

1✔

8908

1✔

8909

        If called with more then one element it will create a special

1✔

8910

        Values object that can be used in the call-with-values function.`),

1✔

8911

    // ------------------------------------------------------------------

1✔

8912

    'call-with-values': doc('call-with-values', function(producer, consumer) {

1✔

8913

        typecheck('call-with-values', producer, 'function', 1);

16✔

8914

        typecheck('call-with-values', consumer, 'function', 2);

16✔

8915

        var maybe = producer.apply(this);

16✔

8916

        if (maybe instanceof Values) {

16✔

8917

            return consumer.apply(this, maybe.valueOf());

14✔

8918

14✔

8919

        return consumer.call(this, maybe);

2✔

8920

    }, `(call-with-values producer consumer)

1✔

8921

1✔

8922

        Calls the producer procedure with no arguments, then calls the

1✔

8923

        consumer procedure with the returned value as an argument -- unless

1✔

8924

        the returned value is a special Values object created by (values), if it is

1✔

8925

        the values are unpacked and the consumer is called with multiple arguments.`),

1✔

8926

    // ------------------------------------------------------------------

1✔

8927

    'current-environment': doc('current-environment', function() {

1✔

8928

        if (this.__name__ === '__frame__') {

29✔

8929

            return this.__parent__;

29✔

8930

29✔

8932

    }, `(current-environment)

1✔

8933

1✔

8934

        Function that returns the current environment (they're first-class objects!)`),

1✔

8935

    // ------------------------------------------------------------------

1✔

8936

    'parent.frame': doc('parent.frame', function() {

1✔

8937

        return user_env;

7✔

8938

    }, `(parent.frame)

1✔

8939

1✔

8940

        Returns the parent environment if called from inside a function.

1✔

8941

        If no parent frame can be found it returns nil.`),

1✔

8942

    // ------------------------------------------------------------------

1✔

8943

    'eval': doc('eval', function(code, env) {

1✔

8944

        env = env || this.get('interaction-environment').call(this);

7✔

8945

        return new Promise((resolve, reject) => {

7✔

8946

            const result = evaluate(code, {

7✔

8947

                env,

7✔

8948

                dynamic_env: env,

7✔

8949

                error: reject

7✔

8950

});

7✔

8951

            resolve(result);

7✔

8952

});

7✔

8953

    }, `(eval expr)

1✔

8954

        (eval expr environment)

1✔

8955

1✔

8956

        Function that evaluates LIPS Scheme code. If the second argument is provided

1✔

8957

        it will be the environment that the code is evaluated in.`),

1✔

8958

    // ------------------------------------------------------------------

1✔

8959

    lambda: new Macro('lambda', function(code, { use_dynamic, error } = {}) {

1✔

8960

        var self = this;

73,703✔

8961

        var __doc__;

73,703✔

8962

        if (is_pair(code.cdr) &&

73,703✔

8963

            LString.isString(code.cdr.car) &&

73,703✔

8964

            !is_nil(code.cdr.cdr)) {

73,703✔

8965

            __doc__ = code.cdr.car.valueOf();

358✔

8966

358✔

8967

        function lambda(...args) {

73,703✔

8968

            // lambda got scopes as context in apply

693,837✔

8969

            let { dynamic_env } = is_context(this) ? this : { dynamic_env: self };

693,837✔

8970

            const env = self.inherit('lambda');

693,837✔

8971

            dynamic_env = dynamic_env.inherit('lambda');

693,837✔

8972

            if (this && !is_context(this)) {

693,837✔

8973

                if (this && !this.__instance__) {

3,060✔

8974

                    Object.defineProperty(this, '__instance__', {

1,033✔

8975

                        enumerable: false,

1,033✔

8976

                        get: () => true,

1,033✔

8977

                        set: () => {},

1,033✔

8978

                        configurable: false

1,033✔

8979

});

1,033✔

8980

1,033✔

8981

                env.set('this', this);

3,060✔

8982

3,060✔

8983

            // arguments and arguments.callee inside lambda function

693,837✔

8984

            if (this instanceof LambdaContext) {

693,837✔

8985

                const options = { throwError: false };

670,783✔

8986

                env.set('arguments', this.env.get('arguments', options));

670,783✔

8987

                env.set('parent.frame', this.env.get('parent.frame', options));

670,783✔

8988

            } else {

693,837✔

8989

                // this case is for lambda as callback function in JS; e.g. setTimeout

23,054✔

8990

                var _args = args.slice();

23,054✔

8991

                _args.callee = lambda;

23,054✔

8992

                _args.env = env;

23,054✔

8993

                env.set('arguments', _args);

23,054✔

8994

23,054✔

8995

            function set(name, value) {

693,837✔

8996

                env.__env__[name.__name__] = value;

698,816✔

8997

                dynamic_env.__env__[name.__name__] = value;

698,816✔

8998

698,816✔

8999

            let name = code.car;

693,837✔

9000

            let i = 0;

693,837✔

9001

            if (name instanceof LSymbol || !is_nil(name)) {

693,837✔

9002

                while (true) {

629,003✔

9003

                    if (!is_nil(name.car)) {

698,816✔

9004

                        if (name instanceof LSymbol) {

698,816✔

9005

                            // rest argument,  can also be first argument

42,297✔

9006

                            const value = quote(Pair.fromArray(args.slice(i), false));

42,297✔

9007

                            set(name, value);

42,297✔

9008

                            break;

42,297✔

9009

                        } else if (is_pair(name)) {

698,816✔

9010

                            const value = args[i];

656,519✔

9011

                            set(name.car, value);

656,519✔

9012

656,519✔

9013

698,816✔

9014

                    if (is_nil(name.cdr)) {

698,816✔

9015

                        break;

586,706✔

9016

586,706✔

9017

                    i++;

69,813✔

9018

                    name = name.cdr;

69,813✔

9019

69,813✔

9020

629,003✔

9021

            var rest = __doc__ ? code.cdr.cdr : code.cdr;

693,837✔

9022

            var output = hygienic_begin([env, dynamic_env], rest);

693,837✔

9023

            const eval_args = {

693,837✔

9024

                env,

693,837✔

9025

                dynamic_env,

693,837✔

9026

                use_dynamic,

693,837✔

9027

                error

693,837✔

9028

693,837✔

9029

            return evaluate(output, eval_args);

693,837✔

9030

693,837✔

9031

        var length = is_pair(code.car) ? code.car.length() : null;

73,703✔

9032

        lambda.__code__ = new Pair(new LSymbol('lambda'), code);

73,703✔

9033

        lambda[__lambda__] = true;

73,703✔

9034

        if (!is_pair(code.car)) {

73,703✔

9035

            return doc(lambda, __doc__, true); // variable arguments

2,204✔

9036

2,204✔

9037

        // wrap and decorate with __doc__

71,499✔

9038

        return doc(set_fn_length(lambda, length), __doc__, true);

71,499✔

9039

    }, `(lambda (a b) body)

1✔

9040

        (lambda args body)

1✔

9041

        (lambda (a b . rest) body)

1✔

9042

1✔

9043

        The lambda macro creates a new anonymous function. If the first element of

1✔

9044

        the body is a string and there is more elements the string is used as the

1✔

9045

        documentation string, that can be read using (help fn).`),

1✔

9046

    // ------------------------------------------------------------------

1✔

9047

    'macroexpand': doc(

1✔

9048

        new Macro('macroexpand', macro_expand()),

1✔

9049

        `(macroexpand expr)

1✔

9050

1✔

9051

         Macro that expand all macros inside and return single expression as output.`),

1✔

9052

    // ------------------------------------------------------------------

1✔

9053

    'macroexpand-1': doc(

1✔

9054

        new Macro('macroexpand-1', macro_expand(true)),

1✔

9055

        `(macroexpand-1 expr)

1✔

9056

1✔

9057

         Macro similar to macroexpand but it expand macros only one level

1✔

9058

         and return single expression as output.`),

1✔

9059

    // ------------------------------------------------------------------

1✔

9060

    'define-macro': doc(new Macro(macro, function(macro, { use_dynamic, error }) {

1✔

9061

        if (is_pair(macro.car) && macro.car.car instanceof LSymbol) {

61✔

9062

            var name = macro.car.car.__name__;

61✔

9063

            var __doc__;

61✔

9064

            if (LString.isString(macro.cdr.car) && is_pair(macro.cdr.cdr)) {

61✔

9065

                __doc__ = macro.cdr.car.valueOf();

39✔

9066

39✔

9067

            var makro_instance = Macro.defmacro(name, function(code) {

61✔

9068

                var env = new Environment({}, this, 'defmacro');

83,498✔

9069

                var name = macro.car.cdr;

83,498✔

9070

                var arg = code;

83,498✔

9071

                while (true) {

83,498✔

9072

                    if (is_nil(name)) {

130,267✔

9073

                        break;

3✔

9074

3✔

9075

                    if (name instanceof LSymbol) {

130,267✔

9076

                        env.__env__[name.__name__] = arg;

81,898✔

9077

                        break;

81,898✔

9078

                    } else if (!is_nil(name.car)) {

130,267✔

9081

                        } else {

48,366✔

9082

                            if (is_pair(arg.car)) {

48,366✔

9083

                                arg.car[__data__] = true;

24,775✔

9084

24,775✔

9085

                            env.__env__[name.car.__name__] = arg.car;

48,366✔

9086

48,366✔

9087

48,366✔

9088

                    if (is_nil(name.cdr)) {

130,267✔

9089

                        break;

1,597✔

9090

1,597✔

9091

                    if (!is_nil(arg)) {

46,769✔

9092

                        arg = arg.cdr;

46,769✔

9093

46,769✔

9094

                    name = name.cdr;

46,769✔

9095

46,769✔

9096

                var eval_args = {

83,498✔

9097

                    env,

83,498✔

9098

                    dynamic_env: env,

83,498✔

9099

                    use_dynamic,

83,498✔

9100

                    error

83,498✔

9101

};

83,498✔

9102

                // evaluate macro

83,498✔

9103

                if (is_pair(macro.cdr)) {

83,498✔

9104

                    // this eval will return lips code

83,498✔

9105

                    var rest = __doc__ ? macro.cdr.cdr : macro.cdr;

83,498✔

9106

                    var result = rest.reduce(function(result, node) {

83,498✔

9107

                        return evaluate(node, eval_args);

83,498✔

9108

});

83,498✔

9109

                    return unpromise(result, function(result) {

83,498✔

9110

                        if (typeof result === 'object') {

83,498✔

9111

                            delete result[__data__];

83,496✔

9112

83,496✔

9113

                        return result;

83,498✔

9114

});

83,498✔

9115

83,498✔

9116

            }, __doc__, true);

61✔

9117

            makro_instance.__code__ = new Pair(new LSymbol('define-macro'), macro);

61✔

9118

            this.set(name, makro_instance);

61✔

9119

61✔

9120

    }), `(define-macro (name . args) body)

1✔

9121

1✔

9122

         The meta-macro, that creates new macros. If the return value is a list structure

1✔

9123

         it will be evaluated where the macro is invoked from. You can use quasiquote \`

1✔

9124

         and unquote , and unquote-splicing ,@ inside to create an expression that will be

1✔

9125

         evaluated at runtime. Macros works like this: if you pass any expression to a

1✔

9126

         macro the arguments will not be evaluated unless the macro's body explicitly

1✔

9127

         calls (eval) on it. Because of this a macro can manipulate the expression

1✔

9128

         (arguments) as lists.`),

1✔

9129

    // ------------------------------------------------------------------

1✔

9130

    'syntax-rules': new Macro('syntax-rules', function(macro, options) {

1✔

9131

        var { use_dynamic, error } = options;

192✔

9132

        // TODO: find identifiers and freeze the scope when defined #172

192✔

9133

        var env = this;

192✔

9134

        function get_identifiers(node) {

192✔

9135

            let symbols = [];

514✔

9136

            while (!is_nil(node)) {

514✔

9137

                const x = node.car;

276✔

9138

                symbols.push(x.valueOf());

276✔

9139

                node = node.cdr;

276✔

9140

276✔

9141

            return symbols;

514✔

9142

514✔

9143

        function validate_identifiers(node) {

192✔

9144

            while (!is_nil(node)) {

192✔

9145

                const x = node.car;

88✔

9149

                node = node.cdr;

88✔

9150

88✔

9151

192✔

9152

        if (macro.car instanceof LSymbol) {

192✔

9153

            validate_identifiers(macro.cdr.car);

12✔

9154

        } else {

192✔

9155

            validate_identifiers(macro.car);

180✔

9156

180✔

9157

        const syntax = new Syntax(function(code, { macro_expand }) {

192✔

9158

            log('>> SYNTAX');

514✔

9159

            log(code);

514✔

9160

            log(macro);

514✔

9161

            const scope = env.inherit('syntax');

514✔

9162

            const dynamic_env = scope;

514✔

9163

            let var_scope = this;

514✔

9164

            // for macros that define variables used in macro (2 levels nestting)

514✔

9165

            if (var_scope.__name__ === Syntax.__merge_env__) {

514✔

9166

                // copy refs for defined gynsyms

133✔

9167

                const props = Object.getOwnPropertySymbols(var_scope.__env__);

133✔

9168

                props.forEach(symbol => {

133✔

9169

                    var_scope.__parent__.set(symbol, var_scope.__env__[symbol]);

173✔

9170

});

133✔

9171

                var_scope = var_scope.__parent__;

133✔

9172

133✔

9173

            var eval_args = { env: scope, dynamic_env, use_dynamic, error };

514✔

9174

            let ellipsis, rules, symbols;

514✔

9175

            if (macro.car instanceof LSymbol) {

514✔

9176

                ellipsis = macro.car;

22✔

9177

                symbols = get_identifiers(macro.cdr.car);

22✔

9178

                rules = macro.cdr.cdr;

22✔

9179

            } else {

514✔

9180

                ellipsis = '...';

492✔

9181

                symbols = get_identifiers(macro.car);

492✔

9182

                rules = macro.cdr;

492✔

9183

492✔

9184

            try {

514✔

9185

                while (!is_nil(rules)) {

514✔

9186

                    var rule = rules.car.car;

1,011✔

9187

                    var expr = rules.car.cdr.car;

1,011✔

9188

                    log('[[[ RULE');

1,011✔

9189

                    log(rule);

1,011✔

9190

                    var bindings = extract_patterns(rule, code, symbols, ellipsis, {

1,011✔

9191

                        expansion: this, define: env

1,011✔

9192

});

1,011✔

9193

                    if (bindings) {

1,011✔

9194

                        /* c8 ignore next 5 */

1✔

9195

                        if (is_debug()) {

1✔

9196

                            console.log(JSON.stringify(symbolize(bindings), true, 2));

1✔

9197

                            console.log('PATTERN: ' + rule.toString(true));

1✔

9198

                            console.log('MACRO: ' + code.toString(true));

1✔

9199

1✔

9200

                        // name is modified in transform_syntax

487✔

9201

                        var names = [];

487✔

9202

                        const new_expr = transform_syntax({

487✔

9203

                            bindings,

487✔

9204

                            expr,

487✔

9205

                            symbols,

487✔

9206

                            scope,

487✔

9207

                            lex_scope: var_scope,

487✔

9208

                            names,

487✔

9209

                            ellipsis

487✔

9210

});

487✔

9211

                        log('OUPUT>>> ', new_expr);

487✔

9212

                        // TODO: if expression is undefined throw an error

487✔

9213

                        if (new_expr) {

487✔

9214

                            expr = new_expr;

481✔

9215

481✔

9216

                        var new_env = var_scope.merge(scope, Syntax.__merge_env__);

484✔

9217

                        if (macro_expand) {

487✔

9218

                            return { expr, scope: new_env };

1✔

9219

1✔

9220

                        var result = evaluate(expr, { ...eval_args, env: new_env });

483✔

9221

                        // Hack: update the result if there are generated

483✔

9222

                        //       gensyms that should be literal symbols

483✔

9223

                        // TODO: maybe not the part move when literal elisps may

483✔

9224

                        //       be generated, maybe they will need to be mark somehow

483✔

9225

                        return clear_gensyms(result, names);

483✔

9226

483✔

9227

                    rules = rules.cdr;

524✔

9228

524✔

9229

            } catch (e) {

514✔

9230

                e.message += `\nin macro:\n  ${macro.toString(true)}`;

9✔

9231

                throw e;

9✔

9232

9✔

9233

            throw new Error(`syntax-rules: no matching syntax in macro ${code.toString(true)}`);

27✔

9234

        }, env);

192✔

9235

        syntax.__code__ = macro;

192✔

9236

        return syntax;

192✔

9237

    }, `(syntax-rules () (pattern expression) ...)

1✔

9238

1✔

9239

        Base of hygienic macros, it will return a new syntax expander

1✔

9240

        that works like Lisp macros.`),

1✔

9241

    // ------------------------------------------------------------------

1✔

9242

    quote: doc(new Macro('quote', function(arg) {

1✔

9243

        return quote(arg.car);

133,504✔

9244

    }), `(quote expression) or 'expression

1✔

9245

1✔

9246

         Macro that returns a single LIPS expression as data (it won't evaluate the

1✔

9247

         argument). It will return a list if put in front of LIPS code.

1✔

9248

         And if put in front of a symbol it will return the symbol itself, not the value

1✔

9249

         bound to that name.`),

1✔

9250

    'unquote-splicing': doc('unquote-splicing', function() {

1✔

9252

    }, `(unquote-splicing code) or ,@code

1✔

9253

1✔

9254

        Special form used in the quasiquote macro. It evaluates the expression inside and

1✔

9255

        splices the list into quasiquote's result. If it is not the last element of the

1✔

9256

        expression, the computed value must be a pair.`),

1✔

9257

    'unquote': doc('unquote', function() {

1✔

9259

    }, `(unquote code) or ,code

1✔

9260

1✔

9261

        Special form used in the quasiquote macro. It evaluates the expression inside and

1✔

9262

        substitutes the value into quasiquote's result.`),

1✔

9263

    // ------------------------------------------------------------------

1✔

9264

    quasiquote: Macro.defmacro('quasiquote', function(arg, env) {

1✔

9265

        const { use_dynamic, error } = env;

330,204✔

9266

        const self = this;

330,204✔

9267

        //var max_unquote = 1;

330,204✔

9268

        const dynamic_env = self;

330,204✔

9269

        // -----------------------------------------------------------------

330,204✔

9270

        function is_struct(value) {

330,204✔

9271

            return is_pair(value) ||

4,595,806✔

9272

                is_plain_object(value) ||

4,595,806✔

9273

                Array.isArray(value);

4,595,806✔

9274

4,595,806✔

9275

        // -----------------------------------------------------------------

330,204✔

9276

        function resolve_pair(pair, fn, test = is_struct) {

330,204✔

9277

            if (is_pair(pair)) {

2,297,903✔

9278

                var car = pair.car;

2,297,903✔

9279

                var cdr = pair.cdr;

2,297,903✔

9280

                if (test(car)) {

2,297,903✔

9281

                    car = fn(car);

1,422,960✔

9282

1,422,960✔

9283

                if (test(cdr)) {

2,297,903✔

9284

                    cdr = fn(cdr);

1,523,240✔

9285

1,523,240✔

9286

                if (is_promise(car) || is_promise(cdr)) {

2,297,903✔

9287

                    return promise_all([car, cdr]).then(([car, cdr]) => {

1✔

9288

                        return new Pair(car, cdr);

1✔

9289

});

1✔

9290

                } else {

2,297,903✔

9291

                    return new Pair(car, cdr);

2,297,902✔

9292

2,297,902✔

9293

2,297,903✔

9295

2,297,903✔

9296

        // -----------------------------------------------------------------

330,204✔

9297

        function join(eval_pair, value) {

330,204✔

9301

            if (is_pair(eval_pair)) {

201,323✔

9302

                if (!is_nil(value)) {

201,323✔

9303

                    eval_pair.append(value);

44,997✔

9304

44,997✔

9311

            return eval_pair;

201,323✔

9312

201,323✔

9313

        // -----------------------------------------------------------------

330,204✔

9314

        function unquoted_arr(arr) {

330,204✔

9315

            return !!arr.filter(value => {

18✔

9316

                return is_pair(value) &&

39✔

9317

                    LSymbol.is(value.car, /^(unquote|unquote-splicing)$/);

39✔

9318

            }).length;

18✔

9319

18✔

9320

        // -----------------------------------------------------------------

330,204✔

9321

        function quote_vector(arr, unquote_cnt, max_unq) {

330,204✔

9322

            return arr.reduce((acc, x) => {

2✔

9323

                if (!is_pair(x)) {

5✔

9324

                    acc.push(x);

1✔

9325

                    return acc;

1✔

9326

1✔

9327

                if (LSymbol.is(x.car, 'unquote-splicing')) {

5✔

9328

                    let result;

1✔

9331

                    } else {

1✔

9332

                        result = evaluate(x.cdr.car, {

1✔

9333

                            env: self,

1✔

9334

                            use_dynamic,

1✔

9335

                            dynamic_env,

1✔

9336

                            error

1✔

9337

});

1✔

9338

1✔

9342

                    return acc.concat(result.to_array());

1✔

9343

1✔

9344

                acc.push(recur(x, unquote_cnt, max_unq));

3✔

9345

                return acc;

3✔

9346

            }, []);

2✔

9347

2✔

9348

        // -----------------------------------------------------------------

330,204✔

9349

        function quote_object(object, unquote_cnt, max_unq) {

330,204✔

9350

            const result = {};

12✔

9351

            unquote_cnt++;

12✔

9352

            Object.keys(object).forEach(key => {

12✔

9353

                const value = object[key];

24✔

9354

                if (is_pair(value)) {

24✔

9359

                    let output;

13✔

9362

                    } else {

13✔

9363

                        output = evaluate(value.cdr.car, {

13✔

9364

                            env: self,

13✔

9365

                            dynamic_env,

13✔

9366

                            use_dynamic,

13✔

9367

                            error

13✔

9368

});

13✔

9369

13✔

9370

                    result[key] = output;

13✔

9371

                } else {

24✔

9372

                    result[key] = value;

11✔

9373

11✔

9374

});

12✔

9378

            return result;

12✔

9379

12✔

9380

        // -----------------------------------------------------------------

330,204✔

9381

        function unquote_splice(pair, unquote_cnt, max_unq) {

330,204✔

9382

            if (unquote_cnt < max_unq) {

205,151✔

9383

                let cdr = nil;

9✔

9384

                if (!is_nil(pair.cdr)) {

9✔

9385

                    cdr = recur(pair.cdr, unquote_cnt - 1, max_unq);

3✔

9386

3✔

9387

                return new Pair(

9✔

9388

                    new Pair(

9✔

9389

                        pair.car.car,

9✔

9390

                        recur(pair.car.cdr, unquote_cnt, max_unq)

9✔

9391

),

9✔

9392

cdr

9✔

9393

);

9✔

9394

9✔

9395

            var lists = [];

205,142✔

9396

            return (function next(node) {

205,142✔

9397

                var value = evaluate(node.car, {

205,146✔

9398

                    env: self,

205,146✔

9399

                    dynamic_env,

205,146✔

9400

                    use_dynamic,

205,146✔

9401

                    error

205,146✔

9402

});

205,146✔

9403

                lists.push(value);

205,146✔

9404

                if (is_pair(node.cdr)) {

205,146✔

9405

                    return next(node.cdr);

4✔

9406

4✔

9407

                return unpromise(lists, function(arr) {

205,142✔

9408

                    if (arr.some(x => !is_pair(x))) {

205,142✔

9409

                        if (is_pair(pair.cdr) &&

3,823✔

9423

                        if (!(is_pair(pair.cdr) && is_nil(arr[0]))) {

3,823✔

9424

                            return arr[0];

3,820✔

9425

3,820✔

9426

3,823✔

9427

                    // don't create Cycles

201,322✔

9428

                    arr = arr.map(eval_pair => {

201,322✔

9429

                        if (splices.has(eval_pair)) {

201,326✔

9430

                            return eval_pair.clone();

8✔

9431

                        } else {

201,326✔

9432

                            splices.add(eval_pair);

201,318✔

9433

                            return eval_pair;

201,318✔

9434

201,318✔

9435

});

201,322✔

9436

                    const value = recur(pair.cdr, 0, 1);

201,322✔

9440

                    return unpromise(value, value => {

201,322✔

9441

                        if (is_nil(arr[0])) {

201,322✔

9442

                            return value;

3✔

9443

3✔

9444

                        if (arr.length === 1) {

201,322✔

9445

                            return join(arr[0], value);

201,316✔

9446

201,316✔

9447

                        var result = arr.reduce((result, eval_pair) => {

3✔

9448

                            return join(result, eval_pair);

4✔

9449

});

3✔

9450

                        return join(result, value);

3✔

9451

});

201,322✔

9452

});

205,142✔

9453

            })(pair.car.cdr);

205,142✔

9454

205,151✔

9455

        // -----------------------------------------------------------------

330,204✔

9456

        var splices = new Set();

330,204✔

9457

        function recur(pair, unquote_cnt, max_unq) {

330,204✔

9458

            if (is_pair(pair)) {

3,484,118✔

9459

                if (is_pair(pair.car)) {

3,327,778✔

9460

                    if (LSymbol.is(pair.car.car, 'unquote-splicing')) {

1,628,113✔

9461

                        return unquote_splice(pair, unquote_cnt + 1, max_unq);

205,146✔

9462

205,146✔

9463

                    if (LSymbol.is(pair.car.car, 'unquote')) {

1,628,113✔

9464

                        // + 2 - one for unquote and one for unquote splicing

773,390✔

9465

                        if (unquote_cnt + 2 === max_unq &&

773,390✔

9466

                            is_pair(pair.car.cdr) &&

773,390✔

9467

                            is_pair(pair.car.cdr.car) &&

773,390✔

9468

                            LSymbol.is(pair.car.cdr.car.car, 'unquote-splicing')) {

773,390✔

9469

                            const rest = pair.car.cdr;

5✔

9470

                            return new Pair(

5✔

9471

                                new Pair(

5✔

9472

                                    new LSymbol('unquote'),

5✔

9473

                                    unquote_splice(rest, unquote_cnt + 2, max_unq)

5✔

9474

),

5✔

9475

nil

5✔

9476

);

5✔

9477

                        } else if (is_pair(pair.car.cdr) &&

773,390✔

9478

                                   !is_nil(pair.car.cdr.cdr)) {

773,385✔

9479

                            if (is_pair(pair.car.cdr.car)) {

4✔

9480

                                // values inside unquote are lists

1✔

9481

                                const result = [];

1✔

9482

                                return (function recur(node) {

1✔

9483

                                    if (is_nil(node)) {

4✔

9484

                                        return Pair.fromArray(result);

1✔

9485

1✔

9486

                                    return unpromise(evaluate(node.car, {

3✔

9487

                                        env: self,

3✔

9488

                                        dynamic_env,

3✔

9489

                                        use_dynamic,

3✔

9490

                                        error

3✔

9491

                                    }), function(next) {

3✔

9492

                                        result.push(next);

3✔

9493

                                        return recur(node.cdr);

3✔

9494

});

3✔

9495

                                })(pair.car.cdr);

1✔

9496

                            } else {

4✔

9497

                                // same as in guile if (unquote 1 2 3) it should be

3✔

9498

                                // spliced - scheme spec say it's unspecify but it

3✔

9499

                                // work like in CL

3✔

9500

                                return pair.car.cdr;

3✔

9501

3✔

9502

4✔

9503

773,390✔

9504

1,628,113✔

9505

                if (LSymbol.is(pair.car, 'quasiquote')) {

3,327,778✔

9506

                    var cdr = recur(pair.cdr, unquote_cnt, max_unq + 1);

23✔

9507

                    return new Pair(pair.car, cdr);

23✔

9508

23✔

9509

                if (LSymbol.is(pair.car, 'quote')) {

3,327,778✔

9510

                    return new Pair(

6,352✔

9511

                        pair.car,

6,352✔

9512

                        recur(pair.cdr, unquote_cnt, max_unq)

6,352✔

9513

);

6,352✔

9514

6,352✔

9515

                if (LSymbol.is(pair.car, 'unquote')) {

3,327,778✔

9516

                    unquote_cnt++;

818,345✔

9517

                    if (unquote_cnt < max_unq) {

818,345✔

9518

                        return new Pair(

14✔

9519

                            new LSymbol('unquote'),

14✔

9520

                            recur(pair.cdr, unquote_cnt, max_unq)

14✔

9521

);

14✔

9522

14✔

9527

                    if (is_pair(pair.cdr)) {

818,331✔

9553

                        } else {

818,331✔

9554

                            return evaluate(pair.cdr.car, {

818,331✔

9555

                                env: self,

818,331✔

9556

                                dynamic_env,

818,331✔

9557

                                error

818,331✔

9558

});

818,331✔

9559

818,331✔

9563

818,345✔

9564

                return resolve_pair(pair, (pair) => {

2,297,903✔

9565

                    return recur(pair, unquote_cnt, max_unq);

2,946,200✔

9566

});

2,297,903✔

9567

            } else if (is_plain_object(pair)) {

3,484,118✔

9568

                return quote_object(pair, unquote_cnt, max_unq);

12✔

9569

            } else if (pair instanceof Array) {

156,340✔

9570

                return quote_vector(pair, unquote_cnt, max_unq);

2✔

9571

2✔

9572

            return pair;

156,326✔

9573

3,484,118✔

9574

        // -----------------------------------------------------------------

330,204✔

9575

        function clear(node) {

330,204✔

9576

            if (is_pair(node)) {

35,799,177✔

9577

                delete node[__data__];

17,734,493✔

9578

                if (!node.have_cycles('car')) {

17,734,493✔

9579

                    clear(node.car);

17,734,493✔

9580

17,734,493✔

9581

                if (!node.have_cycles('cdr')) {

17,734,493✔

9582

                    clear(node.cdr);

17,734,493✔

9583

17,734,493✔

9584

17,734,493✔

9585

35,799,177✔

9586

        // -----------------------------------------------------------------

330,204✔

9587

        if (is_plain_object(arg.car) && !unquoted_arr(Object.values(arg.car))) {

330,204✔

9588

            return quote(arg.car);

2✔

9589

2✔

9590

        if (Array.isArray(arg.car) && !unquoted_arr(arg.car)) {

330,204✔

9591

            return quote(arg.car);

4✔

9592

4✔

9593

        if (is_pair(arg.car) &&

330,204✔

9594

            !arg.car.find('unquote') &&

330,204✔

9595

            !arg.car.find('unquote-splicing') &&

330,204✔

9596

            !arg.car.find('quasiquote')) {

330,204✔

9597

            return quote(arg.car);

6✔

9598

6✔

9599

        var x = recur(arg.car, 0, 1);

330,192✔

9600

        return unpromise(x, value => {

330,192✔

9601

            // clear nested data for tests

330,191✔

9602

            clear(value);

330,191✔

9603

            return quote(value);

330,191✔

9604

});

330,192✔

9605

    }, `(quasiquote list)

1✔

9606

1✔

9607

        Similar macro to \`quote\` but inside it you can use special expressions (unquote

1✔

9608

        x) abbreviated to ,x that will evaluate x and insert its value verbatim or

1✔

9609

        (unquote-splicing x) abbreviated to ,@x that will evaluate x and splice the value

1✔

9610

        into the result. Best used with macros but it can be used outside.`),

1✔

9611

    // ------------------------------------------------------------------

1✔

9612

    clone: doc('clone', function clone(list) {

1✔

9613

        typecheck('clone', list, 'pair');

1✔

9614

        return list.clone();

1✔

9615

    }, `(clone list)

1✔

9616

1✔

9617

        Function that returns a clone of the list, that does not share any pairs with the

1✔

9618

        original, so the clone can be safely mutated without affecting the original.`),

1✔

9619

    // ------------------------------------------------------------------

1✔

9620

    append: doc('append', function append(...items) {

1✔

9621

        items = items.map(item => {

66✔

9622

            if (is_pair(item)) {

145✔

9623

                return item.clone();

106✔

9624

106✔

9625

            return item;

39✔

9626

});

66✔

9627

        return global_env.get('append!').call(this, ...items);

66✔

9628

    }, `(append item ...)

1✔

9629

1✔

9630

        Function that creates a new list with each argument appended end-to-end.

1✔

9631

        It will always return a new list and not modify its arguments.`),

1✔

9632

    // ------------------------------------------------------------------

1✔

9633

    'append!': doc('append!', function(...items) {

1✔

9634

        var is_list = global_env.get('list?');

68✔

9635

        return items.reduce((acc, item) => {

68✔

9636

            typecheck('append!', acc, ['nil', 'pair']);

152✔

9637

            if ((is_pair(item) || is_nil(item)) && !is_list(item)) {

152✔

9638

                throw new Error('append!: Invalid argument, value is not a list');

1✔

9639

1✔

9640

            if (is_nil(acc)) {

152✔

9641

                if (is_nil(item)) {

79✔

9642

                    return nil;

16✔

9643

16✔

9644

                return item;

63✔

9645

63✔

9646

            if (is_null(item)) {

152✔

9647

                return acc;

18✔

9648

18✔

9649

            return acc.append(item);

54✔

9650

        }, nil);

68✔

9651

    }, `(append! arg1 ...)

1✔

9652

1✔

9653

        Destructive version of append, it can modify the lists in place. It returns

1✔

9654

        a new list where each argument is appended to the end. It may modify

1✔

9655

        lists added as arguments.`),

1✔

9656

    // ------------------------------------------------------------------

1✔

9657

    reverse: doc('reverse', function reverse(arg) {

1✔

9658

        typecheck('reverse', arg, ['array', 'pair', 'nil']);

86✔

9662

        if (is_pair(arg)) {

86✔

9663

            var arr = global_env.get('list->array')(arg).reverse();

86✔

9664

            return global_env.get('array->list')(arr);

86✔

9670

    }, `(reverse list)

1✔

9671

1✔

9672

        Function that reverses the list or array. If value is not a list

1✔

9673

        or array it will error.`),

1✔

9674

    // ------------------------------------------------------------------

1✔

9675

    nth: doc('nth', function nth(index, obj) {

1✔

9676

        typecheck('nth', index, 'number');

4✔

9677

        typecheck('nth', obj, ['array', 'pair']);

4✔

9678

        if (is_pair(obj)) {

4✔

9679

            var node = obj;

4✔

9680

            var count = 0;

4✔

9681

            while (count < index) {

4✔

9685

                node = node.cdr;

6✔

9686

                count++;

6✔

9687

6✔

9688

            return node.car;

4✔

9694

    }, `(nth index obj)

1✔

9695

1✔

9696

        Function that returns the nth element of the list or array.

1✔

9697

        If used with a non-indexable value it will error.`),

1✔

9698

    // ------------------------------------------------------------------

1✔

9699

    list: doc('list', function list(...args) {

1✔

9700

        return args.reverse().reduce((list, item) => new Pair(item, list), nil);

280✔

9701

    }, `(list . args)

1✔

9702

1✔

9703

        Function that creates a new list out of its arguments.`),

1✔

9704

    // ------------------------------------------------------------------

1✔

9705

    substring: doc('substring', function substring(string, start, end) {

1✔

9706

        typecheck('substring', string, 'string');

387✔

9707

        typecheck('substring', start, 'number');

387✔

9708

        typecheck('substring', end, ['number', 'void']);

387✔

9709

        return string.substring(start.valueOf(), end && end.valueOf());

387✔

9710

    }, `(substring string start end)

1✔

9711

1✔

9712

        Function that returns the slice of the string starting at start and ending

1✔

9713

        with end.`),

1✔

9714

    // ------------------------------------------------------------------

1✔

9715

    concat: doc('concat', function concat(...args) {

1✔

9716

        args.forEach((arg, i) => typecheck('concat', arg, 'string', i + 1));

169✔

9717

        return args.join('');

169✔

9718

    }, `(concat . strings)

1✔

9719

1✔

9720

        Function that creates a new string by joining its arguments.`),

1✔

9721

    // ------------------------------------------------------------------

1✔

9722

    join: doc('join', function join(separator, list) {

1✔

9723

        typecheck('join', separator, 'string');

2✔

9724

        typecheck('join', list, ['pair', 'nil']);

2✔

9725

        return global_env.get('list->array')(list).join(separator);

2✔

9726

    }, `(join separator list)

1✔

9727

1✔

9728

        Function that returns a string by joining elements of the list using separator.`),

1✔

9729

    // ------------------------------------------------------------------

1✔

9730

    split: doc('split', function split(separator, string) {

1✔

9731

        typecheck('split', separator, ['regex', 'string']);

44,931✔

9732

        typecheck('split', string, 'string');

44,931✔

9733

        return global_env.get('array->list')(string.split(separator));

44,931✔

9734

    }, `(split separator string)

1✔

9735

1✔

9736

        Function that creates a list by splitting string by separator which can

1✔

9737

        be a string or regular expression.`),

1✔

9738

    // ------------------------------------------------------------------

1✔

9739

    replace: doc('replace', function replace(pattern, replacement, string) {

1✔

9740

        typecheck('replace', pattern, ['regex', 'string']);

3✔

9741

        typecheck('replace', replacement, ['string', 'function']);

3✔

9742

        typecheck('replace', string, 'string');

3✔

9743

        if (is_function(replacement)) {

3✔

9744

            // ref: https://stackoverflow.com/a/48032528/387194

1✔

9745

            const replacements = [];

1✔

9746

            string.replace(pattern, function(...args) {

1✔

9747

                replacements.push(replacement(...args));

1✔

9748

});

1✔

9749

            return unpromise(replacements, replacements => {

1✔

9750

                return string.replace(pattern, () => replacements.shift());

1✔

9751

});

1✔

9752

1✔

9753

        return string.replace(pattern, replacement);

2✔

9754

    }, `(replace pattern replacement string)

1✔

9755

1✔

9756

        Function that changes pattern to replacement inside string. Pattern can be a

1✔

9757

        string or regex and replacement can be function or string. See Javascript

1✔

9758

        String.replace().`),

1✔

9759

    // ------------------------------------------------------------------

1✔

9760

    match: doc('match', function match(pattern, string) {

1✔

9761

        typecheck('match', pattern, ['regex', 'string']);

1✔

9762

        typecheck('match', string, 'string');

1✔

9763

        var m = string.match(pattern);

1✔

9765

    }, `(match pattern string)

1✔

9766

1✔

9767

        Function that returns a match object from JavaScript as a list or #f if

1✔

9768

        no match.`),

1✔

9769

    // ------------------------------------------------------------------

1✔

9770

    search: doc('search', function search(pattern, string) {

1✔

9771

        typecheck('search', pattern, ['regex', 'string']);

4✔

9772

        typecheck('search', string, 'string');

4✔

9773

        return string.search(pattern);

4✔

9774

    }, `(search pattern string)

1✔

9775

1✔

9776

        Function that returns the first found index of the pattern inside a string.`),

1✔

9777

    // ------------------------------------------------------------------

1✔

9778

    repr: doc('repr', function repr(obj, quote) {

1✔

9779

        return toString(obj, quote);

90,312✔

9780

    }, `(repr obj)

1✔

9781

1✔

9782

        Function that returns a LIPS code representation of the object as a string.`),

1✔

9783

    // ------------------------------------------------------------------

1✔

9784

    'escape-regex': doc('escape-regex', function(string) {

1✔

9785

        typecheck('escape-regex', string, 'string');

1✔

9786

        return escape_regex(string.valueOf());

1✔

9787

    }, `(escape-regex string)

1✔

9788

1✔

9789

        Function that returns a new string where all special operators used in regex,

1✔

9790

        are escaped with backslashes so they can be used in the RegExp constructor

1✔

9791

        to match a literal string.`),

1✔

9792

    // ------------------------------------------------------------------

1✔

9793

    env: doc('env', function env(env) {

1✔

9794

        env = env || this.env;

24✔

9795

        const names = Object.keys(env.__env__).map(LSymbol);

24✔

9796

        let result;

24✔

9797

        if (names.length) {

24✔

9798

            result = Pair.fromArray(names);

19✔

9799

        } else {

24✔

9800

            result = nil;

5✔

9801

5✔

9802

        if (env.__parent__ instanceof Environment) {

24✔

9803

            return global_env.get('env').call(this, env.__parent__).append(result);

21✔

9804

21✔

9805

        return result;

3✔

9806

    }, `(env)

1✔

9807

        (env obj)

1✔

9808

1✔

9809

        Function that returns a list of names (functions, macros and variables)

1✔

9810

        that are bound in the current environment or one of its parents.`),

1✔

9811

    // ------------------------------------------------------------------

1✔

9812

    'new': doc('new', function(obj, ...args) {

1✔

9813

        var instance = new (unbind(obj))(...args.map(x => unbox(x)));

1,473✔

9814

        return instance;

1,473✔

9815

    }, `(new obj . args)

1✔

9816

1✔

9817

        Function that creates new JavaScript instance of an object.`),

1✔

9818

    // ------------------------------------------------------------------

1✔

9819

    'typecheck': doc(

1✔

9820

        typecheck,

1✔

9821

        `(typecheck label value type [position])

1✔

9822

1✔

9823

         Checks the type of value and errors if the type is not one allowed.  Type can be

1✔

9824

         string or list of strings. The position optional argument is used to create a

1✔

9825

         proper error message for the nth argument of function calls.`),

1✔

9826

    // ------------------------------------------------------------------

1✔

9827

    'typecheck-number': doc(

1✔

9828

        typecheck_number,

1✔

9829

        `(typecheck-number label value type [position])

1✔

9830

1✔

9831

         Function similar to typecheck but checks if the argument is a number

1✔

9832

         and specific type of number e.g. complex.`),

1✔

9833

    // ------------------------------------------------------------------

1✔

9834

    'unset-special!': doc('unset-special!', function(symbol) {

1✔

9835

        typecheck('remove-special!', symbol, 'string');

7✔

9836

        delete specials.remove(symbol.valueOf());

7✔

9837

    }, `(unset-special! name)

1✔

9838

1✔

9839

        Function that removes a special symbol from parser added by \`set-special!\`,

1✔

9840

        name must be a string.`),

1✔

9841

    // ------------------------------------------------------------------

1✔

9842

    'set-special!': doc('set-special!', function(seq, name, type = specials.LITERAL) {

1✔

9843

        typecheck('set-special!', seq, 'string', 1);

22✔

9844

        typecheck('set-special!', name, 'symbol', 2);

22✔

9845

        specials.append(seq.valueOf(), name, type);

22✔

9846

    }, `(set-special! symbol name [type])

1✔

9847

1✔

9848

        Add a special symbol to the list of transforming operators by the parser.

1✔

9849

        e.g.: \`(add-special! "#" 'x)\` will allow to use \`#(1 2 3)\` and it will be

1✔

9850

        transformed into (x (1 2 3)) so you can write x macro that will process

1✔

9851

        the list. 3rd argument is optional, and it can be one of two values:

1✔

9852

        lips.specials.LITERAL, which is the default behavior, or

1✔

9853

        lips.specials.SPLICE which causes the value to be unpacked into the expression.

1✔

9854

        This can be used for e.g. to make \`#(1 2 3)\` into (x 1 2 3) that is needed

1✔

9855

        by # that defines vectors.`),

1✔

9856

    // ------------------------------------------------------------------

1✔

9857

    'get': get,

1✔

9858

    '.': get,

1✔

9859

    // ------------------------------------------------------------------

1✔

9860

    'unbind': doc(

1✔

9861

        unbind,

1✔

9862

        `(unbind fn)

1✔

9863

1✔

9864

         Function that removes the weak 'this' binding from a function so you

1✔

9865

         can get properties from the actual function object.`),

1✔

9866

    // ------------------------------------------------------------------

1✔

9867

    type: doc(

1✔

9868

        type,

1✔

9869

        `(type object)

1✔

9870

1✔

9871

         Function that returns the type of an object as string.`),

1✔

9872

    // ------------------------------------------------------------------

1✔

9873

    'debugger': doc('debugger', function() {

1✔

9877

    }, `(debugger)

1✔

9878

1✔

9879

        Function that triggers the JavaScript debugger (e.g. the browser devtools)

1✔

9880

        using the "debugger;" statement. If a debugger is not running this

1✔

9881

        function does nothing.`),

1✔

9882

    // ------------------------------------------------------------------

1✔

9883

    'in': doc('in', function(a, b) {

1✔

9884

        if (a instanceof LSymbol ||

8✔

9885

            a instanceof LString ||

8✔

9886

            a instanceof LNumber) {

8✔

9887

            a = a.valueOf();

8✔

9888

8✔

9889

        return a in unbox(b);

8✔

9890

    }, `(in key value)

1✔

9891

1✔

9892

        Function that uses the Javascript "in" operator to check if key is

1✔

9893

        a valid property in the value.`),

1✔

9894

    // ------------------------------------------------------------------

1✔

9895

    'instance?': doc('instance?', function(obj) {

1✔

9896

        return is_instance(obj);

2,161✔

9897

    }, `(instance? obj)

1✔

9898

1✔

9899

        Checks if object is an instance, created with a new operator`),

1✔

9900

    // ------------------------------------------------------------------

1✔

9901

    'instanceof': doc('instanceof', function(type, obj) {

1✔

9902

        return obj instanceof unbind(type);

4,262✔

9903

    }, `(instanceof type obj)

1✔

9904

1✔

9905

        Predicate that tests if the obj is an instance of type.`),

1✔

9906

    // ------------------------------------------------------------------

1✔

9907

    'prototype?': doc(

1✔

9908

        'prototype?',

1✔

9909

        is_prototype,

1✔

9910

        `(prototype? obj)

1✔

9911

1✔

9912

         Predicate that tests if value is a valid JavaScript prototype,

1✔

9913

         i.e. calling (new) with it will not throw '<x> is not a constructor'.`),

1✔

9914

    // ------------------------------------------------------------------

1✔

9915

    'macro?': doc('macro?', function(obj) {

1✔

9917

    }, `(macro? expression)

1✔

9918

1✔

9919

        Predicate that tests if value is a macro.`),

1✔

9920

    // ------------------------------------------------------------------

1✔

9921

    'continuation?': doc(

1✔

9922

        'continuation?',

1✔

9923

        is_continuation,

1✔

9924

        `(continuation? expression)

1✔

9925

1✔

9926

         Predicate that tests if value is a callable continuation.`),

1✔

9927

    // ------------------------------------------------------------------

1✔

9928

    'function?': doc(

1✔

9929

        'function?',

1✔

9930

        is_function,

1✔

9931

        `(function? expression)

1✔

9932

1✔

9933

         Predicate that tests if value is a callable function.`),

1✔

9934

    // ------------------------------------------------------------------

1✔

9935

    'real?': doc('real?', function(value) {

1✔

9943

    }, `(real? number)

1✔

9944

1✔

9945

        Predicate that tests if value is a real number (not complex).`),

1✔

9946

    // ------------------------------------------------------------------

1✔

9947

    'number?': doc('number?', function(x) {

1✔

9948

        return Number.isNaN(x) || LNumber.isNumber(x);

5,503✔

9949

    }, `(number? expression)

1✔

9950

1✔

9951

        Predicate that tests if value is a number or NaN value.`),

1✔

9952

    // ------------------------------------------------------------------

1✔

9953

    'string?': doc('string?', function(obj) {

1✔

9954

        return LString.isString(obj);

94,067✔

9955

    }, `(string? expression)

1✔

9956

1✔

9957

        Predicate that tests if value is a string.`),

1✔

9958

    // ------------------------------------------------------------------

1✔

9959

    'pair?': doc(

1✔

9960

        'pair?',

1✔

9961

        is_pair,

1✔

9962

        `(pair? expression)

1✔

9963

1✔

9964

         Predicate that tests if value is a pair or list structure.`),

1✔

9965

    // ------------------------------------------------------------------

1✔

9966

    'regex?': doc('regex?', function(obj) {

1✔

9968

    }, `(regex? expression)

1✔

9969

1✔

9970

        Predicate that tests if value is a regular expression.`),

1✔

9971

    // ------------------------------------------------------------------

1✔

9972

    'null?': doc('null?', function(obj) {

1✔

9973

        return is_null(obj);

74,911✔

9974

    }, `(null? expression)

1✔

9975

1✔

9976

        Predicate that tests if value is null-ish (i.e. undefined, nil, or

1✔

9977

        Javascript null).`),

1✔

9978

    // ------------------------------------------------------------------

1✔

9979

    'boolean?': doc('boolean?', function(obj) {

1✔

9981

    }, `(boolean? expression)

1✔

9982

1✔

9983

        Predicate that tests if value is a boolean (#t or #f).`),

1✔

9984

    // ------------------------------------------------------------------

1✔

9985

    'symbol?': doc('symbol?', function(obj) {

1✔

9986

        return obj instanceof LSymbol;

85,488✔

9987

    }, `(symbol? expression)

1✔

9988

1✔

9989

        Predicate that tests if value is a LIPS symbol.`),

1✔

9990

    // ------------------------------------------------------------------

1✔

9991

    'array?': doc('array?', function(obj) {

1✔

9992

        return obj instanceof Array;

2,169✔

9993

    }, `(array? expression)

1✔

9994

1✔

9995

        Predicate that tests if value is an array.`),

1✔

9996

    // ------------------------------------------------------------------

1✔

9997

    'object?': doc('object?', function(obj) {

1✔

9998

        return !is_nil(obj) && obj !== null &&

113✔

9999

            !(obj instanceof LCharacter) &&

113✔

10000

            !(obj instanceof RegExp) &&

113✔

10001

            !(obj instanceof LString) &&

113✔

10002

            !is_pair(obj) &&

113✔

10003

            !(obj instanceof LNumber) &&

113✔

10004

            typeof obj === 'object' &&

113✔

10005

            !(obj instanceof Array);

113✔

10006

    }, `(object? expression)

1✔

10007

1✔

10008

        Predicate that tests if value is an plain object (not another LIPS type).`),

1✔

10009

    // ------------------------------------------------------------------

1✔

10010

    flatten: doc('flatten', function flatten(list) {

1✔

10013

    }, `(flatten list)

1✔

10014

1✔

10015

        Returns a shallow list from tree structure (pairs).`),

1✔

10016

    // ------------------------------------------------------------------

1✔

10017

    'vector-append': doc('vector-append', function(...args) {

1✔

10021

        typecheck_args('vector-append', args, 'array');

12✔

10022

        const [first, ...rest] = args;

12✔

10023

        return first.concat(...rest);

12✔

10024

    }, `(vector-append v1 v2 ...)

1✔

10025

1✔

10026

         Returns new vector by combining it's arguments that should be vectors.`),

1✔

10027

    // ------------------------------------------------------------------

1✔

10028

    'array->list': doc('array->list', function(array) {

1✔

10029

        typecheck('array->list', array, 'array');

45,041✔

10030

        return Pair.fromArray(array);

45,041✔

10031

    }, `(array->list array)

1✔

10032

1✔

10033

        Function that converts a JavaScript array to a LIPS cons list.`),

1✔

10034

    // ------------------------------------------------------------------

1✔

10035

    'tree->array': doc(

1✔

10036

        'tree->array',

1✔

10037

        to_array('tree->array', true),

1✔

10038

        `(tree->array list)

1✔

10039

1✔

10040

         Function that converts a LIPS cons tree structure into a JavaScript array.`),

1✔

10041

    // ------------------------------------------------------------------

1✔

10042

    'list->array': doc(

1✔

10043

        'list->array',

1✔

10044

        to_array('list->array'),

1✔

10045

        `(list->array list)

1✔

10046

1✔

10047

         Function that converts a LIPS list into a JavaScript array.`),

1✔

10048

    // ------------------------------------------------------------------

1✔

10049

    apply: doc('apply', function apply(fn, ...args) {

1✔

10050

        typecheck('apply', fn, 'function', 1);

4,045✔

10051

        var last = args.pop();

4,045✔

10052

        typecheck('apply', last, ['pair', 'nil'], args.length + 2);

4,045✔

10053

        args = args.concat(global_env.get('list->array').call(this, last));

4,045✔

10054

        return fn.apply(this, prepare_fn_args(fn, args));

4,045✔

10055

    }, `(apply fn list)

1✔

10056

1✔

10057

        Function that calls fn with the list of arguments.`),

1✔

10058

    // ------------------------------------------------------------------

1✔

10059

    length: doc('length', function length(obj) {

1✔

10063

        if (is_pair(obj)) {

17,579✔

10064

            return obj.length();

17✔

10065

17✔

10066

        if ("length" in obj) {

17,562✔

10067

            return obj.length;

17,562✔

10068

17,562✔

10069

    }, `(length expression)

1✔

10070

1✔

10071

        Function that returns the length of the object. The object can be a LIPS

1✔

10072

        list or any object that has a "length" property. Returns undefined if the

1✔

10073

        length could not be found.`),

1✔

10074

    // ------------------------------------------------------------------

1✔

10075

    'string->number': doc('string->number', function(arg, radix = 10) {

1✔

10076

        typecheck('string->number', arg, 'string', 1);

23✔

10077

        typecheck('string->number', radix, 'number', 2);

23✔

10078

        arg = arg.valueOf();

23✔

10079

        radix = radix.valueOf();

23✔

10080

        if (arg.match(rational_bare_re) || arg.match(rational_re)) {

23✔

10081

            return parse_rational(arg, radix);

7✔

10082

        } else if (arg.match(complex_bare_re) || arg.match(complex_re)) {

23✔

10083

            return parse_complex(arg, radix);

7✔

10084

        } else {

16✔

10085

            const valid_bare = (radix === 10 && !arg.match(/e/i)) || radix === 16;

9✔

10086

            if (arg.match(int_bare_re) && valid_bare || arg.match(int_re)) {

9✔

10087

                return parse_integer(arg, radix);

8✔

10088

8✔

10089

            if (arg.match(float_re)) {

1✔

10090

                return parse_float(arg);

1✔

10091

1✔

10092

9✔

10094

    }, `(string->number number [radix])

1✔

10095

1✔

10096

        Function that parses a string into a number.`),

1✔

10097

    // ------------------------------------------------------------------

1✔

10098

    'try': doc(new Macro('try', function(code, { use_dynamic, error }) {

1✔

10099

        return new Promise((resolve, reject) => {

190✔

10100

            let catch_clause, finally_clause, body_error;

190✔

10101

            if (LSymbol.is(code.cdr.car.car, 'catch')) {

190✔

10102

                catch_clause = code.cdr.car;

177✔

10103

                if (is_pair(code.cdr.cdr) &&

177✔

10104

                    LSymbol.is(code.cdr.cdr.car.car, 'finally')) {

177✔

10105

                    finally_clause = code.cdr.cdr.car;

2✔

10106

2✔

10107

            } else if (LSymbol.is(code.cdr.car.car, 'finally')) {

190✔

10108

                finally_clause = code.cdr.car;

13✔

10109

13✔

10113

            function finalize(result) {

190✔

10114

                resolve(result);

103✔

10115

                throw new IgnoreException('[CATCH]');

103✔

10116

103✔

10117

            let next = (result, next) => {

190✔

10118

                next(result);

171✔

10119

171✔

10120

            if (finally_clause) {

190✔

10121

                next = function(result, cont) {

15✔

10122

                    // prevent infinite loop when finally throw exception

15✔

10123

                    next = reject;

15✔

10124

                    args.error = (e) => {

15✔

10125

                        throw e;

2✔

10126

};

15✔

10127

                    unpromise(evaluate(new Pair(

15✔

10128

                        new LSymbol('begin'),

15✔

10129

                        finally_clause.cdr

15✔

10130

                    ), args), function() {

15✔

10131

                        cont(result);

14✔

10132

});

15✔

10133

};

15✔

10134

15✔

10135

            const args = {

190✔

10136

                env: this,

190✔

10137

                use_dynamic,

190✔

10138

                dynamic_env: this,

190✔

10139

                error: (e) => {

190✔

10140

                    if (e instanceof IgnoreException) {

228✔

10141

                        throw e;

119✔

10142

119✔

10143

                    body_error = true;

109✔

10144

                    if (catch_clause) {

228✔

10145

                        var env = this.inherit('try');

107✔

10146

                        const name = catch_clause.cdr.car.car;

107✔

10150

                        env.set(name, e);

107✔

10151

                        let catch_error;

107✔

10152

                        var catch_args = {

107✔

10153

                            env,

107✔

10154

                            use_dynamic,

107✔

10155

                            dynamic_env: this,

107✔

10156

                            error: (e) => {

107✔

10157

                                catch_error = true;

8✔

10158

                                reject(e);

8✔

10159

                                throw new IgnoreException('[CATCH]');

8✔

10160

8✔

10161

};

107✔

10162

                        const value = evaluate(new Pair(

107✔

10163

                            new LSymbol('begin'),

107✔

10164

                            catch_clause.cdr.cdr

107✔

10165

                        ), catch_args);

107✔

10166

                        unpromise(value, function handler(result) {

107✔

10167

                            if (!catch_error) {

103✔

10168

                                next(result, finalize);

103✔

10169

103✔

10170

});

107✔

10171

                    } else {

228✔

10172

                        next(undefined, () => {

2✔

10173

                            reject(e);

2✔

10174

});

2✔

10175

2✔

10176

228✔

10177

};

190✔

10178

            const value = evaluate(code.car, args);

190✔

10179

            unpromise(value, function(result) {

190✔

10180

                next(result, resolve);

83✔

10181

            }, args.error);

190✔

10182

});

190✔

10183

    }), `(try expr (catch (e) code))

1✔

10184

         (try expr (catch (e) code) (finally code))

1✔

10185

         (try expr (finally code))

1✔

10186

1✔

10187

         Macro that executes expr and catches any exceptions thrown. If catch is provided

1✔

10188

         it's executed when an error is thrown. If finally is provided it's always

1✔

10189

         executed at the end.`),

1✔

10190

    // ------------------------------------------------------------------

1✔

10191

    'raise': doc('raise', function(obj) {

1✔

10192

        throw obj;

6✔

10193

    }, `(raise obj)

1✔

10194

1✔

10195

        Throws the object verbatim (no wrapping an a new Error).`),

1✔

10196

    'throw': doc('throw', function(message) {

1✔

10197

        throw new Error(message);

8✔

10198

    }, `(throw string)

1✔

10199

1✔

10200

        Throws a new exception.`),

1✔

10201

    // ------------------------------------------------------------------

1✔

10202

    find: doc('find', function find(arg, list) {

1✔

10203

        typecheck('find', arg, ['regex', 'function']);

14✔

10204

        typecheck('find', list, ['pair', 'nil']);

14✔

10205

        if (is_null(list)) {

14✔

10206

            return nil;

1✔

10207

1✔

10208

        var fn = matcher('find', arg);

12✔

10209

        return unpromise(fn(list.car), function(value) {

12✔

10210

            if (value && !is_nil(value)) {

12✔

10211

                return list.car;

3✔

10212

3✔

10213

            return find(arg, list.cdr);

9✔

10214

});

12✔

10215

    }, `(find fn list)

1✔

10216

        (find regex list)

1✔

10217

1✔

10218

        Higher-order function that finds the first value for which fn return true.

1✔

10219

        If called with a regex it will create a matcher function.`),

1✔

10220

    // ------------------------------------------------------------------

1✔

10221

    'for-each': doc('for-each', function(fn, ...lists) {

1✔

10222

        typecheck('for-each', fn, 'function');

88✔

10223

        lists.forEach((arg, i) => {

88✔

10224

            typecheck('for-each', arg, ['pair', 'nil'], i + 1);

88✔

10225

});

88✔

10226

        // we need to use call(this because babel transpile this code into:

88✔

10227

        // var ret = map.apply(void 0, [fn].concat(lists));

88✔

10228

        // it don't work with weakBind

88✔

10229

        var ret = global_env.get('map').call(this, fn, ...lists);

88✔

10230

        if (is_promise(ret)) {

88✔

10231

            return ret.then(() => {});

13✔

10232

13✔

10233

    }, `(for-each fn . lists)

1✔

10234

1✔

10235

        Higher-order function that calls function \`fn\` on each

1✔

10236

        value of the argument. If you provide more than one list

1✔

10237

        it will take each value from each list and call \`fn\` function

1✔

10238

        with that many arguments as number of list arguments.`),

1✔

10239

    // ------------------------------------------------------------------

1✔

10240

    map: doc('map', function map(fn, ...lists) {

1✔

10241

        typecheck('map', fn, 'function');

92,669✔

10242

        var is_list = global_env.get('list?');

92,669✔

10243

        lists.forEach((arg, i) => {

92,669✔

10244

            typecheck('map', arg, ['pair', 'nil'], i + 1);

92,665✔

10245

            // detect cycles

92,665✔

10249

});

92,669✔

10250

        if (lists.length === 0) {

92,669✔

10251

            return nil;

4✔

10252

4✔

10253

        if (lists.some(is_nil)) {

92,669✔

10254

            return nil;

46,131✔

10255

46,131✔

10256

        var args = lists.map(l => l.car);

46,534✔

10257

        const { env, dynamic_env, use_dynamic } = this;

46,534✔

10258

        const result = call_function(fn, args, { env, dynamic_env, use_dynamic });

46,534✔

10259

        return unpromise(result, (head) => {

46,534✔

10260

            return unpromise(map.call(this, fn, ...lists.map(l => l.cdr)), (rest) => {

46,531✔

10261

                return new Pair(head, rest);

46,525✔

10262

});

46,531✔

10263

});

46,534✔

10264

    }, `(map fn . lists)

1✔

10265

1✔

10266

        Higher-order function that calls function \`fn\` with each

1✔

10267

        value of the list. If you provide more then one list as argument

1✔

10268

        it will take each value from each list and call \`fn\` function

1✔

10269

        with that many argument as number of list arguments. The return

1✔

10270

        values of the fn calls are accumulated in a result list and

1✔

10271

        returned by map.`),

1✔

10272

    // ------------------------------------------------------------------

1✔

10273

    'list?': doc('list?', function(obj) {

1✔

10274

        var node = obj;

46,682✔

10275

        while (true) {

46,682✔

10276

            if (is_nil(node)) {

94,643✔

10277

                return true;

46,680✔

10278

46,680✔

10279

            if (!is_pair(node)) {

94,643✔

10280

                return false;

1✔

10281

1✔

10282

            if (node.have_cycles('cdr')) {

94,643✔

10283

                return false;

1✔

10284

1✔

10285

            node = node.cdr;

47,961✔

10286

47,961✔

10287

    }, `(list? obj)

1✔

10288

1✔

10289

        Predicate that tests if value is a proper linked list structure.

1✔

10290

        The car of each pair can be any value. It returns false on cyclic lists."`),

1✔

10291

    // ------------------------------------------------------------------

1✔

10292

    fold: doc('fold', fold('fold', function(fold, fn, init, ...lists) {

1✔

10293

        typecheck('fold', fn, 'function');

12✔

10294

        lists.forEach((arg, i) => {

12✔

10295

            typecheck('fold', arg, ['pair', 'nil'], i + 1);

12✔

10296

});

12✔

10300

        const value = fold.call(this, fn, init, ...lists.map(l => l.cdr));

12✔

10301

        return unpromise(value, value => {

12✔

10302

            return fn(...lists.map(l => l.car), value);

12✔

10303

});

12✔

10304

    }), `(fold fn init . lists)

1✔

10305

1✔

10306

         Function fold is left-to-right reversal of reduce. It call \`fn\`

1✔

10307

         on each pair of elements of the list and returns a single value.

1✔

10308

         e.g. it computes (fn 'a 'x (fn 'b 'y (fn 'c 'z 'foo)))

1✔

10309

         for: (fold fn 'foo '(a b c) '(x y z))`),

1✔

10310

    // ------------------------------------------------------------------

1✔

10311

    pluck: doc('pluck', function pluck(...keys) {

1✔

10312

        return function(obj) {

4✔

10313

            keys = keys.map(x => x instanceof LSymbol ? x.__name__ : x);

4✔

10314

            if (keys.length === 0) {

4✔

10315

                return nil;

1✔

10316

            } else if (keys.length === 1) {

4✔

10317

                const [key] = keys;

2✔

10318

                return obj[key];

2✔

10319

2✔

10320

            var result = {};

1✔

10321

            keys.forEach((key) => {

1✔

10322

                result[key] = obj[key];

2✔

10323

});

1✔

10324

            return result;

1✔

10325

};

4✔

10326

    }, `(pluck . strings)

1✔

10327

1✔

10328

        If called with a single string it will return a function that when

1✔

10329

        called with an object will return that key from the object.

1✔

10330

        If called with more then one string the returned function will

1✔

10331

        create a new object by copying all properties from the given object.`),

1✔

10332

    // ------------------------------------------------------------------

1✔

10333

    reduce: doc('reduce', fold('reduce', function(reduce, fn, init, ...lists) {

1✔

10344

    }), `(reduce fn init list . lists)

1✔

10345

1✔

10346

         Higher-order function that takes each element of the list and calls

1✔

10347

         the fn with result of previous call or init and the next element

1✔

10348

         of the list until each element is processed, and returns a single value

1✔

10349

         as result of last call to \`fn\` function.

1✔

10350

         e.g. it computes (fn 'c 'z (fn 'b 'y (fn 'a 'x 'foo)))

1✔

10351

         for: (reduce fn 'foo '(a b c) '(x y z))`),

1✔

10352

    // ------------------------------------------------------------------

1✔

10353

    filter: doc('filter', function filter(arg, list) {

1✔

10372

    }, `(filter fn list)

1✔

10373

        (filter regex list)

1✔

10374

1✔

10375

        Higher-order function that calls \`fn\` for each element of the list

1✔

10376

        and return a new list for only those elements for which fn returns

1✔

10377

        a truthy value. If called with a regex it will create a matcher function.`),

1✔

10378

    // ------------------------------------------------------------------

1✔

10379

    compose: doc(

1✔

10380

        compose,

1✔

10381

        `(compose . fns)

1✔

10382

1✔

10383

         Higher-order function that creates a new function that applies all functions

1✔

10384

         from right to left and returns the last value. Reverse of pipe.

1✔

10385

         e.g.:

1✔

10386

         ((compose (curry + 2) (curry * 3)) 10) ==> (+ 2 (* 3 10)) ==> 32`),

1✔

10387

    pipe: doc(

1✔

10388

        pipe,

1✔

10389

        `(pipe . fns)

1✔

10390

1✔

10391

         Higher-order function that creates a new function that applies all functions

1✔

10392

         from left to right and returns the last value. Reverse of compose.

1✔

10393

         e.g.:

1✔

10394

         ((pipe (curry + 2) (curry * 3)) 10) ==> (* 3 (+ 2 10)) ==> 36`),

1✔

10395

    curry: doc(

1✔

10396

        curry,

1✔

10397

        `(curry fn . args)

1✔

10398

1✔

10399

         Higher-order function that creates a curried version of the function.

1✔

10400

         The result function will have partially applied arguments and it

1✔

10401

         will keep returning one-argument functions until all arguments are provided,

1✔

10402

         then it calls the original function with the accumulated arguments.

1✔

10403

1✔

10404

         e.g.:

1✔

10405

         (define (add a b c d) (+ a b c d))

1✔

10406

         (define add1 (curry add 1))

1✔

10407

         (define add12 (add 2))

1✔

10408

         (display (add12 3 4))`),

1✔

10409

    // ------------------------------------------------------------------

1✔

10410

    // Numbers

1✔

10411

    // ------------------------------------------------------------------

1✔

10412

    gcd: doc('gcd', function gcd(...args) {

1✔

10417

    }, `(gcd n1 n2 ...)

1✔

10418

1✔

10419

        Function that returns the greatest common divisor of the arguments.`),

1✔

10420

    // ------------------------------------------------------------------

1✔

10421

    lcm: doc('lcm', function lcm(...args) {

1✔

10433

    }, `(lcm n1 n2 ...)

1✔

10434

1✔

10435

        Function that returns the least common multiple of the arguments.`),

1✔

10436

    // ------------------------------------------------------------------

1✔

10437

    'odd?': doc('odd?', single_math_op(function(num) {

1✔

10438

        return LNumber(num).isOdd();

16✔

10439

    }), `(odd? number)

1✔

10440

1✔

10441

         Checks if number is odd.`),

1✔

10442

    // ------------------------------------------------------------------

1✔

10443

    'even?': doc('even?', single_math_op(function(num) {

1✔

10444

        return LNumber(num).isEven();

5✔

10445

    }), `(even? number)

1✔

10446

1✔

10447

         Checks if number is even.`),

1✔

10448

    // ------------------------------------------------------------------

1✔

10449

    // math functions

1✔

10450

    '*': doc('*', reduce_math_op(function(a, b) {

1✔

10451

        return LNumber(a).mul(b);

10,406✔

10452

    }, LNumber(1)), `(* . numbers)

1✔

10453

1✔

10454

        Multiplies all numbers passed as arguments. If single value is passed

1✔

10455

        it will return that value.`),

1✔

10456

    // ------------------------------------------------------------------

1✔

10457

    '+': doc('+', reduce_math_op(function(a, b) {

1✔

10458

        return LNumber(a).add(b);

87,721✔

10459

    }, LNumber(0)), `(+ . numbers)

1✔

10460

1✔

10461

        Sums all numbers passed as arguments. If single value is passed it will

1✔

10462

        return that value.`),

1✔

10463

    // ------------------------------------------------------------------

1✔

10464

    '-': doc('-', function(...args) {

1✔

10465

        if (args.length === 0) {

18,589✔

10466

            throw new Error('-: procedure require at least one argument');

1✔

10467

1✔

10468

        typecheck_args('-', args, 'number');

18,588✔

10469

        if (args.length === 1) {

18,589✔

10470

            return LNumber(args[0]).sub();

8✔

10471

8✔

10472

        if (args.length) {

18,580✔

10473

            return args.reduce(binary_math_op(function(a, b) {

18,580✔

10474

                return LNumber(a).sub(b);

18,582✔

10475

            }));

18,580✔

10476

18,580✔

10477

    }, `(- n1 n2 ...)

1✔

10478

        (- n)

1✔

10479

1✔

10480

        Subtracts n2 and subsequent numbers from n1. If only one argument is passed

1✔

10481

        it will negate the value.`),

1✔

10482

    // ------------------------------------------------------------------

1✔

10483

    '/': doc('/', function(...args) {

1✔

10487

        typecheck_args('/', args, 'number');

231✔

10488

        if (args.length === 1) {

231✔

10489

            return LNumber(1).div(args[0]);

24✔

10490

24✔

10491

        return args.reduce(binary_math_op(function(a, b) {

207✔

10492

            return LNumber(a).div(b);

207✔

10493

        }));

207✔

10494

    }, `(/ n1 n2 ...)

1✔

10495

        (/ n)

1✔

10496

1✔

10497

        Divides n1 by n2 and subsequent arguments one by one. If single argument

1✔

10498

        is passed it will calculate (/ 1 n).`),

1✔

10499

    // ------------------------------------------------------------------

1✔

10500

    abs: doc('abs', single_math_op(function(n) {

1✔

10501

        return LNumber(n).abs();

1✔

10502

    }), `(abs number)

1✔

10503

1✔

10504

         Function that returns the absolute value (magnitude) of number.`),

1✔

10505

    // ------------------------------------------------------------------

1✔

10506

    truncate: doc('truncate', function(n) {

1✔

10507

        typecheck('truncate', n, 'number');

1✔

10508

        if (LNumber.isFloat(n)) {

1✔

10509

            if (n instanceof LNumber) {

1✔

10510

                n = n.valueOf();

1✔

10511

1✔

10512

            return LFloat(truncate(n));

1✔

10513

1✔

10515

    }, `(truncate n)

1✔

10516

1✔

10517

        Function that returns the integer part (floor) of a real number.`),

1✔

10518

    // ------------------------------------------------------------------

1✔

10519

    sqrt: doc('sqrt', single_math_op(function(n) {

1✔

10520

        return LNumber(n).sqrt();

19✔

10521

    }), `(sqrt number)

1✔

10522

1✔

10523

         Function that returns the square root of the number.`),

1✔

10524

    // ------------------------------------------------------------------

1✔

10525

    '**': doc('**', binary_math_op(function(a, b) {

1✔

10526

        a = LNumber(a);

53✔

10527

        b = LNumber(b);

53✔

10528

        if (b.cmp(0) === -1 && LNumber.isInteger(b)) {

53✔

10529

            return LRational({ num: 1, denom: a.pow(b.sub()) });

1✔

10530

1✔

10531

        [a, b] = a.coerce(b);

52✔

10532

        return a.pow(b);

52✔

10533

    }), `(** a b)

1✔

10534

1✔

10535

         Function that calculates number a to to the power of b.`),

1✔

10536

    // ------------------------------------------------------------------

1✔

10537

    '1+': doc('1+', single_math_op(function(number) {

1✔

10539

    }), `(1+ number)

1✔

10540

1✔

10541

         Function that adds 1 to the number and return result.`),

1✔

10542

    // ------------------------------------------------------------------

1✔

10543

    '1-': doc(single_math_op(function(number) {

1✔

10544

        return LNumber(number).sub(1);

47,706✔

10545

    }), `(1- number)

1✔

10546

1✔

10547

         Function that subtracts 1 from the number and return result.`),

1✔

10548

    // ------------------------------------------------------------------

1✔

10549

    '%': doc('%', function(a, b) {

1✔

10550

        typecheck_args('%', [a, b], 'number');

5✔

10551

        return LNumber(a).rem(b);

5✔

10552

    }, `(% n1 n2)

1✔

10553

1✔

10554

        Function returns the remainder of n1/n2 (modulo).`),

1✔

10555

    // ------------------------------------------------------------------

1✔

10556

    // Booleans

1✔

10557

    '==': doc('==', function(...args) {

1✔

10558

        typecheck_args('==', args, 'number');

27,186✔

10559

        return seq_compare((a, b) => LNumber(a).cmp(b) === 0, args);

27,186✔

10560

    }, `(== x1 x2 ...)

1✔

10561

1✔

10562

        Function that compares its numerical arguments and checks if they are

1✔

10563

        all equal.`),

1✔

10564

    // ------------------------------------------------------------------

1✔

10565

    '>': doc('>', function(...args) {

1✔

10566

        typecheck_numbers('>', args, ['bigint', 'float', 'rational']);

8,080✔

10567

        return seq_compare((a, b) => LNumber(a).cmp(b) === 1, args);

8,080✔

10568

    }, `(> x1 x2 x3 ...)

1✔

10569

1✔

10570

        Function that compares its numerical arguments and checks if they are

1✔

10571

        monotonically decreasing, i.e. x1 > x2 and x2 > x3 and so on.`),

1✔

10572

    // ------------------------------------------------------------------

1✔

10573

    '<': doc('<', function(...args) {

1✔

10574

        typecheck_numbers('<', args, ['bigint', 'float', 'rational']);

106,766✔

10575

        return seq_compare((a, b) => LNumber(a).cmp(b) === -1, args);

106,766✔

10576

    }, `(< x1 x2 ...)

1✔

10577

1✔

10578

        Function that compares its numerical arguments and checks if they are

1✔

10579

        monotonically increasing, i.e. x1 < x2 and x2 < x3 and so on.`),

1✔

10580

    // ------------------------------------------------------------------

1✔

10581

    '<=': doc('<=', function(...args) {

1✔

10582

        typecheck_numbers('<=', args, ['bigint', 'float', 'rational']);

86✔

10583

        return seq_compare((a, b) => [0, -1].includes(LNumber(a).cmp(b)), args);

86✔

10584

    }, `(<= x1 x2 ...)

1✔

10585

1✔

10586

        Function that compares its numerical arguments and checks if they are

1✔

10587

        monotonically nondecreasing, i.e. x1 <= x2 and x2 <= x3 and so on.`),

1✔

10588

    // ------------------------------------------------------------------

1✔

10589

    '>=': doc('>=', function(...args) {

1✔

10590

        typecheck_numbers('>=', args, ['bigint', 'float', 'rational']);

14✔

10591

        return seq_compare((a, b) => [0, 1].includes(LNumber(a).cmp(b)), args);

14✔

10592

    }, `(>= x1 x2 ...)

1✔

10593

1✔

10594

        Function that compares its numerical arguments and checks if they are

1✔

10595

        monotonically nonincreasing, i.e. x1 >= x2 and x2 >= x3 and so on.`),

1✔

10596

    // ------------------------------------------------------------------

1✔

10597

    'eq?': doc(

1✔

10598

        'eq?',

1✔

10599

        equal,

1✔

10600

        `(eq? a b)

1✔

10601

1✔

10602

         Function that compares two values if they are identical.`),

1✔

10603

    // ------------------------------------------------------------------

1✔

10604

    or: doc(new Macro('or', function(code, { use_dynamic, error }) {

1✔

10605

        var args = global_env.get('list->array')(code);

11,677✔

10606

        var self = this;

11,677✔

10607

        const dynamic_env = self;

11,677✔

10608

        if (!args.length) {

11,677✔

10609

            return false;

1✔

10610

1✔

10611

        var result;

11,676✔

10612

        return (function loop() {

11,676✔

10613

            function next(value) {

22,969✔

10614

                result = value;

19,950✔

10615

                if (!is_false(result)) {

19,950✔

10616

                    return result;

8,657✔

10617

                } else {

19,950✔

10618

                    return loop();

11,293✔

10619

11,293✔

10620

19,950✔

10621

            if (!args.length) {

22,969✔

10624

                } else {

3,019✔

10625

                    return false;

3,019✔

10626

3,019✔

10627

            } else {

22,969✔

10628

                var arg = args.shift();

19,950✔

10629

                var value = evaluate(arg, { env: self, dynamic_env, use_dynamic, error });

19,950✔

10630

                return unpromise(value, next);

19,950✔

10631

19,950✔

10632

        })();

11,676✔

10633

    }), `(or . expressions)

1✔

10634

1✔

10635

         Macro that executes the values one by one and returns the first that is

1✔

10636

         a truthy value. If there are no expressions that evaluate to true it

1✔

10637

         returns false.`),

1✔

10638

    // ------------------------------------------------------------------

1✔

10639

    and: doc(new Macro('and', function(code, { use_dynamic, error } = {}) {

1✔

10640

        const args = global_env.get('list->array')(code);

235,248✔

10641

        const self = this;

235,248✔

10642

        const dynamic_env = self;

235,248✔

10643

        if (!args.length) {

235,248✔

10644

            return true;

3✔

10645

3✔

10646

        let result;

235,245✔

10647

        const eval_args = { env: self, dynamic_env, use_dynamic, error };

235,245✔

10648

        return (function loop() {

235,245✔

10649

            function next(value) {

495,676✔

10650

                result = value;

430,736✔

10651

                if (is_false(result)) {

430,736✔

10652

                    return result;

170,305✔

10653

                } else {

430,736✔

10654

                    return loop();

260,431✔

10655

260,431✔

10656

430,736✔

10657

            if (!args.length) {

495,676✔

10658

                if (!is_false(result)) {

64,940✔

10659

                    return result;

64,940✔

10663

            } else {

495,676✔

10664

                const arg = args.shift();

430,736✔

10665

                return unpromise(evaluate(arg, eval_args), next);

430,736✔

10666

430,736✔

10667

        })();

235,245✔

10668

    }), `(and . expressions)

1✔

10669

1✔

10670

         Macro that evaluates each expression in sequence and if any value returns false

1✔

10671

         it will stop and return false. If each value returns true it will return the

1✔

10672

         last value. If it's called without arguments it will return true.`),

1✔

10673

    // bit operations

1✔

10674

    '|': doc('|', function(a, b) {

1✔

10676

    }, `(| a b)

1✔

10677

1✔

10678

        Function that calculates the bitwise or operation.`),

1✔

10679

    '&': doc('&', function(a, b) {

1✔

10681

    }, `(& a b)

1✔

10682

1✔

10683

        Function that calculates the bitwise and operation.`),

1✔

10684

    '~': doc('~', function(a) {

1✔

10686

    }, `(~ number)

1✔

10687

1✔

10688

        Function that calculates the bitwise inverse (flip all the bits).`),

1✔

10689

    '>>': doc('>>', function(a, b) {

1✔

10691

    }, `(>> a b)

1✔

10692

1✔

10693

        Function that right shifts the value a by value b bits.`),

1✔

10694

    '<<': doc('<<', function(a, b) {

1✔

10696

    }, `(<< a b)

1✔

10697

1✔

10698

        Function that left shifts the value a by value b bits.`),

1✔

10699

    not: doc('not', function not(value) {

1✔

10700

        return !value;

22✔

10701

    }, `(not object)

1✔

10702

1✔

10703

        Function that returns the Boolean negation of its argument.`)

1✔

10704

}, undefined, 'global');

1✔

10705

var user_env = global_env.inherit('user-env');

1✔

10706

// -------------------------------------------------------------------------

1✔

10707

function set_interaction_env(interaction, internal) {

1✔

10708

    interaction.constant('**internal-env**', internal);

1✔

10709

    interaction.doc(

1✔

10710

        '**internal-env**',

1✔

10711

        `**internal-env**

1✔

10712

1✔

10713

         Constant used to hide stdin, stdout and stderr so they don't interfere

1✔

10714

         with variables with the same name. Constants are an internal type

1✔

10715

         of variable that can't be redefined, defining a variable with the same name

1✔

10716

         will throw an error.`

1✔

10717

);

1✔

10718

    global_env.set('**interaction-environment**', interaction);

1✔

10719

1✔

10720

// -------------------------------------------------------------------------

1✔

10721

set_interaction_env(user_env, internal_env);

1✔

10722

global_env.doc(

1✔

10723

    '**interaction-environment**',

1✔

10724

    `**interaction-environment**

1✔

10725

1✔

10726

    Internal dynamic, global variable used to find interpreter environment.

1✔

10727

    It's used so the read and write functions can locate **internal-env**

1✔

10728

    that contains the references to stdin, stdout and stderr.`

1✔

10729

);

1✔

10730

function set_fs(fs) {

1✔

10731

    user_env.get('**internal-env**').set('fs', fs);

1✔

10732

1✔

10733

1✔

10734

// -------------------------------------------------------------------------

1✔

10735

(function() {

1✔

10736

    var map = { ceil: 'ceiling' };

1✔

10737

    ['floor', 'round', 'ceil'].forEach(fn => {

1✔

10738

        var name = map[fn] ? map[fn] : fn;

3✔

10739

        global_env.set(name, doc(name, function(value) {

3✔

10740

            typecheck(name, value, 'number');

27✔

10741

            if (value instanceof LNumber) {

27✔

10742

                return value[fn]();

27✔

10743

27✔

10744

        }, `(${name} number)

3✔

10745

3✔

10746

            Function that calculates the ${name} of a number.`));

3✔

10747

});

1✔

10748

})();

1✔

10749

// -------------------------------------------------------------------------

1✔

10750

// ref: https://stackoverflow.com/a/4331218/387194

1✔

10751

function allPossibleCases(arr) {

14✔

10752

    if (arr.length === 1) {

14✔

10753

        return arr[0];

4✔

10754

    } else {

14✔

10755

        var result = [];

10✔

10756

        // recur with the rest of array

10✔

10757

        var allCasesOfRest = allPossibleCases(arr.slice(1));

10✔

10758

        for (var i = 0; i < allCasesOfRest.length; i++) {

10✔

10759

            for (var j = 0; j < arr[0].length; j++) {

52✔

10760

                result.push(arr[0][j] + allCasesOfRest[i]);

104✔

10761

104✔

10762

52✔

10763

        return result;

10✔

10764

10✔

10765

14✔

10766

1✔

10767

// -------------------------------------------------------------------------

1✔

10768

function combinations(input, start, end) {

1✔

10769

    var result = [];

1✔

10770

    for (var i = start; i <= end; ++i) {

1✔

10771

        var input_arr = [];

4✔

10772

        for (var j = 0; j < i; ++j) {

4✔

10773

            input_arr.push(input);

14✔

10774

14✔

10775

        result = result.concat(allPossibleCases(input_arr));

4✔

10776

4✔

10777

    return result;

1✔

10778

1✔

10779

1✔

10780

// -------------------------------------------------------------------------

1✔

10781

// cadr caddr cadadr etc.

1✔

10782

combinations(['d', 'a'], 2, 5).forEach(spec => {

1✔

10783

    const s = spec.split('');

60✔

10784

    const chars = s.slice().reverse();

60✔

10785

    const code = s.map(c => `(c${c}r`).join(' ') + ' arg' + ')'.repeat(s.length);

60✔

10786

    const name = 'c' + spec + 'r';

60✔

10787

    global_env.set(name, doc(name, function(arg) {

60✔

10788

        return chars.reduce(function(list, type) {

37,215✔

10789

            typecheck(name, list, 'pair');

74,565✔

10790

            if (type === 'a') {

74,565✔

10791

                return list.car;

37,039✔

10792

            } else {

74,565✔

10793

                return list.cdr;

37,526✔

10794

37,526✔

10795

        }, arg);

37,215✔

10796

    }, `(${name} arg)

60✔

10797

60✔

10798

        Function that calculates ${code}`));

60✔

10799

});

1✔

10800

// -----------------------------------------------------------------------------

1✔

10801

function reversseFind(dir, fn) {

9✔

10802

    var parts = dir.split(path.sep).filter(Boolean);

9✔

10803

    for (var i = parts.length; i--;) {

9✔

10804

        var p = path.join('/', ...parts.slice(0, i + 1));

9✔

10805

        if (fn(p)) {

9✔

10806

            return p;

9✔

10807

9✔

10808

9✔

10809

9✔

10810

1✔

10811

// -----------------------------------------------------------------------------

1✔

10812

function nodeModuleFind(dir) {

9✔

10813

    return reversseFind(dir, function(dir) {

9✔

10814

        return fs.existsSync(path.join(dir, 'node_modules'));

9✔

10815

});

9✔

10816

9✔

10817

1✔

10818

// -------------------------------------------------------------------------

1✔

10819

function is_node() {

5✔

10820

    return typeof global !== 'undefined' && global.global === global;

5✔

10821

5✔

10822

// -------------------------------------------------------------------------

1✔

10823

const noop = () => {};

1✔

10824

// -------------------------------------------------------------------------

1✔

10825

async function node_specific() {

1✔

10826

    const { createRequire } = await import('mod' + 'ule');

1✔

10827

    nodeRequire = createRequire(import.meta.url);

1✔

10828

    fs = await import('fs');

1✔

10829

    path = await import('path');

1✔

10830

    global_env.set('global', global);

1✔

10831

    global_env.set('self', global);

1✔

10832

    global_env.set('window', undefined);

1✔

10833

    const moduleURL = new URL(import.meta.url);

1✔

10834

    // using name __direname and __filename breaks after transpilation

1✔

10835

    const __dirname__ = path.dirname(moduleURL.pathname);

1✔

10836

    const __filename__ = path.basename(moduleURL.pathname);

1✔

10837

    global_env.set('__dirname', __dirname__);

1✔

10838

    global_env.set('__filename', __filename__);

1✔

10839

    // ---------------------------------------------------------------------

1✔

10840

    global_env.set('require.resolve', doc('require.resolve', function(path) {

1✔

10844

    }, `(require.resolve path)

1✔

10845

1✔

10846

        Returns the path relative to the current module.

1✔

10847

1✔

10848

        Only available when LIPS is running under Node.js.`));

1✔

10849

    // ---------------------------------------------------------------------

1✔

10850

    global_env.set('require', doc('require', function(module) {

1✔

10851

        typecheck('require', module, 'string');

9✔

10852

        module = module.valueOf();

9✔

10853

        var root = process.cwd();

9✔

10854

        var value;

9✔

10855

        try {

9✔

10858

            } else {

9✔

10859

                var dir = nodeModuleFind(root);

9✔

10860

                if (dir) {

9✔

10861

                    value = nodeRequire(path.join(dir, 'node_modules', module));

9✔

10865

9✔

10866

        } catch (e) {

9✔

10867

            value = nodeRequire(module);

7✔

10868

7✔

10869

        return patch_value(value, global);

9✔

10870

    }, `(require module)

1✔

10871

1✔

10872

        Function used inside Node.js to import a module.`));

1✔

10873

1✔

10874

    // ignore exceptions that are caught elsewhere. This is needed to fix AVA

1✔

10875

    // reporting unhandled rejections for try..catch

1✔

10876

    // see: https://github.com/avajs/ava/discussions/3289

1✔

10877

    process.on('unhandledRejection', (reason, promise) => {

1✔

10878

        if (reason instanceof IgnoreException) {

25✔

10879

            promise.catch(noop);

25✔

10880

25✔

10881

});

1✔

10882

1✔

10883

// -------------------------------------------------------------------------

1✔

10884

/* c8 ignore next 15 */

1✔

10885

let node_ready; // Scheme load function need to wait for node_specific

1✔

10886

if (is_node()) {

1✔

10887

    node_ready = node_specific();

1✔

10888

} else {

1✔

10889

    node_ready = Promise.resolve();

1✔

10890

    if (typeof window !== 'undefined' && window === root) {

1✔

10891

        global_env.set('window', window);

1✔

10892

        global_env.set('global', undefined);

1✔

10893

        global_env.set('self', window);

1✔

10894

    } else if (typeof self !== 'undefined' && typeof WorkerGlobalScope !== 'undefined') {

1✔

10895

        global_env.set('self', self);

1✔

10896

        global_env.set('window', undefined);

1✔

10897

        global_env.set('global', undefined);

1✔

10898

1✔

10899

1✔

10900

// -------------------------------------------------------------------------

1✔

10901

function typeErrorMessage(fn, got, expected, position = null) {

5✔

10902

    let postfix = fn ? ` in expression \`${fn}\`` : '';

5✔

10903

    if (position !== null) {

5✔

10904

        postfix += ` (argument ${position})`;

2✔

10905

2✔

10909

    if (expected instanceof Array) {

5✔

10910

        if (expected.length === 1) {

4✔

10911

            const first = expected[0].toLowerCase();

2✔

10913

        } else {

2✔

10914

            expected = new Intl.ListFormat('en', {

2✔

10915

                style: 'long', type: 'disjunction'

2✔

10916

            }).format(expected);

2✔

10917

2✔

10918

4✔

10919

    return `Expecting ${expected} got ${got}${postfix}`;

5✔

10920

5✔

10921

1✔

10922

// -------------------------------------------------------------------------

1✔

10923

function typecheck_number(fn, arg, expected, position = null) {

229,894✔

10924

    typecheck(fn, arg, 'number', position);

229,894✔

10925

    const arg_type = arg.__type__;

229,894✔

10926

    let match;

229,894✔

10930

    if (expected instanceof Array) {

229,894✔

10931

        expected = expected.map(x => x.valueOf());

229,894✔

10932

229,894✔

10933

    if (expected instanceof Array) {

229,894✔

10934

        expected = expected.map(x => x.valueOf().toLowerCase());

229,894✔

10935

        if (expected.includes(arg_type)) {

229,894✔

10936

            match = true;

229,894✔

10937

229,894✔

10944

229,894✔

10945

1✔

10946

// -------------------------------------------------------------------------

1✔

10947

function typecheck_numbers(fn, args, expected) {

114,946✔

10948

    args.forEach((arg, i) => {

114,946✔

10949

        typecheck_number(fn, arg, expected, i + 1);

229,894✔

10950

});

114,946✔

10951

114,946✔

10952

1✔

10953

// -------------------------------------------------------------------------

1✔

10954

function typecheck_args(fn, args, expected) {

46,022✔

10955

    args.forEach((arg, i) => {

46,022✔

10956

        typecheck(fn, arg, expected, i + 1);

92,014✔

10957

});

46,022✔

10958

46,022✔

10959

// -------------------------------------------------------------------------

1✔

10960

function typecheck_text_port(fn, arg, type) {

190✔

10961

    typecheck(fn, arg, type);

190✔

10969

190✔

10970

// -------------------------------------------------------------------------

1✔

10971

function typecheck(fn, arg, expected, position = null) {

40,001,090✔

10972

    fn = fn.valueOf();

40,001,090✔

10973

    const arg_type = type(arg).toLowerCase();

40,001,090✔

10980

    var match = false;

40,001,090✔

10981

    if (is_pair(expected)) {

40,001,090✔

10982

        expected = expected.to_array();

13✔

10983

13✔

10984

    if (expected instanceof Array) {

40,001,090✔

10985

        expected = expected.map(x => x.valueOf());

38,311,163✔

10986

38,311,163✔

10987

    if (expected instanceof Array) {

40,001,090✔

10988

        expected = expected.map(x => x.valueOf().toLowerCase());

38,311,163✔

10989

        if (expected.includes(arg_type)) {

38,311,163✔

10990

            match = true;

38,311,159✔

10991

38,311,159✔

10992

    } else {

40,001,090✔

10993

        expected = expected.valueOf().toLowerCase();

1,689,927✔

10994

1,689,927✔

10995

    if (!match && arg_type !== expected) {

40,001,090✔

10996

        throw new Error(typeErrorMessage(fn, arg_type, expected, position));

5✔

10997

5✔

10998

40,001,090✔

10999

1✔

11000

// -------------------------------------------------------------------------

1✔

11001

function memoize(fn) {

1✔

11002

    var memo = new WeakMap();

1✔

11003

    return function(arg) {

1✔

11004

        var result = memo.get(arg);

40,003,236✔

11005

        if (!result) {

40,003,236✔

11006

            result = fn(arg);

40,003,236✔

11007

40,003,236✔

11008

        return result;

40,003,236✔

11009

};

1✔

11010

1✔

11011

// -------------------------------------------------------------------------

1✔

11012

/* eslint-disable no-func-assign */

1✔

11013

type = memoize(type);

1✔

11014

/* eslint-enable no-func-assign */

1✔

11015

// -------------------------------------------------------------------------

1✔

11016

function type(obj) {

40,015,995✔

11017

    let t = type_constants.get(obj);

40,015,995✔

11018

    if (t) {

40,015,995✔

11019

        return t;

6✔

11020

6✔

11021

    if (typeof obj === 'object') {

40,015,995✔

11022

        for (let [key, value] of Object.entries(type_mapping)) {

16,295,164✔

11023

            if (obj instanceof value) {

33,074,505✔

11024

                return key;

16,294,519✔

11025

16,294,519✔

11026

33,074,505✔

11027

        if (is_instance(obj)) {

16,295,164✔

11028

            if (is_function(obj.typeOf)) {

6✔

11029

                return obj.typeOf();

6✔

11030

6✔

11033

        if (obj.constructor) {

639✔

11034

            if (obj.constructor.__class__) {

639✔

11035

                return obj.constructor.__class__;

538✔

11036

538✔

11037

            if (obj.constructor === Object) {

639✔

11044

40✔

11048

            return obj.constructor.name.toLowerCase();

101✔

11049

101✔

11050

16,295,164✔

11051

    if (obj === undefined) {

40,015,995✔

11052

        return 'void';

170✔

11053

170✔

11054

    return typeof obj;

23,720,655✔

11055

40,015,995✔

11056

// -------------------------------------------------------------------------

1✔

11057

// :; wrap tree of Promises with single Promise or return argument as is

1✔

11058

// :: if tree have no Promises

1✔

11059

// -------------------------------------------------------------------------

1✔

11060

function resolve_promises(arg) {

9,944,569✔

11061

    var promises = [];

9,944,569✔

11062

    traverse(arg);

9,944,569✔

11063

    if (promises.length) {

9,944,569✔

11064

        return resolve(arg);

8,204✔

11065

8,204✔

11066

    return arg;

9,936,365✔

11067

    function traverse(node) {

9,936,365✔

11068

        if (is_promise(node)) {

239,310,937✔

11069

            promises.push(node);

8,204✔

11070

        } else if (is_pair(node)) {

239,310,937✔

11071

            if (!node.have_cycles('car')) {

114,421,137✔

11072

                traverse(node.car);

114,421,136✔

11073

114,421,136✔

11074

            if (!node.have_cycles('cdr')) {

114,421,137✔

11075

                traverse(node.cdr);

114,421,125✔

11076

114,421,125✔

11077

        } else if (node instanceof Array) {

239,302,733✔

11078

            node.forEach(traverse);

348,871✔

11079

348,871✔

11080

239,310,937✔

11081

    async function promise(node) {

9,936,365✔

11091

    function resolve(node) {

9,936,365✔

11098

        return node;

8,204✔

11099

8,204✔

11100

9,944,569✔

11101

// -------------------------------------------------------------------------

1✔

11102

function evaluate_args(rest, { use_dynamic, ...options }) {

2,737,447✔

11103

    var args = [];

2,737,447✔

11104

    var node = rest;

2,737,447✔

11105

    function next() {

2,737,447✔

11106

        return args;

2,737,440✔

11107

2,737,440✔

11108

    return (function loop() {

2,737,447✔

11109

        if (is_pair(node)) {

6,391,609✔

11110

            let arg = evaluate(node.car, { use_dynamic, ...options });

3,654,168✔

11111

            if (use_dynamic) {

3,654,168✔

11112

                // NOTE: why native function need bind to env?

238,557✔

11113

                arg = unpromise(arg, arg => {

238,557✔

11117

                    return arg;

238,557✔

11118

});

238,557✔

11119

238,557✔

11120

            return unpromise(resolve_promises(arg), function(arg) {

3,654,164✔

11121

                args.push(arg);

3,654,162✔

11125

                node = node.cdr;

3,654,162✔

11126

                return loop();

3,654,162✔

11127

});

3,654,164✔

11128

        } else if (is_nil(node)) {

6,391,609✔

11129

            return next();

2,737,440✔

11130

        } else {

2,737,441✔

11131

            throw new Error('Syntax Error: improper list found in apply');

1✔

11132

1✔

11133

    })();

2,737,447✔

11134

2,737,447✔

11135

// -------------------------------------------------------------------------

1✔

11136

function evaluate_syntax(macro, code, eval_args) {

513✔

11137

    var value = macro.invoke(code, eval_args);

513✔

11138

    return unpromise(resolve_promises(value), function(value) {

513✔

11139

        if (is_pair(value)) {

477✔

11140

            value.mark_cycles();

241✔

11141

241✔

11142

        return quote(value);

477✔

11143

});

513✔

11144

513✔

11145

// -------------------------------------------------------------------------

1✔

11146

function evaluate_macro(macro, code, eval_args) {

3,432,729✔

11147

    function finalize(result) {

3,432,729✔

11148

        if (is_pair(result)) {

757,635✔

11149

            result.mark_cycles();

640✔

11150

            return result;

640✔

11151

640✔

11152

        return quote(result);

756,995✔

11153

757,635✔

11154

    const value = macro.invoke(code, eval_args);

3,432,729✔

11155

    return unpromise(resolve_promises(value), function ret(value) {

3,432,729✔

11156

        if (!value || value && value[__data__] || self_evaluated(value)) {

3,432,362✔

11157

            return value;

2,674,701✔

11158

        } else {

3,432,362✔

11159

            return unpromise(evaluate(value, eval_args), finalize);

757,661✔

11160

757,661✔

11161

    }, error => {

3,432,729✔

11162

        throw error;

72✔

11163

});

3,432,729✔

11164

3,432,729✔

11165

1✔

11166

// -------------------------------------------------------------------------

1✔

11167

function prepare_fn_args(fn, args) {

2,741,484✔

11168

    if (is_bound(fn) && !is_object_bound(fn) &&

2,741,484✔

11169

        (!lips_context(fn) || is_port_method(fn))) {

2,741,484✔

11170

        args = args.map(unbox);

51,074✔

11171

51,074✔

11172

    if (!is_raw_lambda(fn) &&

2,741,484✔

11173

        args.some(is_lips_function) &&

2,741,484✔

11174

        !is_lips_function(fn) &&

2,741,484✔

11175

        !is_array_method(fn)) {

2,741,484✔

11176

        // we unbox values from callback functions #76

2,053✔

11177

        // calling map on array should not unbox the value

2,053✔

11178

        var result = [], i = args.length;

2,053✔

11179

        while (i--) {

2,053✔

11180

            let arg = args[i];

2,556✔

11181

            if (is_lips_function(arg)) {

2,556✔

11182

                var wrapper = function(...args) {

2,059✔

11183

                    return unpromise(arg.apply(this, args), unbox);

2,044✔

11184

};

2,059✔

11185

                // make wrapper work like output of bind

2,059✔

11186

                hidden_prop(wrapper, '__bound__', true);

2,059✔

11187

                hidden_prop(wrapper, '__fn__', arg);

2,059✔

11188

                // copy prototype from function to wrapper

2,059✔

11189

                // so this work when calling new from JavaScript

2,059✔

11190

                // case of Preact that pass LIPS class as argument

2,059✔

11191

                // to h function

2,059✔

11192

                wrapper.prototype = arg.prototype;

2,059✔

11193

                result[i] = wrapper;

2,059✔

11194

            } else {

2,556✔

11195

                result[i] = arg;

497✔

11196

497✔

11197

2,556✔

11198

        args = result;

2,053✔

11199

2,053✔

11200

    return args;

2,741,484✔

11201

2,741,484✔

11202

1✔

11203

// -------------------------------------------------------------------------

1✔

11204

function call_function(fn, args, { env, dynamic_env, use_dynamic } = {}) {

2,784,008✔

11205

    const scope = env?.new_frame(fn, args);

2,784,008✔

11206

    const dynamic_scope = dynamic_env?.new_frame(fn, args);

2,784,008✔

11207

    const context = new LambdaContext({

2,784,008✔

11208

        env: scope,

2,784,008✔

11209

        use_dynamic,

2,784,008✔

11210

        dynamic_env: dynamic_scope

2,784,008✔

11211

});

2,784,008✔

11212

    return resolve_promises(fn.apply(context, args));

2,784,008✔

11213

2,784,008✔

11214

1✔

11215

// -------------------------------------------------------------------------

1✔

11216

function apply(fn, args, { env, dynamic_env, use_dynamic, error = () => {} } = {}) {

2,737,447✔

11217

    args = evaluate_args(args, { env, dynamic_env, error, use_dynamic });

2,737,447✔

11218

    return unpromise(args, function(args) {

2,737,447✔

11219

        if (is_raw_lambda(fn)) {

2,737,440✔

11220

            // lambda need environment as context

621,269✔

11221

            // normal functions are bound to their contexts

621,269✔

11222

            fn = unbind(fn);

621,269✔

11223

621,269✔

11224

        args = prepare_fn_args(fn, args);

2,737,440✔

11225

        const _args = args.slice();

2,737,440✔

11226

        const result = call_function(fn, _args, { env, dynamic_env, use_dynamic });

2,737,440✔

11227

        return unpromise(result, (result) => {

2,737,440✔

11228

            if (is_pair(result)) {

2,737,351✔

11229

                result.mark_cycles();

349,937✔

11230

                return quote(result);

349,937✔

11231

349,937✔

11232

            return box(result);

2,387,414✔

11233

        }, error);

2,737,440✔

11234

});

2,737,447✔

11235

2,737,447✔

11236

// -------------------------------------------------------------------------

1✔

11237

// :: Parameters for make-parameter and parametrize

1✔

11238

// -------------------------------------------------------------------------

1✔

11239

class Parameter {

13✔

11240

    __value__;

13✔

11241

    __fn__;

13✔

11242

    #__p_name__;

13✔

11243

    constructor(init, fn = null, name = null) {

13✔

11244

        this.__value__ = init;

13✔

11245

        if (fn) {

13✔

11250

            this.__fn__ = fn;

2✔

11251

2✔

11252

        if (name) {

13✔

11253

            this.#__p_name__ = name;

7✔

11254

7✔

11255

13✔

11256

    get __name__() {

13✔

11257

        return this.#__p_name__;

33✔

11258

33✔

11259

    set __name__(name) {

13✔

11260

        this.#__p_name__ = name;

6✔

11261

        if (this.__fn__) {

6✔

11262

            this.__fn__.__name__ = `fn-${name}`;

1✔

11263

1✔

11264

6✔

11265

    invoke() {

13✔

11266

        if (is_function(this.__fn__)) {

13✔

11267

            return this.__fn__(this.__value__);

2✔

11268

2✔

11269

        return this.__value__;

11✔

11270

13✔

11271

    inherit(value) {

13✔

11272

        return new Parameter(value, this.__fn__, this.__name__);

7✔

11273

7✔

11274

13✔

11275

// -------------------------------------------------------------------------

1✔

11276

class LambdaContext {

2,784,008✔

11277

    env;

2,784,008✔

11278

    dynamic_env;

2,784,008✔

11279

    use_dynamic;

2,784,008✔

11280

    constructor(payload) {

2,784,008✔

11281

        Object.assign(this, payload);

2,784,008✔

11282

2,784,008✔

11283

    get __name__() {

2,784,008✔

11284

        return this.env.__name__;

32✔

11285

32✔

11286

    get __parent__() {

2,784,008✔

11287

        return this.env.__parent__;

32✔

11288

32✔

11289

    get(...args) {

2,784,008✔

11290

        return this.env.get(...args);

153✔

11291

153✔

11292

2,784,008✔

11293

// -------------------------------------------------------------------------

1✔

11294

function search_param(env, param) {

15✔

11295

    let candidate = env.get(param.__name__, { throwError: false });

15✔

11296

    if (is_parameter(candidate) && candidate !== param) {

15✔

11297

        return candidate;

8✔

11298

8✔

11299

    let is_first_env = true;

7✔

11300

    const top_env = user_env.get('**interaction-environment**');

7✔

11301

    while (true) {

15✔

11302

        const parent = env.get('parent.frame', { throwError: false });

12✔

11303

        env = parent(0);

12✔

11304

        if (env === top_env) {

12✔

11305

            break;

7✔

11306

7✔

11307

        is_first_env = false;

5✔

11308

        candidate = env.get(param.__name__, { throwError: false });

5✔

11312

12✔

11313

    return param;

7✔

11314

15✔

11315

1✔

11316

// -------------------------------------------------------------------------

1✔

11317

// :: Continuations object from call/cc

1✔

11318

// -------------------------------------------------------------------------

1✔

11319

class Continuation {

12✔

11320

    __value__;

12✔

11321

    constructor(k) {

12✔

11322

        this.__value__ = k;

12✔

11323

12✔

11324

    invoke() {

12✔

11325

        if (this.__value__ === null) {

8✔

11326

            throw new Error('Continuations are not implemented yet');

8✔

11327

8✔

11328

8✔

11329

12✔

11330

1✔

11331

// -------------------------------------------------------------------------

1✔

11332

function evaluate(code, { env, dynamic_env, use_dynamic, error = noop, ...rest } = {}) {

11,437,019✔

11333

    try {

11,437,019✔

11334

        if (!is_env(dynamic_env)) {

11,437,019✔

11336

130✔

11337

        if (use_dynamic) {

11,437,019✔

11338

            env = dynamic_env;

811,112✔

11341

        } else {

10,625,907✔

11342

            env = env || global_env;

10,625,907✔

11343

10,625,907✔

11344

        var eval_args = { env, dynamic_env, use_dynamic, error };

11,437,019✔

11345

        var value;

11,437,019✔

11346

        if (is_null(code)) {

11,437,019✔

11347

            return code;

2,854✔

11348

2,854✔

11349

        if (code instanceof LSymbol) {

11,437,019✔

11350

            return env.get(code);

3,853,109✔

11351

3,853,109✔

11352

        if (!is_pair(code)) {

11,437,019✔

11353

            return code;

1,410,327✔

11354

1,410,327✔

11355

        var first = code.car;

6,170,729✔

11356

        var rest = code.cdr;

6,170,729✔

11357

        if (is_pair(first)) {

11,437,019✔

11358

            value = resolve_promises(evaluate(first, eval_args));

1,012✔

11359

            if (is_promise(value)) {

1,012✔

11360

                return value.then((value) => {

3✔

11361

                    if (!is_callable(value)) {

3✔

11362

                        throw new Error(

1✔

11363

                            type(value) + ' ' + env.get('repr')(value) +

1✔

11364

                                ' is not callable while evaluating ' + code.toString()

1✔

11365

);

1✔

11366

1✔

11367

                    return evaluate(new Pair(value, code.cdr), eval_args);

2✔

11368

});

3✔

11369

                // else is later in code

3✔

11376

1,012✔

11377

        if (first instanceof LSymbol) {

11,437,019✔

11378

            value = env.get(first);

6,169,715✔

11379

        } else if (is_function(first)) {

11,437,019✔

11380

            value = first;

2✔

11381

2✔

11382

        let result;

6,170,721✔

11383

        if (value instanceof Syntax) {

11,437,019✔

11384

            result = evaluate_syntax(value, code, eval_args);

502✔

11385

        } else if (value instanceof Macro) {

11,437,019✔

11386

            result = evaluate_macro(value, rest, eval_args);

3,432,729✔

11387

        } else if (is_function(value)) {

6,170,219✔

11388

            result = apply(value, rest, eval_args);

2,737,447✔

11389

        } else if (value instanceof SyntaxParameter) {

2,737,490✔

11390

            result = evaluate_syntax(value._syntax, code, eval_args);

11✔

11391

        } else if (is_parameter(value)) {

43✔

11392

            const param = search_param(dynamic_env, value);

15✔

11393

            if (is_null(code.cdr)) {

15✔

11394

                result = param.invoke();

13✔

11395

            } else {

15✔

11396

                return unpromise(evaluate(code.cdr.car, eval_args), function(value) {

2✔

11397

                    param.__value__ = value;

2✔

11398

});

2✔

11399

2✔

11400

        } else if (is_continuation(value)) {

32✔

11401

            result = value.invoke();

8✔

11402

        } else if (is_pair(code)) {

17✔

11403

            value = first && first.toString();

9✔

11404

            throw new Error(`${type(first)} ${value} is not a function`);

9✔

11408

        // escape promise feature #54

6,170,286✔

11409

        var __promise__ = env.get(Symbol.for('__promise__'), { throwError: false });

6,170,286✔

11410

        if (__promise__ === true && is_promise(result)) {

11,437,019✔

11411

            // fix #139 evaluate the code inside the promise that is not data.

12✔

11412

            // When promise is not quoted it happen automatically, when returning

12✔

11413

            // promise from evaluate.

12✔

11414

            result = result.then(result => {

12✔

11418

                return result;

10✔

11419

});

12✔

11420

            return new QuotedPromise(result);

12✔

11421

12✔

11422

        return result;

6,170,274✔

11423

    } catch (e) {

11,437,019✔

11424

        error && error.call(env, e, code);

450✔

11425

450✔

11426

11,437,019✔

11427

// -------------------------------------------------------------------------

1✔

11428

const compile = exec_collect(function(code) {

1✔

11430

});

1✔

11431

// -------------------------------------------------------------------------

1✔

11432

const exec = exec_collect(function(code, value) {

1✔

11433

    return value;

881✔

11434

});

1✔

11435

// -------------------------------------------------------------------------

1✔

11436

function exec_with_stacktrace(code, { env, dynamic_env, use_dynamic } = {}) {

881✔

11437

    return evaluate(code, {

881✔

11438

        env,

881✔

11439

        dynamic_env,

881✔

11440

        use_dynamic,

881✔

11441

        error: (e, code) => {

881✔

11442

            if (e && e.message) {

257✔

11448

                if (code) {

256✔

11449

                    // LIPS stack trace

252✔

11450

                    if (!(e.__code__ instanceof Array)) {

252✔

11451

                        e.__code__ = [];

36✔

11452

36✔

11453

                    e.__code__.push(code.toString(true));

252✔

11454

252✔

11455

256✔

11456

            if (!(e instanceof IgnoreException)) {

257✔

11457

                throw e;

257✔

11458

257✔

11459

257✔

11460

});

881✔

11461

881✔

11462

// -------------------------------------------------------------------------

1✔

11463

function exec_collect(collect_callback) {

2✔

11464

    return async function exec_lambda(arg, { env, dynamic_env, use_dynamic } = {}) {

2✔

11465

        if (!is_env(dynamic_env)) {

6✔

11467

6✔

11470

        } else {

6✔

11471

            env = env || user_env;

6✔

11472

6✔

11473

        const results = [];

6✔

11477

        const input = Array.isArray(arg) ? arg : _parse(arg);

6✔

11478

        for await (let code of input) {

6✔

11479

            const value = await exec_with_stacktrace(code, { env, dynamic_env, use_dynamic });

881✔

11480

            results.push(collect_callback(code, value));

881✔

11481

881✔

11482

        return results;

5✔

11483

};

2✔

11484

2✔

11485

// -------------------------------------------------------------------------

1✔

11486

function balanced(code) {

33✔

11487

    var maching_pairs = {

33✔

11488

        '[': ']',

33✔

11489

        '(': ')'

33✔

11490

};

33✔

11491

    var tokens;

33✔

11501

    } else {

33✔

11503

33✔

11504

33✔

11505

    var open_tokens = Object.keys(maching_pairs);

33✔

11506

    var brackets = Object.values(maching_pairs).concat(open_tokens);

33✔

11507

    tokens = tokens.filter(token => brackets.includes(token));

33✔

11508

33✔

11509

    const stack = new Stack();

33✔

11510

    for (const token of tokens) {

33✔

11511

        if (open_tokens.includes(token)) {

233✔

11512

            stack.push(token);

133✔

11513

        } else if (!stack.is_empty()) { // closing token

233✔

11514

            var last = stack.top();

100✔

11515

            // last on stack need to match

100✔

11516

            const closing_token = maching_pairs[last];

100✔

11517

            if (token === closing_token) {

100✔

11518

                stack.pop();

100✔

11526

233✔

11527

    return stack.is_empty();

33✔

11528

33✔

11529

1✔

11530

// -------------------------------------------------------------------------

1✔

11548

1✔

11549

// -------------------------------------------------------------------------

1✔

11553

1✔

11554

// -------------------------------------------------------------------------

1✔

11555

function get_current_script() {

1✔

11556

    if (is_node()) {

1✔

11557

        return;

1✔

11558

1✔

11571

1✔

11572

1✔

11573

// -------------------------------------------------------------------------

1✔

11574

const current_script = get_current_script();

1✔

11575

1✔

11576

// -------------------------------------------------------------------------

1✔

11592

// -------------------------------------------------------------------------

1✔

11676

1✔

11677

// -------------------------------------------------------------------------

1✔

11678

// :: Serialization

1✔

11679

// -------------------------------------------------------------------------

1✔

11680

var serialization_map = {

1✔

11681

    'pair': ([car, cdr]) => Pair(car, cdr),

1✔

11682

    'number': function(value) {

1✔

11683

        if (LString.isString(value)) {

290✔

11684

            return LNumber([value, 10]);

280✔

11685

280✔

11686

        return LNumber(value);

10✔

11687

},

1✔

11688

    'regex': function([pattern, flag]) {

1✔

11689

        return new RegExp(pattern, flag);

7✔

11690

},

1✔

11691

    'nil': function() {

1✔

11692

        return nil;

6,125✔

11693

},

1✔

11694

    'symbol': function(value) {

1✔

11695

        if (LString.isString(value)) {

10,126✔

11696

            return LSymbol(value);

10,126✔

11700

},

1✔

11701

    'string': LString,

1✔

11702

    'character': LCharacter

1✔

11703

};

1✔

11704

// -------------------------------------------------------------------------

1✔

11705

// class mapping to create smaller JSON

1✔

11706

const available_class = Object.keys(serialization_map);

1✔

11707

const class_map = {};

1✔

11708

for (let [i, cls] of Object.entries(available_class)) {

1✔

11709

    class_map[cls] = +i;

7✔

11710

7✔

11711

function mangle_name(name) {

50✔

11712

    return class_map[name];

50✔

11713

50✔

11714

function resolve_name(i) {

19✔

11715

    return available_class[i];

19✔

11716

19✔

11717

// -------------------------------------------------------------------------

1✔

11718

function serialize(data) {

1✔

11719

    return JSON.stringify(data, function(key, value) {

1✔

11720

        const v0 = this[key];

59✔

11721

        if (v0) {

59✔

11722

            if (v0 instanceof RegExp) {

50✔

11723

                return {

1✔

11724

                    '@': mangle_name('regex'),

1✔

11725

                    '#': [v0.source, v0.flags]

1✔

11726

};

1✔

11727

1✔

11728

            var cls = mangle_name(v0.constructor.__class__);

49✔

11729

            if (!is_undef(cls)) {

50✔

11730

                return {

18✔

11731

                    '@': cls,

18✔

11732

                    '#': v0.serialize()

18✔

11733

};

18✔

11734

18✔

11735

50✔

11736

        return value;

40✔

11737

});

1✔

11738

1✔

11739

// -------------------------------------------------------------------------

1✔

11740

function unserialize(string) {

1✔

11741

    return JSON.parse(string, (_, object) => {

1✔

11742

        if (object && typeof object === 'object') {

59✔

11743

            if (!is_undef(object['@'])) {

29✔

11744

                var cls = resolve_name(object['@']);

19✔

11745

                if (serialization_map[cls]) {

19✔

11746

                    return serialization_map[cls](object['#']);

19✔

11747

19✔

11748

19✔

11749

29✔

11750

        return object;

40✔

11751

});

1✔

11752

1✔

11753

1✔

11754

// -------------------------------------------------------------------------

1✔

11755

// binary serialization using CBOR binary data format

1✔

11756

// -------------------------------------------------------------------------

1✔

11757

const cbor = (function() {

1✔

11758

1✔

11759

    var types = {

1✔

11760

        'pair': Pair,

1✔

11761

        'symbol': LSymbol,

1✔

11762

        'number': LNumber,

1✔

11763

        'string': LString,

1✔

11764

        'character': LCharacter,

1✔

11765

        'nil': nil.constructor,

1✔

11766

        'regex': RegExp

1✔

11767

};

1✔

11768

1✔

11769

    function serializer(Class, fn) {

1✔

11770

        return {

7✔

11771

            deserialize: fn,

7✔

11772

            Class

7✔

11773

};

7✔

11774

7✔

11775

1✔

11776

    var encoder = new Encoder();

1✔

11777

1✔

11778

    const cbor_serialization_map = {};

1✔

11779

    for (const [ name, fn ] of Object.entries(serialization_map)) {

1✔

11780

        const Class = types[name];

7✔

11781

        cbor_serialization_map[name] = serializer(Class, fn);

7✔

11782

7✔

11783

    // add CBOR data mapping

1✔

11784

    let tag = 43311;

1✔

11785

    Object.keys(cbor_serialization_map).forEach(type => {

1✔

11786

        const data = cbor_serialization_map[type];

7✔

11799

        } else {

7✔

11800

            const { deserialize, Class } = data;

7✔

11801

            addExtension({

7✔

11802

                Class,

7✔

11803

                tag,

7✔

11804

                encode(instance, encode) {

7✔

11809

},

7✔

11810

                decode(data) {

7✔

11811

                    return deserialize(data);

34,681✔

11812

34,681✔

11813

});

7✔

11814

7✔

11815

        tag++;

7✔

11816

});

1✔

11817

    return encoder;

1✔

11818

})();

1✔

11819

1✔

11820

// -------------------------------------------------------------------------

1✔

11835

1✔

11836

// -------------------------------------------------------------------------

1✔

11842

1✔

11843

// -------------------------------------------------------------------------

1✔

11844

const MAGIC_LENGTH = 7;

1✔

11845

1✔

11846

// -------------------------------------------------------------------------

1✔

11847

function decode_magic(obj) {

1✔

11848

    const decoder = new TextDecoder('utf-8');

1✔

11849

    const prefix = decoder.decode(obj.slice(0, MAGIC_LENGTH));

1✔

11850

    const name = prefix.substring(0, 4);

1✔

11851

    if (name === 'LIPS') {

1✔

11852

        const m = prefix.match(/^(....).*([0-9]+)$/);

1✔

11853

        if (m) {

1✔

11854

            return {

1✔

11855

                type: m[1],

1✔

11856

                version: Number(m[2])

1✔

11857

};

1✔

11858

1✔

11859

1✔

11863

1✔

11864

1✔

11865

// -------------------------------------------------------------------------

1✔

11871

1✔

11872

// -------------------------------------------------------------------------

1✔

11873

function unserialize_bin(data) {

1✔

11874

    const { type, version } = decode_magic(data);

1✔

11875

    if (type === 'LIPS' && version === 1) {

1✔

11876

        const arr = unpack(data.slice(MAGIC_LENGTH), { magic: false });

1✔

11877

        return cbor.decode(arr);

1✔

11881

1✔

11882

1✔

11883

// -------------------------------------------------------------------------

1✔

11890

1✔

11891

// -------------------------------------------------------------------------

1✔

11961

// this can't be in init function, because it need to be in script context

1✔

11964

// -------------------------------------------------------------------------

1✔

11968

// -------------------------------------------------------------------------

1✔

11969

var banner = (function() {

1✔

11970

    // Rollup tree-shaking is removing the variable if it's normal string because

1✔

11971

    // obviously '{{DATE}}' == '{{' + 'DATE}}'; can be removed

1✔

11972

    // but disabling Tree-shaking is adding lot of not used code so we use this

1✔

11973

    // hack instead

1✔

11974

    var date = LString('{{DATE}}').valueOf();

1✔

11976

    var _format = x => x.toString().padStart(2, '0');

1✔

11977

    var _year = _date.getFullYear();

1✔

11978

    var _build = [

1✔

11979

        _year,

1✔

11980

        _format(_date.getMonth() + 1),

1✔

11981

        _format(_date.getDate())

1✔

11982

    ].join('-');

1✔

11983

    var banner = `

1✔

11984

  __ __                          __

1✔

11985

 / / \\ \\       _    _  ___  ___  \\ \\

1✔

11986

| |   \\ \\     | |  | || . \\/ __>  | |

1✔

11987

| |    > \\    | |_ | ||  _/\\__ \\  | |

1✔

11988

| |   / ^ \\   |___||_||_|  <___/  | |

1✔

11989

 \\_\\ /_/ \\_\\                     /_/

1✔

11990

1✔

11991

LIPS Interpreter {{VER}} (${_build}) <https://lips.js.org>

1✔

11992

Copyright (c) 2018-${_year} Jakub T. Jankiewicz

1✔

11993

1✔

11994

Type (env) to see environment with functions macros and variables. You can also

1✔

11995

use (help name) to display help for specific function or macro, (apropos name)

1✔

11996

to display list of matched names in environment and (dir object) to list

1✔

11997

properties of an object.

1✔

11998

`.replace(/^.*\n/, '');

1✔

11999

    return banner;

1✔

12000

})();

1✔

12001

// -------------------------------------------------------------------------

1✔

12002

// to be used with string function when code is minified

1✔

12003

// -------------------------------------------------------------------------

1✔

12004

read_only(Ahead, '__class__', 'ahead');

1✔

12005

read_only(Pair, '__class__', 'pair');

1✔

12006

read_only(Nil, '__class__', 'nil');

1✔

12007

read_only(Pattern, '__class__', 'pattern');

1✔

12008

read_only(Formatter, '__class__', 'formatter');

1✔

12009

read_only(Macro, '__class__', 'macro');

1✔

12010

read_only(Syntax, '__class__', 'syntax');

1✔

12011

read_only(Syntax.Parameter, '__class__', 'syntax-parameter');

1✔

12012

read_only(Environment, '__class__', 'environment');

1✔

12013

read_only(InputPort, '__class__', 'input-port');

1✔

12014

read_only(OutputPort, '__class__', 'output-port');

1✔

12015

read_only(BufferedOutputPort, '__class__', 'output-port');

1✔

12016

read_only(OutputStringPort, '__class__', 'output-string-port');

1✔

12017

read_only(InputStringPort, '__class__', 'input-string-port');

1✔

12018

read_only(InputFilePort, '__class__', 'input-file-port');

1✔

12019

read_only(OutputFilePort, '__class__', 'output-file-port');

1✔

12020

read_only(LipsError, '__class__', 'lips-error');

1✔

12021

[LNumber, LComplex, LRational, LFloat, LBigInteger].forEach(cls => {

1✔

12022

    read_only(cls, '__class__', 'number');

5✔

12023

});

1✔

12024

read_only(LCharacter, '__class__', 'character');

1✔

12025

read_only(LSymbol, '__class__', 'symbol');

1✔

12026

read_only(LString, '__class__', 'string');

1✔

12027

read_only(QuotedPromise, '__class__', 'promise');

1✔

12028

read_only(Parameter, '__class__', 'parameter');

1✔

12029

// -------------------------------------------------------------------------

1✔

12030

const version = '{{VER}}';

1✔

12031

const date = '{{DATE}}';

1✔

12032

1✔

12033

// unwrap async generator into Promise<Array>

1✔

12034

const parse = compose(uniterate_async, _parse);

1✔

12035

1✔

12036

export {

1✔

12037

    version,

1✔

12038

    banner,

1✔

12039

    date,

1✔

12040

    exec,

1✔

12041

    parse,

1✔

12042

    tokenize,

1✔

12043

    evaluate,

1✔

12044

    compile,

1✔

12045

1✔

12046

    serialize,

1✔

12047

    unserialize,

1✔

12048

1✔

12049

    serialize_bin,

1✔

12050

    unserialize_bin,

1✔

12051

1✔

12052

    bootstrap,

1✔

12053

1✔

12054

    Environment,

1✔

12055

    user_env as env,

1✔

12056

1✔

12057

    Worker,

1✔

12058

1✔

12059

    Interpreter,

1✔

12060

    balanced as balanced_parenthesis,

1✔

12061

    balanced as balancedParenthesis,

1✔

12062

    balanced,

1✔

12063

1✔

12064

    Macro,

1✔

12065

    Syntax,

1✔

12066

    Pair,

1✔

12067

    Values,

1✔

12068

    QuotedPromise,

1✔

12069

    LipsError as Error,

1✔

12070

    is_directive as _is_directive,

1✔

12071

1✔

12072

    quote,

1✔

12073

1✔

12074

    InputPort,

1✔

12075

    OutputPort,

1✔

12076

    BufferedOutputPort,

1✔

12077

    InputFilePort,

1✔

12078

    OutputFilePort,

1✔

12079

    InputStringPort,

1✔

12080

    OutputStringPort,

1✔

12081

    InputByteVectorPort,

1✔

12082

    OutputByteVectorPort,

1✔

12083

    InputBinaryFilePort,

1✔

12084

    OutputBinaryFilePort,

1✔

12085

    set_fs,

1✔

12086

1✔

12087

    Formatter,

1✔

12088

    Parser,

1✔

12089

    Lexer,

1✔

12090

    specials,

1✔

12091

    repr,

1✔

12092

    nil,

1✔

12093

    eof,

1✔

12094

1✔

12095

    LSymbol,

1✔

12096

    LNumber,

1✔

12097

    LFloat,

1✔

12098

    LComplex,

1✔

12099

    LRational,

1✔

12100

    LBigInteger,

1✔

12101

    LCharacter,

1✔

12102

    LString,

1✔

12103

    Parameter,

1✔

12104

    rationalize

1✔

12105

};

1✔

12106

const lips = {

1✔

12107

    version,

1✔

12108

    banner,

1✔

12109

    date,

1✔

12110

    exec,

1✔

12111

    parse,

1✔

12112

    tokenize,

1✔

12113

    evaluate,

1✔

12114

    compile,

1✔

12115

1✔

12116

    serialize,

1✔

12117

    unserialize,

1✔

12118

1✔

12119

    serialize_bin,

1✔

12120

    unserialize_bin,

1✔

12121

1✔

12122

    bootstrap,

1✔

12123

1✔

12124

    Environment,

1✔

12125

    env: user_env,

1✔

12126

1✔

12127

    Worker,

1✔

12128

1✔

12129

    Interpreter,

1✔

12130

    balanced_parenthesis: balanced,

1✔

12131

    balancedParenthesis: balanced,

1✔

12132

    balanced,

1✔

12133

1✔

12134

    Macro,

1✔

12135

    Syntax,

1✔

12136

    Pair,

1✔

12137

    Values,

1✔

12138

    QuotedPromise,

1✔

12139

    Error: LipsError,

1✔

12140

1✔

12141

    quote,

1✔

12142

1✔

12143

    InputPort,

1✔

12144

    OutputPort,

1✔

12145

    BufferedOutputPort,

1✔

12146

    InputFilePort,

1✔

12147

    OutputFilePort,

1✔

12148

    InputStringPort,

1✔

12149

    OutputStringPort,

1✔

12150

    InputByteVectorPort,

1✔

12151

    OutputByteVectorPort,

1✔

12152

    InputBinaryFilePort,

1✔

12153

    OutputBinaryFilePort,

1✔

12154

    set_fs,

1✔

12155

1✔

12156

    Formatter,

1✔

12157

    Parser,

1✔

12158

    Lexer,

1✔

12159

    specials,

1✔

12160

    repr,

1✔

12161

    nil,

1✔

12162

    eof,

1✔

12163

1✔

12164

    LSymbol,

1✔

12165

    LNumber,

1✔

12166

    LFloat,

1✔

12167

    LComplex,

1✔

12168

    LRational,

1✔

12169

    LBigInteger,

1✔

12170

    LCharacter,

1✔

12171

    LString,

1✔

12172

    Parameter,

1✔

12173

    rationalize

1✔

12174

};

1✔

12175

global_env.set('lips', lips);

1✔

jcubic / lips / 12259396045

Source File
Press 'n' to go to next uncovered line, 'b' for previous

jcubic / lips / 12259396045

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous