This is page 1 of 2. Use http://codebase.md/jacck/mcp-reasoner?page={x} to view the full context.
# Directory Structure
```
├── .gitignore
├── dist
│ ├── index.d.ts
│ ├── index.js
│ ├── reasoner.d.ts
│ ├── reasoner.js
│ ├── state.d.ts
│ ├── state.js
│ ├── strategies
│ │ ├── base.d.ts
│ │ ├── base.js
│ │ ├── beam-search.d.ts
│ │ ├── beam-search.js
│ │ ├── factory.d.ts
│ │ ├── factory.js
│ │ ├── mcts.d.ts
│ │ └── mcts.js
│ ├── types.d.ts
│ └── types.js
├── LICENSE
├── node_modules
│ ├── .bin
│ │ ├── resolve
│ │ ├── resolve.cmd
│ │ ├── resolve.ps1
│ │ ├── shjs
│ │ ├── shjs.cmd
│ │ ├── shjs.ps1
│ │ ├── shx
│ │ ├── shx.cmd
│ │ ├── shx.ps1
│ │ ├── tsc
│ │ ├── tsc.cmd
│ │ ├── tsc.ps1
│ │ ├── tsserver
│ │ ├── tsserver.cmd
│ │ └── tsserver.ps1
│ ├── .package-lock.json
│ ├── @modelcontextprotocol
│ │ └── sdk
│ │ ├── dist
│ │ │ ├── cli.d.ts
│ │ │ ├── cli.d.ts.map
│ │ │ ├── cli.js
│ │ │ ├── cli.js.map
│ │ │ ├── client
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── index.test.d.ts
│ │ │ │ ├── index.test.d.ts.map
│ │ │ │ ├── index.test.js
│ │ │ │ ├── index.test.js.map
│ │ │ │ ├── sse.d.ts
│ │ │ │ ├── sse.d.ts.map
│ │ │ │ ├── sse.js
│ │ │ │ ├── sse.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ ├── stdio.test.js.map
│ │ │ │ ├── websocket.d.ts
│ │ │ │ ├── websocket.d.ts.map
│ │ │ │ ├── websocket.js
│ │ │ │ └── websocket.js.map
│ │ │ ├── inMemory.d.ts
│ │ │ ├── inMemory.d.ts.map
│ │ │ ├── inMemory.js
│ │ │ ├── inMemory.js.map
│ │ │ ├── inMemory.test.d.ts
│ │ │ ├── inMemory.test.d.ts.map
│ │ │ ├── inMemory.test.js
│ │ │ ├── inMemory.test.js.map
│ │ │ ├── server
│ │ │ │ ├── index.d.ts
│ │ │ │ ├── index.d.ts.map
│ │ │ │ ├── index.js
│ │ │ │ ├── index.js.map
│ │ │ │ ├── index.test.d.ts
│ │ │ │ ├── index.test.d.ts.map
│ │ │ │ ├── index.test.js
│ │ │ │ ├── index.test.js.map
│ │ │ │ ├── sse.d.ts
│ │ │ │ ├── sse.d.ts.map
│ │ │ │ ├── sse.js
│ │ │ │ ├── sse.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ └── stdio.test.js.map
│ │ │ ├── shared
│ │ │ │ ├── protocol.d.ts
│ │ │ │ ├── protocol.d.ts.map
│ │ │ │ ├── protocol.js
│ │ │ │ ├── protocol.js.map
│ │ │ │ ├── stdio.d.ts
│ │ │ │ ├── stdio.d.ts.map
│ │ │ │ ├── stdio.js
│ │ │ │ ├── stdio.js.map
│ │ │ │ ├── stdio.test.d.ts
│ │ │ │ ├── stdio.test.d.ts.map
│ │ │ │ ├── stdio.test.js
│ │ │ │ ├── stdio.test.js.map
│ │ │ │ ├── transport.d.ts
│ │ │ │ ├── transport.d.ts.map
│ │ │ │ ├── transport.js
│ │ │ │ └── transport.js.map
│ │ │ ├── types.d.ts
│ │ │ ├── types.d.ts.map
│ │ │ ├── types.js
│ │ │ └── types.js.map
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── @types
│ │ └── node
│ │ ├── assert
│ │ │ └── strict.d.ts
│ │ ├── assert.d.ts
│ │ ├── async_hooks.d.ts
│ │ ├── buffer.buffer.d.ts
│ │ ├── buffer.d.ts
│ │ ├── child_process.d.ts
│ │ ├── cluster.d.ts
│ │ ├── compatibility
│ │ │ ├── disposable.d.ts
│ │ │ ├── index.d.ts
│ │ │ ├── indexable.d.ts
│ │ │ └── iterators.d.ts
│ │ ├── console.d.ts
│ │ ├── constants.d.ts
│ │ ├── crypto.d.ts
│ │ ├── dgram.d.ts
│ │ ├── diagnostics_channel.d.ts
│ │ ├── dns
│ │ │ └── promises.d.ts
│ │ ├── dns.d.ts
│ │ ├── dom-events.d.ts
│ │ ├── domain.d.ts
│ │ ├── events.d.ts
│ │ ├── fs
│ │ │ └── promises.d.ts
│ │ ├── fs.d.ts
│ │ ├── globals.d.ts
│ │ ├── globals.typedarray.d.ts
│ │ ├── http.d.ts
│ │ ├── http2.d.ts
│ │ ├── https.d.ts
│ │ ├── index.d.ts
│ │ ├── inspector.d.ts
│ │ ├── LICENSE
│ │ ├── module.d.ts
│ │ ├── net.d.ts
│ │ ├── os.d.ts
│ │ ├── package.json
│ │ ├── path.d.ts
│ │ ├── perf_hooks.d.ts
│ │ ├── process.d.ts
│ │ ├── punycode.d.ts
│ │ ├── querystring.d.ts
│ │ ├── readline
│ │ │ └── promises.d.ts
│ │ ├── readline.d.ts
│ │ ├── README.md
│ │ ├── repl.d.ts
│ │ ├── sea.d.ts
│ │ ├── stream
│ │ │ ├── consumers.d.ts
│ │ │ ├── promises.d.ts
│ │ │ └── web.d.ts
│ │ ├── stream.d.ts
│ │ ├── string_decoder.d.ts
│ │ ├── test.d.ts
│ │ ├── timers
│ │ │ └── promises.d.ts
│ │ ├── timers.d.ts
│ │ ├── tls.d.ts
│ │ ├── trace_events.d.ts
│ │ ├── ts5.6
│ │ │ ├── buffer.buffer.d.ts
│ │ │ ├── globals.typedarray.d.ts
│ │ │ └── index.d.ts
│ │ ├── tty.d.ts
│ │ ├── url.d.ts
│ │ ├── util.d.ts
│ │ ├── v8.d.ts
│ │ ├── vm.d.ts
│ │ ├── wasi.d.ts
│ │ ├── worker_threads.d.ts
│ │ └── zlib.d.ts
│ ├── balanced-match
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── index.js
│ │ ├── LICENSE.md
│ │ ├── package.json
│ │ └── README.md
│ ├── brace-expansion
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── bytes
│ │ ├── History.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── Readme.md
│ ├── chalk
│ │ ├── license
│ │ ├── package.json
│ │ ├── readme.md
│ │ └── source
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── utilities.js
│ │ └── vendor
│ │ ├── ansi-styles
│ │ │ ├── index.d.ts
│ │ │ └── index.js
│ │ └── supports-color
│ │ ├── browser.d.ts
│ │ ├── browser.js
│ │ ├── index.d.ts
│ │ └── index.js
│ ├── concat-map
│ │ ├── .travis.yml
│ │ ├── example
│ │ │ └── map.js
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.markdown
│ │ └── test
│ │ └── map.js
│ ├── content-type
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── depd
│ │ ├── History.md
│ │ ├── index.js
│ │ ├── lib
│ │ │ └── browser
│ │ │ └── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── Readme.md
│ ├── fs.realpath
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── old.js
│ │ ├── package.json
│ │ └── README.md
│ ├── function-bind
│ │ ├── .eslintrc
│ │ ├── .github
│ │ │ ├── FUNDING.yml
│ │ │ └── SECURITY.md
│ │ ├── .nycrc
│ │ ├── CHANGELOG.md
│ │ ├── implementation.js
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ ├── .eslintrc
│ │ └── index.js
│ ├── glob
│ │ ├── common.js
│ │ ├── glob.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── sync.js
│ ├── hasown
│ │ ├── .eslintrc
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── .nycrc
│ │ ├── CHANGELOG.md
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── tsconfig.json
│ ├── http-errors
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── iconv-lite
│ │ ├── .github
│ │ │ └── dependabot.yml
│ │ ├── .idea
│ │ │ ├── codeStyles
│ │ │ │ ├── codeStyleConfig.xml
│ │ │ │ └── Project.xml
│ │ │ ├── iconv-lite.iml
│ │ │ ├── inspectionProfiles
│ │ │ │ └── Project_Default.xml
│ │ │ ├── modules.xml
│ │ │ └── vcs.xml
│ │ ├── Changelog.md
│ │ ├── encodings
│ │ │ ├── dbcs-codec.js
│ │ │ ├── dbcs-data.js
│ │ │ ├── index.js
│ │ │ ├── internal.js
│ │ │ ├── sbcs-codec.js
│ │ │ ├── sbcs-data-generated.js
│ │ │ ├── sbcs-data.js
│ │ │ ├── tables
│ │ │ │ ├── big5-added.json
│ │ │ │ ├── cp936.json
│ │ │ │ ├── cp949.json
│ │ │ │ ├── cp950.json
│ │ │ │ ├── eucjp.json
│ │ │ │ ├── gb18030-ranges.json
│ │ │ │ ├── gbk-added.json
│ │ │ │ └── shiftjis.json
│ │ │ ├── utf16.js
│ │ │ ├── utf32.js
│ │ │ └── utf7.js
│ │ ├── lib
│ │ │ ├── bom-handling.js
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ └── streams.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── inflight
│ │ ├── inflight.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── inherits
│ │ ├── inherits_browser.js
│ │ ├── inherits.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── interpret
│ │ ├── CHANGELOG
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── mjs-stub.js
│ │ ├── package.json
│ │ └── README.md
│ ├── is-core-module
│ │ ├── .eslintrc
│ │ ├── .nycrc
│ │ ├── CHANGELOG.md
│ │ ├── core.json
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ └── index.js
│ ├── minimatch
│ │ ├── LICENSE
│ │ ├── minimatch.js
│ │ ├── package.json
│ │ └── README.md
│ ├── minimist
│ │ ├── .eslintrc
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── .nycrc
│ │ ├── CHANGELOG.md
│ │ ├── example
│ │ │ └── parse.js
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ ├── all_bool.js
│ │ ├── bool.js
│ │ ├── dash.js
│ │ ├── default_bool.js
│ │ ├── dotted.js
│ │ ├── kv_short.js
│ │ ├── long.js
│ │ ├── num.js
│ │ ├── parse_modified.js
│ │ ├── parse.js
│ │ ├── proto.js
│ │ ├── short.js
│ │ ├── stop_early.js
│ │ ├── unknown.js
│ │ └── whitespace.js
│ ├── once
│ │ ├── LICENSE
│ │ ├── once.js
│ │ ├── package.json
│ │ └── README.md
│ ├── path-is-absolute
│ │ ├── index.js
│ │ ├── license
│ │ ├── package.json
│ │ └── readme.md
│ ├── path-parse
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── raw-body
│ │ ├── HISTORY.md
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── SECURITY.md
│ ├── rechoir
│ │ ├── .npmignore
│ │ ├── .travis.yml
│ │ ├── CHANGELOG
│ │ ├── index.js
│ │ ├── lib
│ │ │ ├── extension.js
│ │ │ ├── normalize.js
│ │ │ └── register.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── resolve
│ │ ├── .editorconfig
│ │ ├── .eslintrc
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── async.js
│ │ ├── bin
│ │ │ └── resolve
│ │ ├── example
│ │ │ ├── async.js
│ │ │ └── sync.js
│ │ ├── index.js
│ │ ├── lib
│ │ │ ├── async.js
│ │ │ ├── caller.js
│ │ │ ├── core.js
│ │ │ ├── core.json
│ │ │ ├── homedir.js
│ │ │ ├── is-core.js
│ │ │ ├── node-modules-paths.js
│ │ │ ├── normalize-options.js
│ │ │ └── sync.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── readme.markdown
│ │ ├── SECURITY.md
│ │ ├── sync.js
│ │ └── test
│ │ ├── core.js
│ │ ├── dotdot
│ │ │ ├── abc
│ │ │ │ └── index.js
│ │ │ └── index.js
│ │ ├── dotdot.js
│ │ ├── faulty_basedir.js
│ │ ├── filter_sync.js
│ │ ├── filter.js
│ │ ├── home_paths_sync.js
│ │ ├── home_paths.js
│ │ ├── list-exports
│ │ │ ├── .eslintignore
│ │ │ ├── .eslintrc
│ │ │ ├── .github
│ │ │ │ ├── FUNDING.yml
│ │ │ │ └── workflows
│ │ │ │ ├── conditions.yml
│ │ │ │ ├── fixtures.yml
│ │ │ │ ├── ls-engines.yml
│ │ │ │ ├── node-pretest.yml
│ │ │ │ ├── node.yml
│ │ │ │ ├── rebase.yml
│ │ │ │ └── require-allow-edits.yml
│ │ │ ├── LICENSE
│ │ │ ├── package.json
│ │ │ ├── packages
│ │ │ │ ├── list-exports
│ │ │ │ │ ├── .eslintrc
│ │ │ │ │ ├── index.js
│ │ │ │ │ ├── package.json
│ │ │ │ │ └── README.md
│ │ │ │ ├── ls-exports
│ │ │ │ │ ├── .eslintrc
│ │ │ │ │ ├── bin
│ │ │ │ │ │ └── ls-exports
│ │ │ │ │ ├── exportsTable.js
│ │ │ │ │ ├── getPackageJSONPath.js
│ │ │ │ │ ├── package.json
│ │ │ │ │ ├── README.md
│ │ │ │ │ └── table.js
│ │ │ │ └── tests
│ │ │ │ ├── .eslintignore
│ │ │ │ ├── .eslintrc
│ │ │ │ ├── conditions-expected.js
│ │ │ │ ├── conditions.js
│ │ │ │ ├── fixtures
│ │ │ │ │ ├── es-abstract
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── 2015
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── AdvanceStringIndex.js
│ │ │ │ │ │ │ ├── ArrayCreate.js
│ │ │ │ │ │ │ ├── ArraySetLength.js
│ │ │ │ │ │ │ ├── ArraySpeciesCreate.js
│ │ │ │ │ │ │ ├── Call.js
│ │ │ │ │ │ │ ├── CanonicalNumericIndexString.js
│ │ │ │ │ │ │ ├── CompletePropertyDescriptor.js
│ │ │ │ │ │ │ ├── CreateDataProperty.js
│ │ │ │ │ │ │ ├── CreateDataPropertyOrThrow.js
│ │ │ │ │ │ │ ├── CreateHTML.js
│ │ │ │ │ │ │ ├── CreateIterResultObject.js
│ │ │ │ │ │ │ ├── CreateListFromArrayLike.js
│ │ │ │ │ │ │ ├── CreateMethodProperty.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── DefinePropertyOrThrow.js
│ │ │ │ │ │ │ ├── DeletePropertyOrThrow.js
│ │ │ │ │ │ │ ├── EnumerableOwnNames.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── Get.js
│ │ │ │ │ │ │ ├── GetIterator.js
│ │ │ │ │ │ │ ├── GetMethod.js
│ │ │ │ │ │ │ ├── GetOwnPropertyKeys.js
│ │ │ │ │ │ │ ├── GetPrototypeFromConstructor.js
│ │ │ │ │ │ │ ├── GetSubstitution.js
│ │ │ │ │ │ │ ├── GetV.js
│ │ │ │ │ │ │ ├── HasOwnProperty.js
│ │ │ │ │ │ │ ├── HasProperty.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── InstanceofOperator.js
│ │ │ │ │ │ │ ├── Invoke.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsArray.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsConcatSpreadable.js
│ │ │ │ │ │ │ ├── IsConstructor.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsExtensible.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsInteger.js
│ │ │ │ │ │ │ ├── IsPromise.js
│ │ │ │ │ │ │ ├── IsPropertyDescriptor.js
│ │ │ │ │ │ │ ├── IsPropertyKey.js
│ │ │ │ │ │ │ ├── IsRegExp.js
│ │ │ │ │ │ │ ├── IteratorClose.js
│ │ │ │ │ │ │ ├── IteratorComplete.js
│ │ │ │ │ │ │ ├── IteratorNext.js
│ │ │ │ │ │ │ ├── IteratorStep.js
│ │ │ │ │ │ │ ├── IteratorValue.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── ObjectCreate.js
│ │ │ │ │ │ │ ├── OrdinaryDefineOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryHasInstance.js
│ │ │ │ │ │ │ ├── OrdinaryHasProperty.js
│ │ │ │ │ │ │ ├── RegExpExec.js
│ │ │ │ │ │ │ ├── RequireObjectCoercible.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SameValueZero.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── Set.js
│ │ │ │ │ │ │ ├── SetFunctionName.js
│ │ │ │ │ │ │ ├── SetIntegrityLevel.js
│ │ │ │ │ │ │ ├── SpeciesConstructor.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── SymbolDescriptiveString.js
│ │ │ │ │ │ │ ├── TestIntegrityLevel.js
│ │ │ │ │ │ │ ├── thisBooleanValue.js
│ │ │ │ │ │ │ ├── thisNumberValue.js
│ │ │ │ │ │ │ ├── thisStringValue.js
│ │ │ │ │ │ │ ├── thisTimeValue.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToDateString.js
│ │ │ │ │ │ │ ├── ToInt16.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInt8.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToLength.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToPropertyKey.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── ToUint8.js
│ │ │ │ │ │ │ ├── ToUint8Clamp.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── ValidateAndApplyPropertyDescriptor.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── 2016
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── AdvanceStringIndex.js
│ │ │ │ │ │ │ ├── ArrayCreate.js
│ │ │ │ │ │ │ ├── ArraySetLength.js
│ │ │ │ │ │ │ ├── ArraySpeciesCreate.js
│ │ │ │ │ │ │ ├── Call.js
│ │ │ │ │ │ │ ├── CanonicalNumericIndexString.js
│ │ │ │ │ │ │ ├── CompletePropertyDescriptor.js
│ │ │ │ │ │ │ ├── CreateDataProperty.js
│ │ │ │ │ │ │ ├── CreateDataPropertyOrThrow.js
│ │ │ │ │ │ │ ├── CreateHTML.js
│ │ │ │ │ │ │ ├── CreateIterResultObject.js
│ │ │ │ │ │ │ ├── CreateListFromArrayLike.js
│ │ │ │ │ │ │ ├── CreateMethodProperty.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── DefinePropertyOrThrow.js
│ │ │ │ │ │ │ ├── DeletePropertyOrThrow.js
│ │ │ │ │ │ │ ├── EnumerableOwnNames.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── Get.js
│ │ │ │ │ │ │ ├── GetIterator.js
│ │ │ │ │ │ │ ├── GetMethod.js
│ │ │ │ │ │ │ ├── GetOwnPropertyKeys.js
│ │ │ │ │ │ │ ├── GetPrototypeFromConstructor.js
│ │ │ │ │ │ │ ├── GetSubstitution.js
│ │ │ │ │ │ │ ├── GetV.js
│ │ │ │ │ │ │ ├── HasOwnProperty.js
│ │ │ │ │ │ │ ├── HasProperty.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── InstanceofOperator.js
│ │ │ │ │ │ │ ├── Invoke.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsArray.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsConcatSpreadable.js
│ │ │ │ │ │ │ ├── IsConstructor.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsExtensible.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsInteger.js
│ │ │ │ │ │ │ ├── IsPromise.js
│ │ │ │ │ │ │ ├── IsPropertyDescriptor.js
│ │ │ │ │ │ │ ├── IsPropertyKey.js
│ │ │ │ │ │ │ ├── IsRegExp.js
│ │ │ │ │ │ │ ├── IterableToArrayLike.js
│ │ │ │ │ │ │ ├── IteratorClose.js
│ │ │ │ │ │ │ ├── IteratorComplete.js
│ │ │ │ │ │ │ ├── IteratorNext.js
│ │ │ │ │ │ │ ├── IteratorStep.js
│ │ │ │ │ │ │ ├── IteratorValue.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── ObjectCreate.js
│ │ │ │ │ │ │ ├── OrdinaryDefineOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetPrototypeOf.js
│ │ │ │ │ │ │ ├── OrdinaryHasInstance.js
│ │ │ │ │ │ │ ├── OrdinaryHasProperty.js
│ │ │ │ │ │ │ ├── OrdinarySetPrototypeOf.js
│ │ │ │ │ │ │ ├── RegExpExec.js
│ │ │ │ │ │ │ ├── RequireObjectCoercible.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SameValueNonNumber.js
│ │ │ │ │ │ │ ├── SameValueZero.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── Set.js
│ │ │ │ │ │ │ ├── SetFunctionName.js
│ │ │ │ │ │ │ ├── SetIntegrityLevel.js
│ │ │ │ │ │ │ ├── SpeciesConstructor.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── SymbolDescriptiveString.js
│ │ │ │ │ │ │ ├── TestIntegrityLevel.js
│ │ │ │ │ │ │ ├── thisBooleanValue.js
│ │ │ │ │ │ │ ├── thisNumberValue.js
│ │ │ │ │ │ │ ├── thisStringValue.js
│ │ │ │ │ │ │ ├── thisTimeValue.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToDateString.js
│ │ │ │ │ │ │ ├── ToInt16.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInt8.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToLength.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToPropertyKey.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── ToUint8.js
│ │ │ │ │ │ │ ├── ToUint8Clamp.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── ValidateAndApplyPropertyDescriptor.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── 2017
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── AdvanceStringIndex.js
│ │ │ │ │ │ │ ├── ArrayCreate.js
│ │ │ │ │ │ │ ├── ArraySetLength.js
│ │ │ │ │ │ │ ├── ArraySpeciesCreate.js
│ │ │ │ │ │ │ ├── Call.js
│ │ │ │ │ │ │ ├── CanonicalNumericIndexString.js
│ │ │ │ │ │ │ ├── CompletePropertyDescriptor.js
│ │ │ │ │ │ │ ├── CreateDataProperty.js
│ │ │ │ │ │ │ ├── CreateDataPropertyOrThrow.js
│ │ │ │ │ │ │ ├── CreateHTML.js
│ │ │ │ │ │ │ ├── CreateIterResultObject.js
│ │ │ │ │ │ │ ├── CreateListFromArrayLike.js
│ │ │ │ │ │ │ ├── CreateMethodProperty.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── DefinePropertyOrThrow.js
│ │ │ │ │ │ │ ├── DeletePropertyOrThrow.js
│ │ │ │ │ │ │ ├── EnumerableOwnProperties.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── Get.js
│ │ │ │ │ │ │ ├── GetIterator.js
│ │ │ │ │ │ │ ├── GetMethod.js
│ │ │ │ │ │ │ ├── GetOwnPropertyKeys.js
│ │ │ │ │ │ │ ├── GetPrototypeFromConstructor.js
│ │ │ │ │ │ │ ├── GetSubstitution.js
│ │ │ │ │ │ │ ├── GetV.js
│ │ │ │ │ │ │ ├── HasOwnProperty.js
│ │ │ │ │ │ │ ├── HasProperty.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── InstanceofOperator.js
│ │ │ │ │ │ │ ├── Invoke.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsArray.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsConcatSpreadable.js
│ │ │ │ │ │ │ ├── IsConstructor.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsExtensible.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsInteger.js
│ │ │ │ │ │ │ ├── IsPromise.js
│ │ │ │ │ │ │ ├── IsPropertyDescriptor.js
│ │ │ │ │ │ │ ├── IsPropertyKey.js
│ │ │ │ │ │ │ ├── IsRegExp.js
│ │ │ │ │ │ │ ├── IterableToList.js
│ │ │ │ │ │ │ ├── IteratorClose.js
│ │ │ │ │ │ │ ├── IteratorComplete.js
│ │ │ │ │ │ │ ├── IteratorNext.js
│ │ │ │ │ │ │ ├── IteratorStep.js
│ │ │ │ │ │ │ ├── IteratorValue.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── ObjectCreate.js
│ │ │ │ │ │ │ ├── OrdinaryDefineOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetPrototypeOf.js
│ │ │ │ │ │ │ ├── OrdinaryHasInstance.js
│ │ │ │ │ │ │ ├── OrdinaryHasProperty.js
│ │ │ │ │ │ │ ├── OrdinarySetPrototypeOf.js
│ │ │ │ │ │ │ ├── RegExpExec.js
│ │ │ │ │ │ │ ├── RequireObjectCoercible.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SameValueNonNumber.js
│ │ │ │ │ │ │ ├── SameValueZero.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── Set.js
│ │ │ │ │ │ │ ├── SetFunctionName.js
│ │ │ │ │ │ │ ├── SetIntegrityLevel.js
│ │ │ │ │ │ │ ├── SpeciesConstructor.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── SymbolDescriptiveString.js
│ │ │ │ │ │ │ ├── TestIntegrityLevel.js
│ │ │ │ │ │ │ ├── thisBooleanValue.js
│ │ │ │ │ │ │ ├── thisNumberValue.js
│ │ │ │ │ │ │ ├── thisStringValue.js
│ │ │ │ │ │ │ ├── thisTimeValue.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToDateString.js
│ │ │ │ │ │ │ ├── ToIndex.js
│ │ │ │ │ │ │ ├── ToInt16.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInt8.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToLength.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToPropertyKey.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── ToUint8.js
│ │ │ │ │ │ │ ├── ToUint8Clamp.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── ValidateAndApplyPropertyDescriptor.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── 2018
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── AdvanceStringIndex.js
│ │ │ │ │ │ │ ├── ArrayCreate.js
│ │ │ │ │ │ │ ├── ArraySetLength.js
│ │ │ │ │ │ │ ├── ArraySpeciesCreate.js
│ │ │ │ │ │ │ ├── Call.js
│ │ │ │ │ │ │ ├── CanonicalNumericIndexString.js
│ │ │ │ │ │ │ ├── CompletePropertyDescriptor.js
│ │ │ │ │ │ │ ├── CopyDataProperties.js
│ │ │ │ │ │ │ ├── CreateDataProperty.js
│ │ │ │ │ │ │ ├── CreateDataPropertyOrThrow.js
│ │ │ │ │ │ │ ├── CreateHTML.js
│ │ │ │ │ │ │ ├── CreateIterResultObject.js
│ │ │ │ │ │ │ ├── CreateListFromArrayLike.js
│ │ │ │ │ │ │ ├── CreateMethodProperty.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── DateString.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── DefinePropertyOrThrow.js
│ │ │ │ │ │ │ ├── DeletePropertyOrThrow.js
│ │ │ │ │ │ │ ├── EnumerableOwnPropertyNames.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── Get.js
│ │ │ │ │ │ │ ├── GetIterator.js
│ │ │ │ │ │ │ ├── GetMethod.js
│ │ │ │ │ │ │ ├── GetOwnPropertyKeys.js
│ │ │ │ │ │ │ ├── GetPrototypeFromConstructor.js
│ │ │ │ │ │ │ ├── GetSubstitution.js
│ │ │ │ │ │ │ ├── GetV.js
│ │ │ │ │ │ │ ├── HasOwnProperty.js
│ │ │ │ │ │ │ ├── HasProperty.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── InstanceofOperator.js
│ │ │ │ │ │ │ ├── Invoke.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsArray.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsConcatSpreadable.js
│ │ │ │ │ │ │ ├── IsConstructor.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsExtensible.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsInteger.js
│ │ │ │ │ │ │ ├── IsPromise.js
│ │ │ │ │ │ │ ├── IsPropertyKey.js
│ │ │ │ │ │ │ ├── IsRegExp.js
│ │ │ │ │ │ │ ├── IsStringPrefix.js
│ │ │ │ │ │ │ ├── IterableToList.js
│ │ │ │ │ │ │ ├── IteratorClose.js
│ │ │ │ │ │ │ ├── IteratorComplete.js
│ │ │ │ │ │ │ ├── IteratorNext.js
│ │ │ │ │ │ │ ├── IteratorStep.js
│ │ │ │ │ │ │ ├── IteratorValue.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── NumberToString.js
│ │ │ │ │ │ │ ├── ObjectCreate.js
│ │ │ │ │ │ │ ├── OrdinaryDefineOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetPrototypeOf.js
│ │ │ │ │ │ │ ├── OrdinaryHasInstance.js
│ │ │ │ │ │ │ ├── OrdinaryHasProperty.js
│ │ │ │ │ │ │ ├── OrdinarySetPrototypeOf.js
│ │ │ │ │ │ │ ├── PromiseResolve.js
│ │ │ │ │ │ │ ├── RegExpExec.js
│ │ │ │ │ │ │ ├── RequireObjectCoercible.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SameValueNonNumber.js
│ │ │ │ │ │ │ ├── SameValueZero.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── Set.js
│ │ │ │ │ │ │ ├── SetFunctionName.js
│ │ │ │ │ │ │ ├── SetIntegrityLevel.js
│ │ │ │ │ │ │ ├── SpeciesConstructor.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── SymbolDescriptiveString.js
│ │ │ │ │ │ │ ├── TestIntegrityLevel.js
│ │ │ │ │ │ │ ├── thisBooleanValue.js
│ │ │ │ │ │ │ ├── thisNumberValue.js
│ │ │ │ │ │ │ ├── thisStringValue.js
│ │ │ │ │ │ │ ├── thisSymbolValue.js
│ │ │ │ │ │ │ ├── thisTimeValue.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeString.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToDateString.js
│ │ │ │ │ │ │ ├── ToIndex.js
│ │ │ │ │ │ │ ├── ToInt16.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInt8.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToLength.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToPropertyKey.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── ToUint8.js
│ │ │ │ │ │ │ ├── ToUint8Clamp.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── ValidateAndApplyPropertyDescriptor.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── 2019
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── AddEntriesFromIterable.js
│ │ │ │ │ │ │ ├── AdvanceStringIndex.js
│ │ │ │ │ │ │ ├── ArrayCreate.js
│ │ │ │ │ │ │ ├── ArraySetLength.js
│ │ │ │ │ │ │ ├── ArraySpeciesCreate.js
│ │ │ │ │ │ │ ├── Call.js
│ │ │ │ │ │ │ ├── CanonicalNumericIndexString.js
│ │ │ │ │ │ │ ├── CompletePropertyDescriptor.js
│ │ │ │ │ │ │ ├── CopyDataProperties.js
│ │ │ │ │ │ │ ├── CreateDataProperty.js
│ │ │ │ │ │ │ ├── CreateDataPropertyOrThrow.js
│ │ │ │ │ │ │ ├── CreateHTML.js
│ │ │ │ │ │ │ ├── CreateIterResultObject.js
│ │ │ │ │ │ │ ├── CreateListFromArrayLike.js
│ │ │ │ │ │ │ ├── CreateMethodProperty.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── DateString.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── DefinePropertyOrThrow.js
│ │ │ │ │ │ │ ├── DeletePropertyOrThrow.js
│ │ │ │ │ │ │ ├── EnumerableOwnPropertyNames.js
│ │ │ │ │ │ │ ├── FlattenIntoArray.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── Get.js
│ │ │ │ │ │ │ ├── GetIterator.js
│ │ │ │ │ │ │ ├── GetMethod.js
│ │ │ │ │ │ │ ├── GetOwnPropertyKeys.js
│ │ │ │ │ │ │ ├── GetPrototypeFromConstructor.js
│ │ │ │ │ │ │ ├── GetSubstitution.js
│ │ │ │ │ │ │ ├── GetV.js
│ │ │ │ │ │ │ ├── HasOwnProperty.js
│ │ │ │ │ │ │ ├── HasProperty.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── InstanceofOperator.js
│ │ │ │ │ │ │ ├── Invoke.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsArray.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsConcatSpreadable.js
│ │ │ │ │ │ │ ├── IsConstructor.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsExtensible.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsInteger.js
│ │ │ │ │ │ │ ├── IsPromise.js
│ │ │ │ │ │ │ ├── IsPropertyKey.js
│ │ │ │ │ │ │ ├── IsRegExp.js
│ │ │ │ │ │ │ ├── IsStringPrefix.js
│ │ │ │ │ │ │ ├── IterableToList.js
│ │ │ │ │ │ │ ├── IteratorClose.js
│ │ │ │ │ │ │ ├── IteratorComplete.js
│ │ │ │ │ │ │ ├── IteratorNext.js
│ │ │ │ │ │ │ ├── IteratorStep.js
│ │ │ │ │ │ │ ├── IteratorValue.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── NumberToString.js
│ │ │ │ │ │ │ ├── ObjectCreate.js
│ │ │ │ │ │ │ ├── OrdinaryDefineOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetOwnProperty.js
│ │ │ │ │ │ │ ├── OrdinaryGetPrototypeOf.js
│ │ │ │ │ │ │ ├── OrdinaryHasInstance.js
│ │ │ │ │ │ │ ├── OrdinaryHasProperty.js
│ │ │ │ │ │ │ ├── OrdinarySetPrototypeOf.js
│ │ │ │ │ │ │ ├── PromiseResolve.js
│ │ │ │ │ │ │ ├── RegExpExec.js
│ │ │ │ │ │ │ ├── RequireObjectCoercible.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SameValueNonNumber.js
│ │ │ │ │ │ │ ├── SameValueZero.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── Set.js
│ │ │ │ │ │ │ ├── SetFunctionName.js
│ │ │ │ │ │ │ ├── SetIntegrityLevel.js
│ │ │ │ │ │ │ ├── SpeciesConstructor.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── SymbolDescriptiveString.js
│ │ │ │ │ │ │ ├── TestIntegrityLevel.js
│ │ │ │ │ │ │ ├── thisBooleanValue.js
│ │ │ │ │ │ │ ├── thisNumberValue.js
│ │ │ │ │ │ │ ├── thisStringValue.js
│ │ │ │ │ │ │ ├── thisSymbolValue.js
│ │ │ │ │ │ │ ├── thisTimeValue.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeString.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToDateString.js
│ │ │ │ │ │ │ ├── ToIndex.js
│ │ │ │ │ │ │ ├── ToInt16.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInt8.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToLength.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToPropertyKey.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── ToUint8.js
│ │ │ │ │ │ │ ├── ToUint8Clamp.js
│ │ │ │ │ │ │ ├── TrimString.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── ValidateAndApplyPropertyDescriptor.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── 5
│ │ │ │ │ │ │ ├── AbstractEqualityComparison.js
│ │ │ │ │ │ │ ├── AbstractRelationalComparison.js
│ │ │ │ │ │ │ ├── CheckObjectCoercible.js
│ │ │ │ │ │ │ ├── DateFromTime.js
│ │ │ │ │ │ │ ├── Day.js
│ │ │ │ │ │ │ ├── DayFromYear.js
│ │ │ │ │ │ │ ├── DaysInYear.js
│ │ │ │ │ │ │ ├── DayWithinYear.js
│ │ │ │ │ │ │ ├── FromPropertyDescriptor.js
│ │ │ │ │ │ │ ├── HourFromTime.js
│ │ │ │ │ │ │ ├── InLeapYear.js
│ │ │ │ │ │ │ ├── IsAccessorDescriptor.js
│ │ │ │ │ │ │ ├── IsCallable.js
│ │ │ │ │ │ │ ├── IsDataDescriptor.js
│ │ │ │ │ │ │ ├── IsGenericDescriptor.js
│ │ │ │ │ │ │ ├── IsPropertyDescriptor.js
│ │ │ │ │ │ │ ├── MakeDate.js
│ │ │ │ │ │ │ ├── MakeDay.js
│ │ │ │ │ │ │ ├── MakeTime.js
│ │ │ │ │ │ │ ├── MinFromTime.js
│ │ │ │ │ │ │ ├── modulo.js
│ │ │ │ │ │ │ ├── MonthFromTime.js
│ │ │ │ │ │ │ ├── msFromTime.js
│ │ │ │ │ │ │ ├── SameValue.js
│ │ │ │ │ │ │ ├── SecFromTime.js
│ │ │ │ │ │ │ ├── StrictEqualityComparison.js
│ │ │ │ │ │ │ ├── TimeClip.js
│ │ │ │ │ │ │ ├── TimeFromYear.js
│ │ │ │ │ │ │ ├── TimeWithinDay.js
│ │ │ │ │ │ │ ├── ToBoolean.js
│ │ │ │ │ │ │ ├── ToInt32.js
│ │ │ │ │ │ │ ├── ToInteger.js
│ │ │ │ │ │ │ ├── ToNumber.js
│ │ │ │ │ │ │ ├── ToObject.js
│ │ │ │ │ │ │ ├── ToPrimitive.js
│ │ │ │ │ │ │ ├── ToPropertyDescriptor.js
│ │ │ │ │ │ │ ├── ToString.js
│ │ │ │ │ │ │ ├── ToUint16.js
│ │ │ │ │ │ │ ├── ToUint32.js
│ │ │ │ │ │ │ ├── Type.js
│ │ │ │ │ │ │ ├── WeekDay.js
│ │ │ │ │ │ │ └── YearFromTime.js
│ │ │ │ │ │ ├── CHANGELOG.md
│ │ │ │ │ │ ├── es2015.js
│ │ │ │ │ │ ├── es2016.js
│ │ │ │ │ │ ├── es2017.js
│ │ │ │ │ │ ├── es2018.js
│ │ │ │ │ │ ├── es2019.js
│ │ │ │ │ │ ├── es5.js
│ │ │ │ │ │ ├── es6.js
│ │ │ │ │ │ ├── es7.js
│ │ │ │ │ │ ├── GetIntrinsic.js
│ │ │ │ │ │ ├── helpers
│ │ │ │ │ │ │ ├── assertRecord.js
│ │ │ │ │ │ │ ├── assign.js
│ │ │ │ │ │ │ ├── callBind.js
│ │ │ │ │ │ │ ├── callBound.js
│ │ │ │ │ │ │ ├── DefineOwnProperty.js
│ │ │ │ │ │ │ ├── every.js
│ │ │ │ │ │ │ ├── forEach.js
│ │ │ │ │ │ │ ├── getInferredName.js
│ │ │ │ │ │ │ ├── getIteratorMethod.js
│ │ │ │ │ │ │ ├── getOwnPropertyDescriptor.js
│ │ │ │ │ │ │ ├── getProto.js
│ │ │ │ │ │ │ ├── getSymbolDescription.js
│ │ │ │ │ │ │ ├── isFinite.js
│ │ │ │ │ │ │ ├── isNaN.js
│ │ │ │ │ │ │ ├── isPrefixOf.js
│ │ │ │ │ │ │ ├── isPrimitive.js
│ │ │ │ │ │ │ ├── isPropertyDescriptor.js
│ │ │ │ │ │ │ ├── isSamePropertyDescriptor.js
│ │ │ │ │ │ │ ├── maxSafeInteger.js
│ │ │ │ │ │ │ ├── mod.js
│ │ │ │ │ │ │ ├── OwnPropertyKeys.js
│ │ │ │ │ │ │ ├── padTimeComponent.js
│ │ │ │ │ │ │ ├── regexTester.js
│ │ │ │ │ │ │ ├── setProto.js
│ │ │ │ │ │ │ ├── sign.js
│ │ │ │ │ │ │ └── timeConstants.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── operations
│ │ │ │ │ │ │ ├── .eslintrc
│ │ │ │ │ │ │ ├── 2015.js
│ │ │ │ │ │ │ ├── 2016.js
│ │ │ │ │ │ │ ├── 2017.js
│ │ │ │ │ │ │ ├── 2018.js
│ │ │ │ │ │ │ └── 2019.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ └── test
│ │ │ │ │ │ ├── diffOps.js
│ │ │ │ │ │ ├── es2015.js
│ │ │ │ │ │ ├── es2016.js
│ │ │ │ │ │ ├── es2017.js
│ │ │ │ │ │ ├── es2018.js
│ │ │ │ │ │ ├── es2019.js
│ │ │ │ │ │ ├── es5.js
│ │ │ │ │ │ ├── es6.js
│ │ │ │ │ │ ├── es7.js
│ │ │ │ │ │ ├── GetIntrinsic.js
│ │ │ │ │ │ ├── helpers
│ │ │ │ │ │ │ ├── assertRecord.js
│ │ │ │ │ │ │ ├── defineProperty.js
│ │ │ │ │ │ │ ├── getSymbolDescription.js
│ │ │ │ │ │ │ ├── OwnPropertyKeys.js
│ │ │ │ │ │ │ ├── runManifestTest.js
│ │ │ │ │ │ │ └── values.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ └── tests.js
│ │ │ │ │ ├── ex-conditions
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── default.js
│ │ │ │ │ │ ├── dinr.js
│ │ │ │ │ │ ├── dirn.js
│ │ │ │ │ │ ├── dnir.js
│ │ │ │ │ │ ├── dnri.js
│ │ │ │ │ │ ├── drin.js
│ │ │ │ │ │ ├── drni.js
│ │ │ │ │ │ ├── fallback.js
│ │ │ │ │ │ ├── gen.js
│ │ │ │ │ │ ├── idnr.js
│ │ │ │ │ │ ├── idrn.js
│ │ │ │ │ │ ├── import.mjs
│ │ │ │ │ │ ├── indr.js
│ │ │ │ │ │ ├── inrd.js
│ │ │ │ │ │ ├── irdn.js
│ │ │ │ │ │ ├── irnd.js
│ │ │ │ │ │ ├── main.js
│ │ │ │ │ │ ├── ndir.js
│ │ │ │ │ │ ├── ndri.js
│ │ │ │ │ │ ├── nidr.js
│ │ │ │ │ │ ├── nird.js
│ │ │ │ │ │ ├── node.js
│ │ │ │ │ │ ├── nrdi.js
│ │ │ │ │ │ ├── nrid.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── rdin.js
│ │ │ │ │ │ ├── rdni.js
│ │ │ │ │ │ ├── require.js
│ │ │ │ │ │ ├── ridn.js
│ │ │ │ │ │ ├── rind.js
│ │ │ │ │ │ ├── rndi.js
│ │ │ │ │ │ └── rnid.js
│ │ │ │ │ ├── ex-conditions-in-folder
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── cjs
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ └── utils.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── mjs
│ │ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ │ └── utils.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-exports-string
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-exports-TL-object
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-folder-mapped
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── expected-without-conditions.json
│ │ │ │ │ │ │ ├── expected.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── mapped
│ │ │ │ │ │ │ ├── in-mapped-only.js
│ │ │ │ │ │ │ └── shared.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── unmapped
│ │ │ │ │ │ ├── in-unmapped-only.js
│ │ │ │ │ │ └── shared.js
│ │ │ │ │ ├── ex-main-dot-slash
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-dotless
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-dotted
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-exports-dot-object
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-exports-multi-object
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-exports-string
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-exports-TL-object
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-main-implicit
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-no-exports-with-root-type-commonjs
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── cjs.cjs
│ │ │ │ │ │ ├── esm.mjs
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-no-exports-with-root-type-module
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── cjs.cjs
│ │ │ │ │ │ ├── esm.mjs
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-node-modules
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ ├── expected-without-conditions.json
│ │ │ │ │ │ ├── expected.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── default.js
│ │ │ │ │ │ ├── dep.js
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-nonexistent-dir
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ ├── expected-without-conditions.json
│ │ │ │ │ │ ├── expected.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── ex-private
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── dir
│ │ │ │ │ │ │ ├── extra.js
│ │ │ │ │ │ │ ├── extra.mjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── file.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ └── package.json
│ │ │ │ │ ├── flatted-1
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── cjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── esm
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── min.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ └── types.d.ts
│ │ │ │ │ ├── flatted-2
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .github
│ │ │ │ │ │ │ └── FUNDING.yml
│ │ │ │ │ │ ├── cjs
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── esm
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── min.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── SPECS.md
│ │ │ │ │ │ └── types.d.ts
│ │ │ │ │ ├── flatted-3
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .github
│ │ │ │ │ │ │ └── FUNDING.yml
│ │ │ │ │ │ ├── cjs
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ ├── es.js
│ │ │ │ │ │ ├── esm
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── min.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── SPECS.md
│ │ │ │ │ │ └── types.d.ts
│ │ │ │ │ ├── has-package-exports
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ ├── expected-without-conditions.json
│ │ │ │ │ │ ├── expected.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .eslintignore
│ │ │ │ │ │ ├── .eslintrc
│ │ │ │ │ │ ├── .nycrc
│ │ │ │ │ │ ├── browser.js
│ │ │ │ │ │ ├── CHANGELOG.md
│ │ │ │ │ │ ├── conditional.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── no.js
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── pattern.js
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── test
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ └── yes.js
│ │ │ │ │ ├── is-promise-2.1.0
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .travis.yml
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── readme.md
│ │ │ │ │ ├── is-promise-2.2.0
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ ├── expected.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── readme.md
│ │ │ │ │ ├── is-promise-2.2.1
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── readme.md
│ │ │ │ │ ├── is-promise-2.2.2
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── readme.md
│ │ │ │ │ ├── list-exports
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ ├── expected-without-conditions.json
│ │ │ │ │ │ └── expected.json
│ │ │ │ │ ├── ls-exports
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── expected-without-conditions.json
│ │ │ │ │ ├── preact
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── compat
│ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ ├── server.js
│ │ │ │ │ │ │ └── src
│ │ │ │ │ │ │ ├── Children.js
│ │ │ │ │ │ │ ├── events.js
│ │ │ │ │ │ │ ├── forwardRef.js
│ │ │ │ │ │ │ ├── index.d.ts
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ ├── internal.d.ts
│ │ │ │ │ │ │ ├── memo.js
│ │ │ │ │ │ │ ├── portals.js
│ │ │ │ │ │ │ ├── PureComponent.js
│ │ │ │ │ │ │ ├── render.js
│ │ │ │ │ │ │ ├── suspense-list.d.ts
│ │ │ │ │ │ │ ├── suspense-list.js
│ │ │ │ │ │ │ ├── suspense.d.ts
│ │ │ │ │ │ │ ├── suspense.js
│ │ │ │ │ │ │ └── util.js
│ │ │ │ │ │ ├── debug
│ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ └── src
│ │ │ │ │ │ │ ├── check-props.js
│ │ │ │ │ │ │ ├── component-stack.js
│ │ │ │ │ │ │ ├── constants.js
│ │ │ │ │ │ │ ├── debug.js
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ └── internal.d.ts
│ │ │ │ │ │ ├── devtools
│ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ └── src
│ │ │ │ │ │ │ ├── devtools.js
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── hooks
│ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ └── src
│ │ │ │ │ │ │ ├── index.d.ts
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ └── internal.d.ts
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── README.md
│ │ │ │ │ │ ├── src
│ │ │ │ │ │ │ ├── clone-element.js
│ │ │ │ │ │ │ ├── component.js
│ │ │ │ │ │ │ ├── constants.js
│ │ │ │ │ │ │ ├── create-context.js
│ │ │ │ │ │ │ ├── create-element.js
│ │ │ │ │ │ │ ├── diff
│ │ │ │ │ │ │ │ ├── catch-error.js
│ │ │ │ │ │ │ │ ├── children.js
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── props.js
│ │ │ │ │ │ │ ├── index.d.ts
│ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ ├── internal.d.ts
│ │ │ │ │ │ │ ├── jsx.d.ts
│ │ │ │ │ │ │ ├── options.js
│ │ │ │ │ │ │ ├── render.js
│ │ │ │ │ │ │ └── util.js
│ │ │ │ │ │ └── test-utils
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ └── src
│ │ │ │ │ │ ├── index.d.ts
│ │ │ │ │ │ └── index.js
│ │ │ │ │ ├── resolve-1
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .eslintignore
│ │ │ │ │ │ ├── .eslintrc
│ │ │ │ │ │ ├── .travis.yml
│ │ │ │ │ │ ├── example
│ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── lib
│ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ ├── caller.js
│ │ │ │ │ │ │ ├── core.js
│ │ │ │ │ │ │ ├── core.json
│ │ │ │ │ │ │ ├── is-core.js
│ │ │ │ │ │ │ ├── node-modules-paths.js
│ │ │ │ │ │ │ ├── normalize-options.js
│ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── readme.markdown
│ │ │ │ │ │ └── test
│ │ │ │ │ │ ├── .eslintrc
│ │ │ │ │ │ ├── core.js
│ │ │ │ │ │ ├── dotdot
│ │ │ │ │ │ │ ├── abc
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── dotdot.js
│ │ │ │ │ │ ├── faulty_basedir.js
│ │ │ │ │ │ ├── filter_sync.js
│ │ │ │ │ │ ├── filter.js
│ │ │ │ │ │ ├── mock_sync.js
│ │ │ │ │ │ ├── mock.js
│ │ │ │ │ │ ├── module_dir
│ │ │ │ │ │ │ ├── xmodules
│ │ │ │ │ │ │ │ └── aaa
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ ├── ymodules
│ │ │ │ │ │ │ │ └── aaa
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── zmodules
│ │ │ │ │ │ │ └── bbb
│ │ │ │ │ │ │ ├── main.js
│ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ ├── module_dir.js
│ │ │ │ │ │ ├── node_path
│ │ │ │ │ │ │ ├── x
│ │ │ │ │ │ │ │ ├── aaa
│ │ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ │ └── ccc
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── y
│ │ │ │ │ │ │ ├── bbb
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── ccc
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── node_path.js
│ │ │ │ │ │ ├── node-modules-paths.js
│ │ │ │ │ │ ├── nonstring.js
│ │ │ │ │ │ ├── pathfilter
│ │ │ │ │ │ │ └── deep_ref
│ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ ├── pathfilter.js
│ │ │ │ │ │ ├── precedence
│ │ │ │ │ │ │ ├── aaa
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ │ ├── aaa.js
│ │ │ │ │ │ │ ├── bbb
│ │ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ │ └── bbb.js
│ │ │ │ │ │ ├── precedence.js
│ │ │ │ │ │ ├── resolver
│ │ │ │ │ │ │ ├── baz
│ │ │ │ │ │ │ │ ├── doom.js
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── quux.js
│ │ │ │ │ │ │ ├── browser_field
│ │ │ │ │ │ │ │ ├── a.js
│ │ │ │ │ │ │ │ ├── b.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── cup.coffee
│ │ │ │ │ │ │ ├── dot_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── dot_slash_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── foo.js
│ │ │ │ │ │ │ ├── incorrect_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── invalid_main
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── mug.coffee
│ │ │ │ │ │ │ ├── mug.js
│ │ │ │ │ │ │ ├── multirepo
│ │ │ │ │ │ │ │ ├── lerna.json
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── packages
│ │ │ │ │ │ │ │ ├── package-a
│ │ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ │ └── package-b
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── nested_symlinks
│ │ │ │ │ │ │ │ └── mylib
│ │ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ │ ├── other_path
│ │ │ │ │ │ │ │ ├── lib
│ │ │ │ │ │ │ │ │ └── other-lib.js
│ │ │ │ │ │ │ │ └── root.js
│ │ │ │ │ │ │ ├── quux
│ │ │ │ │ │ │ │ └── foo
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ ├── same_names
│ │ │ │ │ │ │ │ ├── foo
│ │ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ │ └── foo.js
│ │ │ │ │ │ │ ├── symlinked
│ │ │ │ │ │ │ │ ├── _
│ │ │ │ │ │ │ │ │ ├── node_modules
│ │ │ │ │ │ │ │ │ │ └── foo.js
│ │ │ │ │ │ │ │ │ └── symlink_target
│ │ │ │ │ │ │ │ │ └── .gitkeep
│ │ │ │ │ │ │ │ └── package
│ │ │ │ │ │ │ │ ├── bar.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ └── without_basedir
│ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ ├── resolver_sync.js
│ │ │ │ │ │ ├── resolver.js
│ │ │ │ │ │ ├── shadowed_core
│ │ │ │ │ │ │ └── node_modules
│ │ │ │ │ │ │ └── util
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── shadowed_core.js
│ │ │ │ │ │ ├── subdirs.js
│ │ │ │ │ │ └── symlinks.js
│ │ │ │ │ ├── resolve-2
│ │ │ │ │ │ ├── expected
│ │ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ │ └── project
│ │ │ │ │ │ ├── .eslintignore
│ │ │ │ │ │ ├── .eslintrc
│ │ │ │ │ │ ├── .github
│ │ │ │ │ │ │ └── FUNDING.yml
│ │ │ │ │ │ ├── .travis.yml
│ │ │ │ │ │ ├── example
│ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ ├── index.mjs
│ │ │ │ │ │ ├── lib
│ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ ├── caller.js
│ │ │ │ │ │ │ ├── core.js
│ │ │ │ │ │ │ ├── core.json
│ │ │ │ │ │ │ ├── is-core.js
│ │ │ │ │ │ │ ├── node-modules-paths.js
│ │ │ │ │ │ │ ├── normalize-options.js
│ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ ├── LICENSE
│ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ ├── readme.markdown
│ │ │ │ │ │ └── test
│ │ │ │ │ │ ├── core.js
│ │ │ │ │ │ ├── dotdot
│ │ │ │ │ │ │ ├── abc
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── dotdot.js
│ │ │ │ │ │ ├── faulty_basedir.js
│ │ │ │ │ │ ├── filter_sync.js
│ │ │ │ │ │ ├── filter.js
│ │ │ │ │ │ ├── mock_sync.js
│ │ │ │ │ │ ├── mock.js
│ │ │ │ │ │ ├── module_dir
│ │ │ │ │ │ │ ├── xmodules
│ │ │ │ │ │ │ │ └── aaa
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ ├── ymodules
│ │ │ │ │ │ │ │ └── aaa
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── zmodules
│ │ │ │ │ │ │ └── bbb
│ │ │ │ │ │ │ ├── main.js
│ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ ├── module_dir.js
│ │ │ │ │ │ ├── node_path
│ │ │ │ │ │ │ ├── x
│ │ │ │ │ │ │ │ ├── aaa
│ │ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ │ └── ccc
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── y
│ │ │ │ │ │ │ ├── bbb
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ └── ccc
│ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ ├── node_path.js
│ │ │ │ │ │ ├── node-modules-paths.js
│ │ │ │ │ │ ├── nonstring.js
│ │ │ │ │ │ ├── pathfilter
│ │ │ │ │ │ │ └── deep_ref
│ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ ├── pathfilter_sync.js
│ │ │ │ │ │ ├── pathfilter.js
│ │ │ │ │ │ ├── precedence
│ │ │ │ │ │ │ ├── aaa
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ │ ├── aaa.js
│ │ │ │ │ │ │ ├── bbb
│ │ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ │ └── bbb.js
│ │ │ │ │ │ ├── precedence.js
│ │ │ │ │ │ ├── resolver
│ │ │ │ │ │ │ ├── baz
│ │ │ │ │ │ │ │ ├── doom.js
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── quux.js
│ │ │ │ │ │ │ ├── browser_field
│ │ │ │ │ │ │ │ ├── a.js
│ │ │ │ │ │ │ │ ├── b.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── cup.coffee
│ │ │ │ │ │ │ ├── dot_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── dot_slash_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── foo.js
│ │ │ │ │ │ │ ├── incorrect_main
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── invalid_main
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── mug.coffee
│ │ │ │ │ │ │ ├── mug.js
│ │ │ │ │ │ │ ├── multirepo
│ │ │ │ │ │ │ │ ├── lerna.json
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── packages
│ │ │ │ │ │ │ │ ├── package-a
│ │ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ │ └── package-b
│ │ │ │ │ │ │ │ ├── index.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ ├── nested_symlinks
│ │ │ │ │ │ │ │ └── mylib
│ │ │ │ │ │ │ │ ├── async.js
│ │ │ │ │ │ │ │ ├── package.json
│ │ │ │ │ │ │ │ └── sync.js
│ │ │ │ │ │ │ ├── other_path
│ │ │ │ │ │ │ │ ├── lib
│ │ │ │ │ │ │ │ │ └── other-lib.js
│ │ │ │ │ │ │ │ └── root.js
│ │ │ │ │ │ │ ├── quux
│ │ │ │ │ │ │ │ └── foo
│ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ ├── same_names
│ │ │ │ │ │ │ │ ├── foo
│ │ │ │ │ │ │ │ │ └── index.js
│ │ │ │ │ │ │ │ └── foo.js
│ │ │ │ │ │ │ ├── symlinked
│ │ │ │ │ │ │ │ ├── _
│ │ │ │ │ │ │ │ │ └── symlink_target
│ │ │ │ │ │ │ │ │ └── .gitkeep
│ │ │ │ │ │ │ │ └── package
│ │ │ │ │ │ │ │ ├── bar.js
│ │ │ │ │ │ │ │ └── package.json
│ │ │ │ │ │ │ └── without_basedir
│ │ │ │ │ │ │ └── main.js
│ │ │ │ │ │ ├── resolver_sync.js
│ │ │ │ │ │ ├── resolver.js
│ │ │ │ │ │ ├── shadowed_core.js
│ │ │ │ │ │ ├── subdirs.js
│ │ │ │ │ │ └── symlinks.js
│ │ │ │ │ └── single-spa-layout
│ │ │ │ │ ├── expected
│ │ │ │ │ │ ├── broken-dir-slash-conditions.json
│ │ │ │ │ │ ├── broken.json
│ │ │ │ │ │ ├── conditions.json
│ │ │ │ │ │ ├── experimental.json
│ │ │ │ │ │ ├── pattern-trailers-no-dir-slash.json
│ │ │ │ │ │ ├── pattern-trailers.json
│ │ │ │ │ │ ├── patterns.json
│ │ │ │ │ │ └── pre-exports.json
│ │ │ │ │ └── project
│ │ │ │ │ ├── LICENSE
│ │ │ │ │ ├── package.json
│ │ │ │ │ └── README.md
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── README.md
│ │ │ └── since.js
│ │ ├── mock_sync.js
│ │ ├── mock.js
│ │ ├── module_dir
│ │ │ ├── xmodules
│ │ │ │ └── aaa
│ │ │ │ └── index.js
│ │ │ ├── ymodules
│ │ │ │ └── aaa
│ │ │ │ └── index.js
│ │ │ └── zmodules
│ │ │ └── bbb
│ │ │ ├── main.js
│ │ │ └── package.json
│ │ ├── module_dir.js
│ │ ├── node_path
│ │ │ ├── x
│ │ │ │ ├── aaa
│ │ │ │ │ └── index.js
│ │ │ │ └── ccc
│ │ │ │ └── index.js
│ │ │ └── y
│ │ │ ├── bbb
│ │ │ │ └── index.js
│ │ │ └── ccc
│ │ │ └── index.js
│ │ ├── node_path.js
│ │ ├── node-modules-paths.js
│ │ ├── nonstring.js
│ │ ├── pathfilter
│ │ │ └── deep_ref
│ │ │ └── main.js
│ │ ├── pathfilter.js
│ │ ├── precedence
│ │ │ ├── aaa
│ │ │ │ ├── index.js
│ │ │ │ └── main.js
│ │ │ ├── aaa.js
│ │ │ ├── bbb
│ │ │ │ └── main.js
│ │ │ └── bbb.js
│ │ ├── precedence.js
│ │ ├── resolver
│ │ │ ├── baz
│ │ │ │ ├── doom.js
│ │ │ │ ├── package.json
│ │ │ │ └── quux.js
│ │ │ ├── browser_field
│ │ │ │ ├── a.js
│ │ │ │ ├── b.js
│ │ │ │ └── package.json
│ │ │ ├── cup.coffee
│ │ │ ├── dot_main
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── dot_slash_main
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── false_main
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── foo.js
│ │ │ ├── incorrect_main
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── invalid_main
│ │ │ │ └── package.json
│ │ │ ├── mug.coffee
│ │ │ ├── mug.js
│ │ │ ├── multirepo
│ │ │ │ ├── lerna.json
│ │ │ │ ├── package.json
│ │ │ │ └── packages
│ │ │ │ ├── package-a
│ │ │ │ │ ├── index.js
│ │ │ │ │ └── package.json
│ │ │ │ └── package-b
│ │ │ │ ├── index.js
│ │ │ │ └── package.json
│ │ │ ├── nested_symlinks
│ │ │ │ └── mylib
│ │ │ │ ├── async.js
│ │ │ │ ├── package.json
│ │ │ │ └── sync.js
│ │ │ ├── other_path
│ │ │ │ ├── lib
│ │ │ │ │ └── other-lib.js
│ │ │ │ └── root.js
│ │ │ ├── quux
│ │ │ │ └── foo
│ │ │ │ └── index.js
│ │ │ ├── same_names
│ │ │ │ ├── foo
│ │ │ │ │ └── index.js
│ │ │ │ └── foo.js
│ │ │ ├── symlinked
│ │ │ │ ├── _
│ │ │ │ │ ├── node_modules
│ │ │ │ │ │ └── foo.js
│ │ │ │ │ └── symlink_target
│ │ │ │ │ └── .gitkeep
│ │ │ │ └── package
│ │ │ │ ├── bar.js
│ │ │ │ └── package.json
│ │ │ └── without_basedir
│ │ │ └── main.js
│ │ ├── resolver_sync.js
│ │ ├── resolver.js
│ │ ├── shadowed_core
│ │ │ └── node_modules
│ │ │ └── util
│ │ │ └── index.js
│ │ ├── shadowed_core.js
│ │ ├── subdirs.js
│ │ └── symlinks.js
│ ├── safer-buffer
│ │ ├── dangerous.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── Porting-Buffer.md
│ │ ├── Readme.md
│ │ ├── safer.js
│ │ └── tests.js
│ ├── setprototypeof
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ └── index.js
│ ├── shelljs
│ │ ├── bin
│ │ │ └── shjs
│ │ ├── CHANGELOG.md
│ │ ├── commands.js
│ │ ├── global.js
│ │ ├── LICENSE
│ │ ├── make.js
│ │ ├── package.json
│ │ ├── plugin.js
│ │ ├── README.md
│ │ ├── shell.js
│ │ └── src
│ │ ├── cat.js
│ │ ├── cd.js
│ │ ├── chmod.js
│ │ ├── common.js
│ │ ├── cp.js
│ │ ├── dirs.js
│ │ ├── echo.js
│ │ ├── error.js
│ │ ├── exec-child.js
│ │ ├── exec.js
│ │ ├── find.js
│ │ ├── grep.js
│ │ ├── head.js
│ │ ├── ln.js
│ │ ├── ls.js
│ │ ├── mkdir.js
│ │ ├── mv.js
│ │ ├── popd.js
│ │ ├── pushd.js
│ │ ├── pwd.js
│ │ ├── rm.js
│ │ ├── sed.js
│ │ ├── set.js
│ │ ├── sort.js
│ │ ├── tail.js
│ │ ├── tempdir.js
│ │ ├── test.js
│ │ ├── to.js
│ │ ├── toEnd.js
│ │ ├── touch.js
│ │ ├── uniq.js
│ │ └── which.js
│ ├── shx
│ │ ├── CHANGELOG.md
│ │ ├── lib
│ │ │ ├── cli.js
│ │ │ ├── config.js
│ │ │ ├── help.js
│ │ │ ├── plugin-true-false.js
│ │ │ ├── printCmdRet.js
│ │ │ └── shx.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── statuses
│ │ ├── codes.json
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── supports-preserve-symlinks-flag
│ │ ├── .eslintrc
│ │ ├── .github
│ │ │ └── FUNDING.yml
│ │ ├── .nycrc
│ │ ├── browser.js
│ │ ├── CHANGELOG.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── test
│ │ └── index.js
│ ├── toidentifier
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── typescript
│ │ ├── bin
│ │ │ ├── tsc
│ │ │ └── tsserver
│ │ ├── lib
│ │ │ ├── _tsc.js
│ │ │ ├── _tsserver.js
│ │ │ ├── _typingsInstaller.js
│ │ │ ├── cancellationToken.js
│ │ │ ├── cs
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── de
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── es
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── fr
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── it
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ja
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ko
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── lib.d.ts
│ │ │ ├── lib.decorators.d.ts
│ │ │ ├── lib.decorators.legacy.d.ts
│ │ │ ├── lib.dom.asynciterable.d.ts
│ │ │ ├── lib.dom.d.ts
│ │ │ ├── lib.dom.iterable.d.ts
│ │ │ ├── lib.es2015.collection.d.ts
│ │ │ ├── lib.es2015.core.d.ts
│ │ │ ├── lib.es2015.d.ts
│ │ │ ├── lib.es2015.generator.d.ts
│ │ │ ├── lib.es2015.iterable.d.ts
│ │ │ ├── lib.es2015.promise.d.ts
│ │ │ ├── lib.es2015.proxy.d.ts
│ │ │ ├── lib.es2015.reflect.d.ts
│ │ │ ├── lib.es2015.symbol.d.ts
│ │ │ ├── lib.es2015.symbol.wellknown.d.ts
│ │ │ ├── lib.es2016.array.include.d.ts
│ │ │ ├── lib.es2016.d.ts
│ │ │ ├── lib.es2016.full.d.ts
│ │ │ ├── lib.es2016.intl.d.ts
│ │ │ ├── lib.es2017.arraybuffer.d.ts
│ │ │ ├── lib.es2017.d.ts
│ │ │ ├── lib.es2017.date.d.ts
│ │ │ ├── lib.es2017.full.d.ts
│ │ │ ├── lib.es2017.intl.d.ts
│ │ │ ├── lib.es2017.object.d.ts
│ │ │ ├── lib.es2017.sharedmemory.d.ts
│ │ │ ├── lib.es2017.string.d.ts
│ │ │ ├── lib.es2017.typedarrays.d.ts
│ │ │ ├── lib.es2018.asyncgenerator.d.ts
│ │ │ ├── lib.es2018.asynciterable.d.ts
│ │ │ ├── lib.es2018.d.ts
│ │ │ ├── lib.es2018.full.d.ts
│ │ │ ├── lib.es2018.intl.d.ts
│ │ │ ├── lib.es2018.promise.d.ts
│ │ │ ├── lib.es2018.regexp.d.ts
│ │ │ ├── lib.es2019.array.d.ts
│ │ │ ├── lib.es2019.d.ts
│ │ │ ├── lib.es2019.full.d.ts
│ │ │ ├── lib.es2019.intl.d.ts
│ │ │ ├── lib.es2019.object.d.ts
│ │ │ ├── lib.es2019.string.d.ts
│ │ │ ├── lib.es2019.symbol.d.ts
│ │ │ ├── lib.es2020.bigint.d.ts
│ │ │ ├── lib.es2020.d.ts
│ │ │ ├── lib.es2020.date.d.ts
│ │ │ ├── lib.es2020.full.d.ts
│ │ │ ├── lib.es2020.intl.d.ts
│ │ │ ├── lib.es2020.number.d.ts
│ │ │ ├── lib.es2020.promise.d.ts
│ │ │ ├── lib.es2020.sharedmemory.d.ts
│ │ │ ├── lib.es2020.string.d.ts
│ │ │ ├── lib.es2020.symbol.wellknown.d.ts
│ │ │ ├── lib.es2021.d.ts
│ │ │ ├── lib.es2021.full.d.ts
│ │ │ ├── lib.es2021.intl.d.ts
│ │ │ ├── lib.es2021.promise.d.ts
│ │ │ ├── lib.es2021.string.d.ts
│ │ │ ├── lib.es2021.weakref.d.ts
│ │ │ ├── lib.es2022.array.d.ts
│ │ │ ├── lib.es2022.d.ts
│ │ │ ├── lib.es2022.error.d.ts
│ │ │ ├── lib.es2022.full.d.ts
│ │ │ ├── lib.es2022.intl.d.ts
│ │ │ ├── lib.es2022.object.d.ts
│ │ │ ├── lib.es2022.regexp.d.ts
│ │ │ ├── lib.es2022.string.d.ts
│ │ │ ├── lib.es2023.array.d.ts
│ │ │ ├── lib.es2023.collection.d.ts
│ │ │ ├── lib.es2023.d.ts
│ │ │ ├── lib.es2023.full.d.ts
│ │ │ ├── lib.es2023.intl.d.ts
│ │ │ ├── lib.es2024.arraybuffer.d.ts
│ │ │ ├── lib.es2024.collection.d.ts
│ │ │ ├── lib.es2024.d.ts
│ │ │ ├── lib.es2024.full.d.ts
│ │ │ ├── lib.es2024.object.d.ts
│ │ │ ├── lib.es2024.promise.d.ts
│ │ │ ├── lib.es2024.regexp.d.ts
│ │ │ ├── lib.es2024.sharedmemory.d.ts
│ │ │ ├── lib.es2024.string.d.ts
│ │ │ ├── lib.es5.d.ts
│ │ │ ├── lib.es6.d.ts
│ │ │ ├── lib.esnext.array.d.ts
│ │ │ ├── lib.esnext.collection.d.ts
│ │ │ ├── lib.esnext.d.ts
│ │ │ ├── lib.esnext.decorators.d.ts
│ │ │ ├── lib.esnext.disposable.d.ts
│ │ │ ├── lib.esnext.full.d.ts
│ │ │ ├── lib.esnext.intl.d.ts
│ │ │ ├── lib.esnext.iterator.d.ts
│ │ │ ├── lib.scripthost.d.ts
│ │ │ ├── lib.webworker.asynciterable.d.ts
│ │ │ ├── lib.webworker.d.ts
│ │ │ ├── lib.webworker.importscripts.d.ts
│ │ │ ├── lib.webworker.iterable.d.ts
│ │ │ ├── pl
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── pt-br
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── ru
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── tr
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ ├── tsc.js
│ │ │ ├── tsserver.js
│ │ │ ├── tsserverlibrary.d.ts
│ │ │ ├── tsserverlibrary.js
│ │ │ ├── typescript.d.ts
│ │ │ ├── typescript.js
│ │ │ ├── typesMap.json
│ │ │ ├── typingsInstaller.js
│ │ │ ├── watchGuard.js
│ │ │ ├── zh-cn
│ │ │ │ └── diagnosticMessages.generated.json
│ │ │ └── zh-tw
│ │ │ └── diagnosticMessages.generated.json
│ │ ├── LICENSE.txt
│ │ ├── package.json
│ │ ├── README.md
│ │ ├── SECURITY.md
│ │ └── ThirdPartyNoticeText.txt
│ ├── undici-types
│ │ ├── agent.d.ts
│ │ ├── api.d.ts
│ │ ├── balanced-pool.d.ts
│ │ ├── cache.d.ts
│ │ ├── client.d.ts
│ │ ├── connector.d.ts
│ │ ├── content-type.d.ts
│ │ ├── cookies.d.ts
│ │ ├── diagnostics-channel.d.ts
│ │ ├── dispatcher.d.ts
│ │ ├── env-http-proxy-agent.d.ts
│ │ ├── errors.d.ts
│ │ ├── eventsource.d.ts
│ │ ├── fetch.d.ts
│ │ ├── file.d.ts
│ │ ├── filereader.d.ts
│ │ ├── formdata.d.ts
│ │ ├── global-dispatcher.d.ts
│ │ ├── global-origin.d.ts
│ │ ├── handlers.d.ts
│ │ ├── header.d.ts
│ │ ├── index.d.ts
│ │ ├── interceptors.d.ts
│ │ ├── LICENSE
│ │ ├── mock-agent.d.ts
│ │ ├── mock-client.d.ts
│ │ ├── mock-errors.d.ts
│ │ ├── mock-interceptor.d.ts
│ │ ├── mock-pool.d.ts
│ │ ├── package.json
│ │ ├── patch.d.ts
│ │ ├── pool-stats.d.ts
│ │ ├── pool.d.ts
│ │ ├── proxy-agent.d.ts
│ │ ├── readable.d.ts
│ │ ├── README.md
│ │ ├── retry-agent.d.ts
│ │ ├── retry-handler.d.ts
│ │ ├── util.d.ts
│ │ ├── webidl.d.ts
│ │ └── websocket.d.ts
│ ├── unpipe
│ │ ├── HISTORY.md
│ │ ├── index.js
│ │ ├── LICENSE
│ │ ├── package.json
│ │ └── README.md
│ ├── wrappy
│ │ ├── LICENSE
│ │ ├── package.json
│ │ ├── README.md
│ │ └── wrappy.js
│ └── zod
│ ├── index.d.ts
│ ├── lib
│ │ ├── __tests__
│ │ │ ├── Mocker.d.ts
│ │ │ └── Mocker.js
│ │ ├── benchmarks
│ │ │ ├── datetime.d.ts
│ │ │ ├── datetime.js
│ │ │ ├── discriminatedUnion.d.ts
│ │ │ ├── discriminatedUnion.js
│ │ │ ├── index.d.ts
│ │ │ ├── index.js
│ │ │ ├── ipv4.d.ts
│ │ │ ├── ipv4.js
│ │ │ ├── object.d.ts
│ │ │ ├── object.js
│ │ │ ├── primitives.d.ts
│ │ │ ├── primitives.js
│ │ │ ├── realworld.d.ts
│ │ │ ├── realworld.js
│ │ │ ├── string.d.ts
│ │ │ ├── string.js
│ │ │ ├── union.d.ts
│ │ │ └── union.js
│ │ ├── errors.d.ts
│ │ ├── errors.js
│ │ ├── external.d.ts
│ │ ├── external.js
│ │ ├── helpers
│ │ │ ├── enumUtil.d.ts
│ │ │ ├── enumUtil.js
│ │ │ ├── errorUtil.d.ts
│ │ │ ├── errorUtil.js
│ │ │ ├── parseUtil.d.ts
│ │ │ ├── parseUtil.js
│ │ │ ├── partialUtil.d.ts
│ │ │ ├── partialUtil.js
│ │ │ ├── typeAliases.d.ts
│ │ │ ├── typeAliases.js
│ │ │ ├── util.d.ts
│ │ │ └── util.js
│ │ ├── index.d.ts
│ │ ├── index.js
│ │ ├── index.mjs
│ │ ├── index.umd.js
│ │ ├── locales
│ │ │ ├── en.d.ts
│ │ │ └── en.js
│ │ ├── standard-schema.d.ts
│ │ ├── standard-schema.js
│ │ ├── types.d.ts
│ │ ├── types.js
│ │ ├── ZodError.d.ts
│ │ └── ZodError.js
│ ├── LICENSE
│ ├── package.json
│ └── README.md
├── package-lock.json
├── package.json
├── README.md
├── src
│ ├── index.ts
│ ├── reasoner.ts
│ ├── state.ts
│ ├── strategies
│ │ ├── base.ts
│ │ ├── beam-search.ts
│ │ ├── experiments
│ │ │ ├── mcts-002-alpha.ts
│ │ │ └── mcts-002alt-alpha.ts
│ │ ├── factory.ts
│ │ └── mcts.ts
│ ├── types
│ │ └── modelcontextprotocol.d.ts
│ └── types.ts
└── tsconfig.json
```
# Files
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
```
node_modules/
dist/
```
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
```markdown
# MCP Reasoner
A reasoning implementation for Claude Desktop that lets you use both Beam Search and Monte Carlo Tree Search (MCTS). tbh this started as a way to see if we could make Claude even better at complex problem-solving... turns out we definitely can.
### Current Version:
**v2.0.0**
#### What's New:
> Added 2 Experimental Reasoning Algorithms:
>
> - `mcts-002-alpha`
>
> - Uses the A* Search Method along with an early *alpha* implementation of a Policy Simulation Layer
>
> - Also includes an early *alpha* implementation of Adaptive Exploration Simulator & Outcome Based Reasoning Simulator
>
> *NOTE* the implementation of these alpha simulators is not complete and is subject to change
>
> - `mcts-002alt-alpha`
>
> - Uses the Bidirectional Search Method along with an early *alpha* implementation of a Policy Simulation Layer
>
> - Also includes an early *alpha* implementation of Adaptive Exploration Simulator & Outcome Based Reasoning Simulator
>
> *NOTE* the implementation of these alpha simulators is not complete and is subject to change
What happened to `mcts-001-alpha` and `mcts-001alt-alpha`?
> Quite simply: It was useless and near similar to the base `mcts` method. After initial testing the results yielded in basic thought processes was near similar showing that simply adding policy simulation may not have an effect.
So why add Polciy Simulation Layer now?
> Well i think its important to incorporate Policy AND Search in tandem as that is how most of the algorithms implement them.
#### Previous Versions:
**v1.1.0**
> Added model control over search parameters:
>
> beamWidth - lets Claude adjust how many paths to track (1-10)
>
> numSimulations - fine-tune MCTS simulation count (1-150)
## Features
- Two search strategies that you can switch between:
- Beam search (good for straightforward stuff)
- MCTS (when stuff gets complex) with alpha variations (see above)
- Tracks how good different reasoning paths are
- Maps out all the different ways Claude thinks through problems
- Analyzes how the reasoning process went
- Follows the MCP protocol (obviously)
## Installation
```
git clone https://github.com/frgmt0/mcp-reasoner.git
OR clone the original:
git clone https://github.com/Jacck/mcp-reasoner.git
cd mcp-reasoner
npm install
npm run build
```
## Configuration
Add to Claude Desktop config:
```
{
"mcpServers": {
"mcp-reasoner": {
"command": "node",
"args": ["path/to/mcp-reasoner/dist/index.js"],
}
}
}
```
## Testing
[More Testing Coming Soon]
## Benchmarks
[Benchmarking will be added soon]
Key Benchmarks to test against:
- MATH500
- GPQA-Diamond
- GMSK8
- Maybe Polyglot &/or SWE-Bench
## License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
```
--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
```json
{
"compilerOptions": {
"target": "ES2020",
"module": "ES2020",
"moduleResolution": "node",
"outDir": "./dist",
"rootDir": "./src",
"strict": true,
"esModuleInterop": true,
"skipLibCheck": true,
"forceConsistentCasingInFileNames": true,
"declaration": true,
"resolveJsonModule": true
},
"include": ["src/**/*"],
"exclude": ["node_modules", "dist"]
}
```
--------------------------------------------------------------------------------
/src/types/modelcontextprotocol.d.ts:
--------------------------------------------------------------------------------
```typescript
declare module '@modelcontextprotocol/sdk/server/index.js' {
export class Server {
constructor(info: { name: string; version: string }, config: { capabilities: { tools: {} } });
setRequestHandler(schema: any, handler: (request: any) => Promise<any>): void;
connect(transport: any): Promise<void>;
}
}
declare module '@modelcontextprotocol/sdk/server/stdio.js' {
export class StdioServerTransport {
constructor();
}
}
declare module '@modelcontextprotocol/sdk/types.js' {
export interface Tool {
name: string;
description: string;
inputSchema: {
type: string;
properties: Record<string, any>;
required: string[];
};
}
export const CallToolRequestSchema: {
params: {
name: string;
arguments: any;
};
};
export const ListToolsRequestSchema: {
params: any;
};
}
```
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
```json
{
"name": "mcp-reasoner",
"version": "2.0.0",
"description": "MCP Reasoner with multiple reasoning strategies including Beam Search and Monte Carlo Tree Search",
"type": "module",
"main": "dist/index.js",
"types": "dist/index.d.ts",
"scripts": {
"build": "tsc",
"start": "node dist/index.js",
"clean": "shx rm -rf dist",
"prebuild": "npm run clean",
"test": "jest",
"lint": "eslint src --ext .ts",
"format": "prettier --write \"src/**/*.ts\"",
"prepare": "npm run build"
},
"dependencies": {
"@modelcontextprotocol/sdk": "*",
"chalk": "^5.3.0",
"uuid": "^9.0.0"
},
"devDependencies": {
"@types/jest": "^29.5.0",
"@types/node": "^20.0.0",
"@types/uuid": "^10.0.0",
"@typescript-eslint/eslint-plugin": "^6.0.0",
"@typescript-eslint/parser": "^6.0.0",
"eslint": "^8.0.0",
"jest": "^29.5.0",
"prettier": "^3.0.0",
"shx": "^0.3.4",
"ts-jest": "^29.1.0",
"typescript": "^5.0.0"
},
"keywords": [
"mcp",
"reasoning",
"beam-search",
"monte-carlo-tree-search",
"ai",
"search"
],
"author": "",
"license": "MIT",
"engines": {
"node": ">=16.0.0"
}
}
```
--------------------------------------------------------------------------------
/src/strategies/factory.ts:
--------------------------------------------------------------------------------
```typescript
import { StateManager } from '../state.js';
import { BaseStrategy } from './base.js';
import { BeamSearchStrategy } from './beam-search.js';
import { MonteCarloTreeSearchStrategy } from './mcts.js';
import { MCTS002AlphaStrategy } from './experiments/mcts-002-alpha.js';
import { MCTS002AltAlphaStrategy } from './experiments/mcts-002alt-alpha.js';
export enum ReasoningStrategy {
BEAM_SEARCH = 'beam_search',
MCTS = 'mcts',
MCTS_002_ALPHA = 'mcts_002_alpha',
MCTS_002_ALT_ALPHA = 'mcts_002_alt_alpha'
}
export class StrategyFactory {
static createStrategy(
type: ReasoningStrategy,
stateManager: StateManager,
beamWidth?: number,
numSimulations?: number
): BaseStrategy {
switch (type) {
case ReasoningStrategy.BEAM_SEARCH:
return new BeamSearchStrategy(stateManager, beamWidth);
case ReasoningStrategy.MCTS:
return new MonteCarloTreeSearchStrategy(stateManager, numSimulations);
case ReasoningStrategy.MCTS_002_ALPHA:
return new MCTS002AlphaStrategy(stateManager, numSimulations);
case ReasoningStrategy.MCTS_002_ALT_ALPHA:
return new MCTS002AltAlphaStrategy(stateManager, numSimulations);
default:
throw new Error(`Unknown strategy type: ${type}`);
}
}
}
```
--------------------------------------------------------------------------------
/src/types.ts:
--------------------------------------------------------------------------------
```typescript
export interface ThoughtNode {
id: string;
thought: string;
score: number;
depth: number;
children: string[]; // Store child IDs
parentId?: string; // Store parent ID
isComplete: boolean;
}
export interface ReasoningRequest {
thought: string;
thoughtNumber: number;
totalThoughts: number;
nextThoughtNeeded: boolean;
parentId?: string; // For branching thoughts
strategyType?: string; // Strategy to use for reasoning
beamWidth?: number; // Number of top paths to maintain (n-sampling)
numSimulations?: number; // Number of MCTS simulations to run
}
export interface ReasoningResponse {
nodeId: string;
thought: string;
score: number;
depth: number;
isComplete: boolean;
nextThoughtNeeded: boolean;
possiblePaths?: number;
bestScore?: number;
strategyUsed?: string;
}
export interface ReasoningStats {
totalNodes: number;
averageScore: number;
maxDepth: number;
branchingFactor: number;
strategyMetrics?: Record<string, any>;
}
export const CONFIG = {
beamWidth: 3, // Keep top 3 paths
maxDepth: 5, // Reasonable depth limit
minScore: 0.5, // Threshold for path viability
temperature: 0.7, // For thought diversity
cacheSize: 1000, // LRU cache size
defaultStrategy: 'beam_search', // Default reasoning strategy
numSimulations: 50 // Default number of MCTS simulations
} as const;
```
--------------------------------------------------------------------------------
/src/state.ts:
--------------------------------------------------------------------------------
```typescript
import { ThoughtNode } from './types.js';
class LRUCache<K, V> {
private cache = new Map<K, V>();
private readonly maxSize: number;
constructor(maxSize: number) {
this.maxSize = maxSize;
}
get(key: K): V | undefined {
const value = this.cache.get(key);
if (value) {
// Refresh by removing and re-adding
this.cache.delete(key);
this.cache.set(key, value);
}
return value;
}
set(key: K, value: V): void {
// Remove oldest if at capacity
if (this.cache.size >= this.maxSize) {
const firstKey = Array.from(this.cache.keys())[0];
if (firstKey !== undefined) {
this.cache.delete(firstKey);
}
}
// Add new value
this.cache.set(key, value);
}
clear(): void {
this.cache.clear();
}
size(): number {
return this.cache.size;
}
has(key: K): boolean {
return this.cache.has(key);
}
}
export class StateManager {
private cache: LRUCache<string, ThoughtNode>;
private nodes = new Map<string, ThoughtNode>();
constructor(cacheSize: number) {
this.cache = new LRUCache(cacheSize);
}
async getNode(id: string): Promise<ThoughtNode | undefined> {
// Check cache first
const cached = this.cache.get(id);
if (cached) return cached;
// Check main storage
const node = this.nodes.get(id);
if (node) {
this.cache.set(id, node);
return node;
}
return undefined;
}
async saveNode(node: ThoughtNode): Promise<void> {
this.nodes.set(node.id, node);
this.cache.set(node.id, node);
}
async getChildren(nodeId: string): Promise<ThoughtNode[]> {
const node = await this.getNode(nodeId);
if (!node) return [];
const children = await Promise.all(
node.children.map(id => this.getNode(id))
);
return children.filter((n): n is ThoughtNode => n !== undefined);
}
async getPath(nodeId: string): Promise<ThoughtNode[]> {
const path: ThoughtNode[] = [];
let currentId = nodeId;
while (currentId) {
const node = await this.getNode(currentId);
if (!node) break;
path.unshift(node);
currentId = node.parentId || '';
}
return path;
}
async getAllNodes(): Promise<ThoughtNode[]> {
return Array.from(this.nodes.values());
}
clear(): void {
this.nodes.clear();
this.cache.clear();
}
}
```
--------------------------------------------------------------------------------
/src/strategies/beam-search.ts:
--------------------------------------------------------------------------------
```typescript
import { v4 as uuidv4 } from 'uuid';
import { ThoughtNode, ReasoningRequest, ReasoningResponse, CONFIG } from '../types.js';
import { BaseStrategy } from './base.js';
export class BeamSearchStrategy extends BaseStrategy {
private beamWidth: number;
private beams: Map<number, ThoughtNode[]>;
constructor(stateManager: any, beamWidth: number = CONFIG.beamWidth) {
super(stateManager);
this.beamWidth = beamWidth;
this.beams = new Map();
}
public async processThought(request: ReasoningRequest): Promise<ReasoningResponse> {
const nodeId = uuidv4();
const parentNode = request.parentId ?
await this.getNode(request.parentId) : undefined;
const node: ThoughtNode = {
id: nodeId,
thought: request.thought,
depth: request.thoughtNumber - 1,
score: 0,
children: [],
parentId: request.parentId,
isComplete: !request.nextThoughtNeeded
};
// Evaluate and score the node
node.score = this.evaluateThought(node, parentNode);
await this.saveNode(node);
// Update parent if exists
if (parentNode) {
parentNode.children.push(node.id);
await this.saveNode(parentNode);
}
// Manage beam at current depth
let currentBeam = this.beams.get(node.depth) || [];
currentBeam.push(node);
currentBeam.sort((a, b) => b.score - a.score);
// Prune beam to maintain beam width
if (currentBeam.length > this.beamWidth) {
currentBeam = currentBeam.slice(0, this.beamWidth);
}
this.beams.set(node.depth, currentBeam);
// Calculate path statistics
const currentPath = await this.stateManager.getPath(nodeId);
const pathScore = currentPath.reduce((acc, n) => acc + n.score, 0) / currentPath.length;
// Get best path score from all beams
const bestBeamScore = Math.max(
...Array.from(this.beams.values())
.flat()
.map(n => n.score)
);
return {
nodeId: node.id,
thought: node.thought,
score: node.score,
depth: node.depth,
isComplete: node.isComplete,
nextThoughtNeeded: request.nextThoughtNeeded,
possiblePaths: this.calculatePossiblePaths(),
bestScore: Math.max(pathScore, bestBeamScore)
};
}
private calculatePossiblePaths(): number {
let totalPaths = 0;
this.beams.forEach((beam, depth) => {
const nextBeam = this.beams.get(depth + 1);
if (nextBeam) {
totalPaths += beam.length * nextBeam.length;
} else {
totalPaths += beam.length;
}
});
return totalPaths;
}
public async getBestPath(): Promise<ThoughtNode[]> {
// Find the deepest beam
const maxDepth = Math.max(...Array.from(this.beams.keys()));
const deepestBeam = this.beams.get(maxDepth) || [];
if (deepestBeam.length === 0) return [];
// Get the best scoring node from deepest beam
const bestNode = deepestBeam.reduce((a, b) => a.score > b.score ? a : b);
// Reconstruct path
const path = await this.stateManager.getPath(bestNode.id);
return path;
}
public async getMetrics(): Promise<any> {
const baseMetrics = await super.getMetrics();
return {
...baseMetrics,
beamWidth: this.beamWidth,
activeBeams: this.beams.size,
totalBeamNodes: Array.from(this.beams.values()).flat().length
};
}
public async clear(): Promise<void> {
await super.clear();
this.beams.clear();
}
}
```
--------------------------------------------------------------------------------
/src/strategies/base.ts:
--------------------------------------------------------------------------------
```typescript
import { ThoughtNode, ReasoningRequest, ReasoningResponse } from '../types.js';
import { StateManager } from '../state.js';
export interface StrategyMetrics {
name: string;
nodesExplored: number;
averageScore: number;
maxDepth: number;
active?: boolean;
[key: string]: number | string | boolean | undefined; // Allow additional strategy-specific metrics including booleans
}
export abstract class BaseStrategy {
protected stateManager: StateManager;
constructor(stateManager: StateManager) {
this.stateManager = stateManager;
}
abstract processThought(request: ReasoningRequest): Promise<ReasoningResponse>;
protected async getNode(id: string): Promise<ThoughtNode | undefined> {
return this.stateManager.getNode(id);
}
protected async saveNode(node: ThoughtNode): Promise<void> {
return this.stateManager.saveNode(node);
}
protected evaluateThought(node: ThoughtNode, parent?: ThoughtNode): number {
// Base evaluation logic
const logicalScore = this.calculateLogicalScore(node, parent);
const depthPenalty = this.calculateDepthPenalty(node);
const completionBonus = node.isComplete ? 0.2 : 0;
return (logicalScore + depthPenalty + completionBonus) / 3;
}
private calculateLogicalScore(node: ThoughtNode, parent?: ThoughtNode): number {
let score = 0;
// Length and complexity
score += Math.min(node.thought.length / 200, 0.3);
// Logical connectors
if (/\b(therefore|because|if|then|thus|hence|so)\b/i.test(node.thought)) {
score += 0.2;
}
// Mathematical/logical expressions
if (/[+\-*/=<>]/.test(node.thought)) {
score += 0.2;
}
// Parent-child coherence
if (parent) {
const coherence = this.calculateCoherence(parent.thought, node.thought);
score += coherence * 0.3;
}
return score;
}
private calculateDepthPenalty(node: ThoughtNode): number {
return Math.max(0, 1 - (node.depth / 10) * 0.3);
}
private calculateCoherence(parentThought: string, childThought: string): number {
// Simple coherence based on shared terms
const parentTerms = new Set(parentThought.toLowerCase().split(/\W+/));
const childTerms = childThought.toLowerCase().split(/\W+/);
const sharedTerms = childTerms.filter(term => parentTerms.has(term)).length;
return Math.min(sharedTerms / childTerms.length, 1);
}
// Required methods for all strategies
public async getBestPath(): Promise<ThoughtNode[]> {
const nodes = await this.stateManager.getAllNodes();
if (nodes.length === 0) return [];
// Default implementation - find highest scoring complete path
const completedNodes = nodes.filter(n => n.isComplete)
.sort((a, b) => b.score - a.score);
if (completedNodes.length === 0) return [];
return this.stateManager.getPath(completedNodes[0].id);
}
public async getMetrics(): Promise<StrategyMetrics> {
const nodes = await this.stateManager.getAllNodes();
return {
name: this.constructor.name,
nodesExplored: nodes.length,
averageScore: nodes.length > 0
? nodes.reduce((sum, n) => sum + n.score, 0) / nodes.length
: 0,
maxDepth: nodes.length > 0
? Math.max(...nodes.map(n => n.depth))
: 0
};
}
public async clear(): Promise<void> {
// Optional cleanup method for strategies
// Default implementation does nothing
}
}
```
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
import { Reasoner } from './reasoner.js';
import { ReasoningStrategy } from './strategies/factory.js';
// Initialize server
const server = new Server(
{
name: "mcp-reasoner",
version: "1.0.0",
},
{
capabilities: {
tools: {},
},
}
);
// Initialize reasoner
const reasoner = new Reasoner();
// Process input and ensure correct types
function processInput(input: any) {
const result = {
thought: String(input.thought || ""),
thoughtNumber: Number(input.thoughtNumber || 0),
totalThoughts: Number(input.totalThoughts || 0),
nextThoughtNeeded: Boolean(input.nextThoughtNeeded),
strategyType: input.strategyType as ReasoningStrategy | undefined,
beamWidth: Number(input.beamWidth || 3),
numSimulations: Number(input.numSimulations || 50)
};
// Validate
if (!result.thought) {
throw new Error("thought must be provided");
}
if (result.thoughtNumber < 1) {
throw new Error("thoughtNumber must be >= 1");
}
if (result.totalThoughts < 1) {
throw new Error("totalThoughts must be >= 1");
}
if (result.beamWidth < 1 || result.beamWidth > 10) {
throw new Error("beamWidth must be between 1 and 10");
}
if (result.numSimulations < 1 || result.numSimulations > 150) {
throw new Error("numSimulations must be between 1 and 150");
}
return result;
}
// Register the tool
server.setRequestHandler(ListToolsRequestSchema, async () => ({
tools: [{
name: "mcp-reasoner",
description: "Advanced reasoning tool with multiple strategies including Beam Search and Monte Carlo Tree Search",
inputSchema: {
type: "object",
properties: {
thought: {
type: "string",
description: "Current reasoning step"
},
thoughtNumber: {
type: "integer",
description: "Current step number",
minimum: 1
},
totalThoughts: {
type: "integer",
description: "Total expected steps",
minimum: 1
},
nextThoughtNeeded: {
type: "boolean",
description: "Whether another step is needed"
},
strategyType: {
type: "string",
enum: Object.values(ReasoningStrategy),
description: "Reasoning strategy to use (beam_search or mcts)"
},
beamWidth: {
type: "integer",
description: "Number of top paths to maintain (n-sampling). Defaults to 3 if not specified",
minimum: 1,
maximum: 10
},
numSimulations: {
type: "integer",
description: "Number of MCTS simulations to run. Defaults to 50 if not specified",
minimum: 1,
maximum: 150
}
},
required: ["thought", "thoughtNumber", "totalThoughts", "nextThoughtNeeded"]
}
}]
}));
// Handle requests
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name !== "mcp-reasoner") {
return {
content: [{
type: "text",
text: JSON.stringify({ error: "Unknown tool", success: false })
}],
isError: true
};
}
try {
// Process and validate input
const step = processInput(request.params.arguments);
// Process thought with selected strategy
const response = await reasoner.processThought({
thought: step.thought,
thoughtNumber: step.thoughtNumber,
totalThoughts: step.totalThoughts,
nextThoughtNeeded: step.nextThoughtNeeded,
strategyType: step.strategyType,
beamWidth: step.beamWidth,
numSimulations: step.numSimulations
});
// Get reasoning stats
const stats = await reasoner.getStats();
// Return enhanced response
const result = {
thoughtNumber: step.thoughtNumber,
totalThoughts: step.totalThoughts,
nextThoughtNeeded: step.nextThoughtNeeded,
thought: step.thought,
nodeId: response.nodeId,
score: response.score,
strategyUsed: response.strategyUsed,
stats: {
totalNodes: stats.totalNodes,
averageScore: stats.averageScore,
maxDepth: stats.maxDepth,
branchingFactor: stats.branchingFactor,
strategyMetrics: stats.strategyMetrics
}
};
return {
content: [{
type: "text",
text: JSON.stringify(result)
}]
};
} catch (error) {
return {
content: [{
type: "text",
text: JSON.stringify({
error: error instanceof Error ? error.message : String(error),
success: false
})
}],
isError: true
};
}
});
// Start server
const transport = new StdioServerTransport();
server.connect(transport).catch(error => {
process.stderr.write(`Error starting server: ${error}\n`);
process.exit(1);
});
```
--------------------------------------------------------------------------------
/src/reasoner.ts:
--------------------------------------------------------------------------------
```typescript
import { ThoughtNode, ReasoningRequest, ReasoningResponse, ReasoningStats, CONFIG } from './types.js';
import { StateManager } from './state.js';
import { StrategyFactory, ReasoningStrategy } from './strategies/factory.js';
import { BaseStrategy, StrategyMetrics } from './strategies/base.js';
export class Reasoner {
private stateManager: StateManager;
private currentStrategy: BaseStrategy;
private strategies: Map<ReasoningStrategy, BaseStrategy>;
constructor() {
this.stateManager = new StateManager(CONFIG.cacheSize);
// Initialize available strategies
this.strategies = new Map();
// Initialize base strategies
this.strategies.set(
ReasoningStrategy.BEAM_SEARCH,
StrategyFactory.createStrategy(ReasoningStrategy.BEAM_SEARCH, this.stateManager, CONFIG.beamWidth)
);
this.strategies.set(
ReasoningStrategy.MCTS,
StrategyFactory.createStrategy(ReasoningStrategy.MCTS, this.stateManager, undefined, CONFIG.numSimulations)
);
// Initialize experimental MCTS strategies
this.strategies.set(
ReasoningStrategy.MCTS_002_ALPHA,
StrategyFactory.createStrategy(ReasoningStrategy.MCTS_002_ALPHA, this.stateManager, undefined, CONFIG.numSimulations)
);
this.strategies.set(
ReasoningStrategy.MCTS_002_ALT_ALPHA,
StrategyFactory.createStrategy(ReasoningStrategy.MCTS_002_ALT_ALPHA, this.stateManager, undefined, CONFIG.numSimulations)
);
// Set default strategy
const defaultStrategy = CONFIG.defaultStrategy as ReasoningStrategy;
this.currentStrategy = this.strategies.get(defaultStrategy) ||
this.strategies.get(ReasoningStrategy.BEAM_SEARCH)!;
}
public async processThought(request: ReasoningRequest): Promise<ReasoningResponse> {
// Switch strategy if requested
if (request.strategyType && this.strategies.has(request.strategyType as ReasoningStrategy)) {
const strategyType = request.strategyType as ReasoningStrategy;
// Create new strategy instance with appropriate parameters
if (strategyType === ReasoningStrategy.BEAM_SEARCH) {
this.currentStrategy = StrategyFactory.createStrategy(
strategyType,
this.stateManager,
request.beamWidth
);
} else {
// All MCTS variants (base and experimental) use numSimulations
this.currentStrategy = StrategyFactory.createStrategy(
strategyType,
this.stateManager,
undefined,
request.numSimulations
);
}
// Update strategy in map
this.strategies.set(strategyType, this.currentStrategy);
}
// Process thought using current strategy
const response = await this.currentStrategy.processThought(request);
// Add strategy information to response
return {
...response,
strategyUsed: this.getCurrentStrategyName()
};
}
public async getStats(): Promise<ReasoningStats> {
const nodes = await this.stateManager.getAllNodes();
if (nodes.length === 0) {
return {
totalNodes: 0,
averageScore: 0,
maxDepth: 0,
branchingFactor: 0,
strategyMetrics: {}
};
}
const scores = nodes.map(n => n.score);
const depths = nodes.map(n => n.depth);
const branchingFactors = nodes.map(n => n.children.length);
const metrics = await this.getStrategyMetrics();
return {
totalNodes: nodes.length,
averageScore: scores.reduce((a, b) => a + b, 0) / scores.length,
maxDepth: Math.max(...depths),
branchingFactor: branchingFactors.reduce((a, b) => a + b, 0) / nodes.length,
strategyMetrics: metrics
};
}
private async getStrategyMetrics(): Promise<Record<string, StrategyMetrics>> {
const metrics: Record<string, StrategyMetrics> = {};
for (const [name, strategy] of this.strategies.entries()) {
metrics[name] = await strategy.getMetrics();
if (strategy === this.currentStrategy) {
metrics[name] = {
...metrics[name],
active: true
};
}
}
return metrics;
}
public getCurrentStrategyName(): ReasoningStrategy {
for (const [name, strategy] of this.strategies.entries()) {
if (strategy === this.currentStrategy) {
return name;
}
}
return ReasoningStrategy.BEAM_SEARCH;
}
public async getBestPath(): Promise<ThoughtNode[]> {
return this.currentStrategy.getBestPath();
}
public async clear(): Promise<void> {
await this.stateManager.clear();
// Clear all strategies
for (const strategy of this.strategies.values()) {
await strategy.clear();
}
}
public setStrategy(strategyType: ReasoningStrategy, beamWidth?: number, numSimulations?: number): void {
if (!this.strategies.has(strategyType)) {
throw new Error(`Unknown strategy type: ${strategyType}`);
}
// Create new strategy instance with appropriate parameters
if (strategyType === ReasoningStrategy.BEAM_SEARCH) {
this.currentStrategy = StrategyFactory.createStrategy(strategyType, this.stateManager, beamWidth);
} else {
// All MCTS variants (base and experimental) use numSimulations
this.currentStrategy = StrategyFactory.createStrategy(strategyType, this.stateManager, undefined, numSimulations);
}
// Update strategy in map
this.strategies.set(strategyType, this.currentStrategy);
}
public getAvailableStrategies(): ReasoningStrategy[] {
return Array.from(this.strategies.keys());
}
}
```
--------------------------------------------------------------------------------
/src/strategies/mcts.ts:
--------------------------------------------------------------------------------
```typescript
import { v4 as uuidv4 } from 'uuid';
import { ThoughtNode, ReasoningRequest, ReasoningResponse, CONFIG } from '../types.js';
import { BaseStrategy } from './base.js';
interface MCTSNode extends ThoughtNode {
visits: number;
totalReward: number;
untriedActions?: string[];
}
export class MonteCarloTreeSearchStrategy extends BaseStrategy {
private readonly explorationConstant = Math.sqrt(2);
private readonly simulationDepth = CONFIG.maxDepth;
private numSimulations: number;
private root: MCTSNode | null = null;
constructor(stateManager: any, numSimulations: number = CONFIG.numSimulations) {
super(stateManager);
// Ensure numSimulations is within reasonable bounds
this.numSimulations = Math.max(1, Math.min(150, numSimulations));
}
public async processThought(request: ReasoningRequest): Promise<ReasoningResponse> {
const nodeId = uuidv4();
const parentNode = request.parentId ?
await this.getNode(request.parentId) as MCTSNode : undefined;
const node: MCTSNode = {
id: nodeId,
thought: request.thought,
depth: request.thoughtNumber - 1,
score: 0,
children: [],
parentId: request.parentId,
isComplete: !request.nextThoughtNeeded,
visits: 0,
totalReward: 0,
untriedActions: []
};
// Initialize node
node.score = this.evaluateThought(node, parentNode);
node.visits = 1;
node.totalReward = node.score;
await this.saveNode(node);
// Update parent if exists
if (parentNode) {
parentNode.children.push(node.id);
await this.saveNode(parentNode);
}
// If this is a root node, store it
if (!parentNode) {
this.root = node;
}
// Run MCTS simulations
if (!node.isComplete) {
await this.runSimulations(node);
}
// Calculate path statistics
const currentPath = await this.stateManager.getPath(nodeId);
const pathScore = this.calculatePathScore(currentPath);
return {
nodeId: node.id,
thought: node.thought,
score: node.score,
depth: node.depth,
isComplete: node.isComplete,
nextThoughtNeeded: request.nextThoughtNeeded,
possiblePaths: this.calculatePossiblePaths(node),
bestScore: pathScore
};
}
private async runSimulations(node: MCTSNode): Promise<void> {
for (let i = 0; i < this.numSimulations; i++) {
const selectedNode = await this.select(node);
const expandedNode = await this.expand(selectedNode);
const reward = await this.simulate(expandedNode);
await this.backpropagate(expandedNode, reward);
}
}
private async select(node: MCTSNode): Promise<MCTSNode> {
let current = node;
while (current.children.length > 0 && !current.untriedActions?.length) {
const children = await Promise.all(
current.children.map(id => this.getNode(id))
) as MCTSNode[];
current = this.selectBestUCT(children);
}
return current;
}
private async expand(node: MCTSNode): Promise<MCTSNode> {
if (node.isComplete || node.depth >= this.simulationDepth) {
return node;
}
// Create a new thought node as expansion
const newNode: MCTSNode = {
id: uuidv4(),
thought: `Simulated thought at depth ${node.depth + 1}`,
depth: node.depth + 1,
score: 0,
children: [],
parentId: node.id,
isComplete: false,
visits: 1,
totalReward: 0
};
newNode.score = this.evaluateThought(newNode, node);
await this.saveNode(newNode);
node.children.push(newNode.id);
await this.saveNode(node);
return newNode;
}
private async simulate(node: MCTSNode): Promise<number> {
let current = node;
let totalScore = current.score;
let depth = current.depth;
while (depth < this.simulationDepth && !current.isComplete) {
const simulatedNode: MCTSNode = {
id: uuidv4(),
thought: `Random simulation at depth ${depth + 1}`,
depth: depth + 1,
score: 0,
children: [],
parentId: current.id,
isComplete: depth + 1 >= this.simulationDepth,
visits: 1,
totalReward: 0
};
simulatedNode.score = this.evaluateThought(simulatedNode, current);
totalScore += simulatedNode.score;
current = simulatedNode;
depth++;
}
return totalScore / (depth - node.depth + 1);
}
private async backpropagate(node: MCTSNode, reward: number): Promise<void> {
let current: MCTSNode | undefined = node;
while (current) {
current.visits++;
current.totalReward += reward;
await this.saveNode(current);
current = current.parentId ?
await this.getNode(current.parentId) as MCTSNode :
undefined;
}
}
private selectBestUCT(nodes: MCTSNode[]): MCTSNode {
const totalVisits = nodes.reduce((sum, node) => sum + node.visits, 0);
return nodes.reduce((best, node) => {
const exploitation = node.totalReward / node.visits;
const exploration = Math.sqrt(Math.log(totalVisits) / node.visits);
const uct = exploitation + this.explorationConstant * exploration;
return uct > (best.totalReward / best.visits +
this.explorationConstant * Math.sqrt(Math.log(totalVisits) / best.visits))
? node : best;
});
}
private calculatePathScore(path: ThoughtNode[]): number {
if (path.length === 0) return 0;
return path.reduce((acc, node) => acc + node.score, 0) / path.length;
}
private calculatePossiblePaths(node: MCTSNode): number {
return Math.pow(2, this.simulationDepth - node.depth);
}
public async getBestPath(): Promise<ThoughtNode[]> {
if (!this.root) return [];
const bestChild = (await Promise.all(
this.root.children.map(id => this.getNode(id))
) as MCTSNode[])
.reduce((best, node) =>
node.visits > best.visits ? node : best
);
return this.stateManager.getPath(bestChild.id);
}
public async getMetrics(): Promise<any> {
const baseMetrics = await super.getMetrics();
return {
...baseMetrics,
simulationDepth: this.simulationDepth,
numSimulations: this.numSimulations,
explorationConstant: this.explorationConstant,
totalSimulations: this.root?.visits || 0
};
}
public async clear(): Promise<void> {
await super.clear();
this.root = null;
}
}
```