szabomarton/Frontend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added factorial module

Browse Source
This commit is contained in:
szabomarton
2024-10-22 13:12:20 +02:00
parent 7f2ddb3a86
commit e12780f413
2836 changed files with 207364 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

24
24_10_22_faktorialis/node_modules/mathjs/CONTRIBUTING.md generated vendored Normal file
View File

@@ -0,0 +1,24 @@
## Contributing
Contributions to the math.js library are very welcome! We can't do this alone. You can contribute in different ways: spread the word, report bugs, come up with ideas and suggestions, and contribute to the code.
### What can I do?
Search through the [issues](https://github.com/josdejong/mathjs/issues) looking for bugs that you can help fix, or look at [discussions/ideas](https://github.com/josdejong/mathjs/discussions/categories/ideas) to see if there is an idea for a new feature that that looks interesting to pick up.
### There are a few preferences regarding code contributions:
- The code of math.js follows the JavaScript Standard Style as described on https://standardjs.com/, powered by `eslint`. Run `npm run lint` to test, and `npm run format` to automatically adjust your code to the code style.
- Make sure you properly unit test your changes.
- Before creating a pull request, run the unit tests to make sure they all pass.
- Only commit changes done in the source files under `src`, not to the generated builds
which are located in the folders `dist` and `lib`.
- Send pull requests to the `develop` branch, not the `master` branch.
### FAQ
- How to implement a new function? Answer: See the section [Implementing a new function](README.md#implementing-a-new-function) in the README.md.
- Where to find more documentation? Answer: best starting point is the project's [README.md](https://github.com/josdejong/mathjs#readme) file.
- I'm not sure how/where to start, what now? Answer: feel free to ask when in doubt, just [open an issue](https://github.com/josdejong/mathjs/issues) and discuss your thoughts and questions.
Thanks!

2960
24_10_22_faktorialis/node_modules/mathjs/HISTORY.md generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

176
24_10_22_faktorialis/node_modules/mathjs/LICENSE generated vendored Normal file
View File

@@ -0,0 +1,176 @@
Apache License
Version 2.0, January 2004
https://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS

16
24_10_22_faktorialis/node_modules/mathjs/NOTICE generated vendored Normal file
View File

@@ -0,0 +1,16 @@
math.js
https://github.com/josdejong/mathjs
Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

242
24_10_22_faktorialis/node_modules/mathjs/README.md generated vendored Normal file
View File

@@ -0,0 +1,242 @@
![math.js](https://raw.github.com/josdejong/mathjs/master/misc/img/mathjs.png)
[https://mathjs.org](https://mathjs.org)
Math.js is an extensive math library for JavaScript and Node.js. It features a flexible expression parser with support for symbolic computation, comes with a large set of built-in functions and constants, and offers an integrated solution to work with different data types like numbers, big numbers, complex numbers, fractions, units, and matrices. Powerful and easy to use.
[![Version](https://img.shields.io/npm/v/mathjs.svg)](https://www.npmjs.com/package/mathjs)
[![Downloads](https://img.shields.io/npm/dm/mathjs.svg)](https://www.npmjs.com/package/mathjs)
[![Build Status](https://github.com/josdejong/mathjs/workflows/Node.js%20CI/badge.svg)](https://github.com/josdejong/mathjs/actions)
[![Maintenance](https://img.shields.io/maintenance/yes/2024.svg)](https://github.com/josdejong/mathjs/graphs/commit-activity)
[![License](https://img.shields.io/github/license/josdejong/mathjs.svg)](https://github.com/josdejong/mathjs/blob/master/LICENSE)
[![FOSSA Status](https://app.fossa.io/api/projects/git%2Bgithub.com%2Fjosdejong%2Fmathjs.svg?type=shield)](https://app.fossa.io/projects/git%2Bgithub.com%2Fjosdejong%2Fmathjs?ref=badge_shield)
[![Codecov](https://codecov.io/gh/josdejong/mathjs/branch/develop/graph/badge.svg)](https://codecov.io/gh/josdejong/mathjs)
[![Github Sponsor](https://img.shields.io/github/sponsors/josdejong
)](https://github.com/sponsors/josdejong)
## Features
- Supports numbers, bignumbers, bigints, complex numbers, fractions, units, strings, arrays, and matrices.
- Is compatible with JavaScript's built-in Math library.
- Contains a flexible expression parser.
- Does symbolic computation.
- Comes with a large set of built-in functions and constants.
- Can be used as a command line application as well.
- Runs on any JavaScript engine.
- Is easily extensible.
- Open source.
## Usage
Math.js can be used in both node.js and in the browser.
Install math.js using [npm](https://www.npmjs.com/package/mathjs):
npm install mathjs
Or download mathjs via one of the CDN's listed on the downloads page:
&nbsp;&nbsp;&nbsp;&nbsp;[https://mathjs.org/download.html](https://mathjs.org/download.html#download)
Math.js can be used similar to JavaScript's built-in Math library. Besides that,
math.js can evaluate
[expressions](https://mathjs.org/docs/expressions/index.html)
and supports
[chained operations](https://mathjs.org/docs/core/chaining.html).
```js
import {
atan2, chain, derivative, e, evaluate, log, pi, pow, round, sqrt
} from 'mathjs'
// functions and constants
round(e, 3) // 2.718
atan2(3, -3) / pi // 0.75
log(10000, 10) // 4
sqrt(-4) // 2i
pow([[-1, 2], [3, 1]], 2) // [[7, 0], [0, 7]]
derivative('x^2 + x', 'x') // 2 * x + 1
// expressions
evaluate('12 / (2.3 + 0.7)') // 4
evaluate('12.7 cm to inch') // 5 inch
evaluate('sin(45 deg) ^ 2') // 0.5
evaluate('9 / 3 + 2i') // 3 + 2i
evaluate('det([-1, 2; 3, 1])') // -7
// chaining
chain(3)
.add(4)
.multiply(2)
.done() // 14
```
See the [Getting Started](https://mathjs.org/docs/getting_started.html) for a more detailed tutorial.
## Browser support
Math.js works on any [ES2020](https://262.ecma-international.org/11.0/) compatible JavaScript engine, including node.js, Chrome, Firefox, Safari, and Edge.
## Documentation
- [Getting Started](https://mathjs.org/docs/getting_started.html)
- [Examples](https://mathjs.org/examples/index.html)
- [Overview](https://mathjs.org/docs/index.html)
- [History](https://mathjs.org/history.html)
## Build
First clone the project from github:
git clone git@github.com:josdejong/mathjs.git
cd mathjs
Install the project dependencies:
npm install
Then, the project can be build by executing the build script via npm:
npm run build
This will build ESM output, CommonJS output, and the bundle math.js
from the source files and put them in the folder lib.
## Develop
When developing new features for mathjs, it is good to be aware of the following background information.
### Code
The code of `mathjs` is written in ES modules, and requires all files to have a real, relative path, meaning the files must have a `*.js` extension. Please configure adding file extensions on auto import in your IDE.
### Architecture
What mathjs tries to achieve is to offer an environment where you can do calculations with mixed data types,
like multiplying a regular `number` with a `Complex` number or a `BigNumber`, and work with all of those in matrices.
Mathjs also allows to add a new data type with little effort.
The solution that mathjs uses has two main ingredients:
- **Typed functions**. All functions are created using [`typed-function`](https://github.com/josdejong/typed-function/). This makes it easier to (dynamically) create and extend a single function with new data types, automatically do type conversions on function inputs, etc. So, if you create function multiply for two `number`s, you can extend it with support for multiplying your own data type, say `MyDecimal`. If you define a conversion from `MyDecimal` to `number`, the typed-function will automatically allow you to multiply a `MyDecimal` with a `number`.
- **Dependency injection**. When we have a function `multiply` with support for `MyDecimal`, thanks to the dependency injection, other functions using `multiply` under the hood, like `prod`, will automatically support `MyDecimal` too. This also works the other way around: if you don't need the heavyweight `multiply` (which supports BigNumbers, matrices, etc), and you just need a plain and simple number support, you can use a lightweight implementation of `multiply` just for numbers, and inject that in `prod` and other functions.
At the lowest level, mathjs has immutable factory functions which create immutable functions. The core function `math.create(...)` creates a new instance having functions created from all passed factory functions. A mathjs instance is a collection of created functions. It contains a function like `math.import` to allow extending the instance with new functions, which can then be used in the expression parser.
### Implementing a new function
A common case is to implement a new function. This involves the following steps:
- Implement the function in the right category, for example `./src/function/arithmetic/myNewFunction.js`, where you can replace `arithmetic` with the proper category, and `myNewFunction` with the name of the new function. Add the new function to the index files `./src/factoriesAny.js` and possibly `./src/factoriesNumber.js`.
- Write documentation on the function in the source code comment of `myNewFunction.js`. This documentation is used to auto generate documentation on the website.
- Write embedded documentation for the new function in `./src/expression/embeddedDocs/function/arithmetic/myNewFunction.js`. Add the new documentation to the index file `./src/expression/embeddedDocs/embeddedDocs.js`.
- Write unit tests for the function in `./test/unit-tests/function/arithmetic/myNewFunction.test.js`.
- Write the necessary TypeScript definitions for the new function in `./types/index.d.ts`, and write tests for it in `./test/typescript-tests/testTypes.ts`. This is described in [./types/EXPLANATION.md](./types/EXPLANATION.md).
- Ensure the code style is ok by running `npm run lint` (run `npm run format` to fix the code style automatically).
### Build scripts
The build script currently generates two types of output:
- **any**, generate entry points to create full versions of all functions
- **number**: generating and entry points to create lightweight functions just supporting `number`
For each function, an object is generated containing the factory functions of all dependencies of the function. This allows to just load a specific set of functions, and not load or bundle any other functionality. So for example, to just create function `add` you can do `math.create(addDependencies)`.
## Test
To execute tests for the library, install the project dependencies once:
npm install
Then, the tests can be executed:
npm test
To test the type definitions:
npm run test:types
Additionally, the tests can be run on FireFox using [headless mode](https://developer.mozilla.org/en-US/Firefox/Headless_mode):
npm run test:browser
To run the tests remotely on BrowserStack, first set the environment variables `BROWSER_STACK_USERNAME` and `BROWSER_STACK_ACCESS_KEY` with your username and access key and then execute:
npm run test:browserstack
You can separately run the code linter, though it is also executed with `npm test`:
npm run lint
To automatically fix linting issue, run:
npm run format
To test code coverage of the tests:
npm run coverage
To see the coverage results, open the generated report in your browser:
./coverage/lcov-report/index.html
### Continuous integration testing
Continuous integration tests are run on [Github Actions](https://github.com/josdejong/mathjs/actions) and [BrowserStack](https://www.browserstack.com) every time a commit is pushed to github. Github Actions runs the tests for different versions of node.js, and BrowserStack runs the tests on all major browsers.
[![BrowserStack](https://raw.github.com/josdejong/mathjs/master/misc/browserstack.png)](https://www.browserstack.com)
Thanks Github Actions and BrowserStack for the generous free hosting of this open source project!
## License
mathjs is published under the Apache 2.0 license:
```
Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
https://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```
mathjs contains a JavaScript port of the [CSparse](https://github.com/DrTimothyAldenDavis/SuiteSparse/tree/dev/CSparse/Source) library, published under the LGPL-2.1+ license:
```
CSparse: a Concise Sparse matrix package.
Copyright (c) 2006, Timothy A. Davis.
http://www.suitesparse.com
--------------------------------------------------------------------------------
CSparse is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
CSparse is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this Module; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
```

446
24_10_22_faktorialis/node_modules/mathjs/bin/cli.js generated vendored Normal file
View File

@@ -0,0 +1,446 @@
#!/usr/bin/env node
/**
* math.js
* https://github.com/josdejong/mathjs
*
* Math.js is an extensive math library for JavaScript and Node.js,
* It features real and complex numbers, units, matrices, a large set of
* mathematical functions, and a flexible expression parser.
*
* Usage:
*
* mathjs [scriptfile(s)] {OPTIONS}
*
* Options:
*
* --version, -v Show application version
* --help, -h Show this message
* --tex Generate LaTeX instead of evaluating
* --string Generate string instead of evaluating
* --parenthesis= Set the parenthesis option to
* either of "keep", "auto" and "all"
*
* Example usage:
* mathjs Open a command prompt
* mathjs 1+2 Evaluate expression
* mathjs script.txt Run a script file
* mathjs script1.txt script2.txt Run two script files
* mathjs script.txt > results.txt Run a script file, output to file
* cat script.txt | mathjs Run input stream
* cat script.txt | mathjs > results.txt Run input stream, output to file
*
* @license
* Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/
const fs = require('fs')
const path = require('path')
const { createEmptyMap } = require('../lib/cjs/utils/map.js')
let scope = createEmptyMap()
const PRECISION = 14 // decimals
/**
* "Lazy" load math.js: only require when we actually start using it.
* This ensures the cli application looks like it loads instantly.
* When requesting help or version number, math.js isn't even loaded.
* @return {{ evalute: function, parse: function, math: Object }}
*/
function getMath () {
const { create, all } = require('../lib/browser/math.js')
const math = create(all)
const parse = math.parse
const evaluate = math.evaluate
// See https://mathjs.org/docs/expressions/security.html#less-vulnerable-expression-parser
math.import({
'import': function () { throw new Error('Function import is disabled') },
'createUnit': function () { throw new Error('Function createUnit is disabled') },
'reviver': function () { throw new Error('Function reviver is disabled') }
}, { override: true })
return { math, parse, evaluate }
}
/**
* Helper function to format a value. Regular numbers will be rounded
* to 14 digits to prevent round-off errors from showing up.
* @param {*} value
*/
function format (value) {
const { math } = getMath()
return math.format(value, {
fn: function (value) {
if (typeof value === 'number') {
// round numbers
return math.format(value, PRECISION)
} else {
return math.format(value)
}
}
})
}
/**
* auto complete a text
* @param {String} text
* @return {[Array, String]} completions
*/
function completer (text) {
const { math } = getMath()
let matches = []
let keyword
const m = /[a-zA-Z_0-9]+$/.exec(text)
if (m) {
keyword = m[0]
// scope variables
for (const def in scope.keys()) {
if (def.indexOf(keyword) === 0) {
matches.push(def)
}
}
// commandline keywords
['exit', 'quit', 'clear'].forEach(function (cmd) {
if (cmd.indexOf(keyword) === 0) {
matches.push(cmd)
}
})
// math functions and constants
const ignore = ['expr', 'type']
for (const func in math.expression.mathWithTransform) {
if (hasOwnProperty(math.expression.mathWithTransform, func)) {
if (func.indexOf(keyword) === 0 && !ignore.includes(func)) {
matches.push(func)
}
}
}
// units
const Unit = math.Unit
for (const name in Unit.UNITS) {
if (hasOwnProperty(Unit.UNITS, name)) {
if (name.indexOf(keyword) === 0) {
matches.push(name)
}
}
}
for (const name in Unit.PREFIXES) {
if (hasOwnProperty(Unit.PREFIXES, name)) {
const prefixes = Unit.PREFIXES[name]
for (const prefix in prefixes) {
if (hasOwnProperty(prefixes, prefix)) {
if (prefix.indexOf(keyword) === 0) {
matches.push(prefix)
} else if (keyword.indexOf(prefix) === 0) {
const unitKeyword = keyword.substring(prefix.length)
for (const n in Unit.UNITS) {
if (hasOwnProperty(Unit.UNITS, n)) {
if (n.indexOf(unitKeyword) === 0 &&
Unit.isValuelessUnit(prefix + n)) {
matches.push(prefix + n)
}
}
}
}
}
}
}
}
// remove duplicates
matches = matches.filter(function (elem, pos, arr) {
return arr.indexOf(elem) === pos
})
}
return [matches, keyword]
}
/**
* Run stream, read and evaluate input and stream that to output.
* Text lines read from the input are evaluated, and the results are send to
* the output.
* @param input Input stream
* @param output Output stream
* @param mode Output mode
* @param parenthesis Parenthesis option
*/
function runStream (input, output, mode, parenthesis) {
const readline = require('readline')
const rl = readline.createInterface({
input: input || process.stdin,
output: output || process.stdout,
completer: completer
})
if (rl.output.isTTY) {
rl.setPrompt('> ')
rl.prompt()
}
// load math.js now, right *after* loading the prompt.
const { math, parse } = getMath()
// TODO: automatic insertion of 'ans' before operators like +, -, *, /
rl.on('line', function (line) {
const expr = line.trim()
switch (expr.toLowerCase()) {
case 'quit':
case 'exit':
// exit application
rl.close()
break
case 'clear':
// clear memory
scope = createEmptyMap()
console.log('memory cleared')
// get next input
if (rl.output.isTTY) {
rl.prompt()
}
break
default:
if (!expr) {
break
}
switch (mode) {
case 'evaluate':
// evaluate expression
try {
let node = parse(expr)
let res = node.evaluate(scope)
if (math.isResultSet(res)) {
// we can have 0 or 1 results in the ResultSet, as the CLI
// does not allow multiple expressions separated by a return
res = res.entries[0]
node = node.blocks
.filter(function (entry) { return entry.visible })
.map(function (entry) { return entry.node })[0]
}
if (node) {
if (math.isAssignmentNode(node)) {
const name = findSymbolName(node)
if (name !== null) {
const value = scope.get(name)
scope.set('ans', value)
console.log(name + ' = ' + format(value))
} else {
scope.set('ans', res)
console.log(format(res))
}
} else if (math.isHelp(res)) {
console.log(res.toString())
} else {
scope.set('ans', res)
console.log(format(res))
}
}
} catch (err) {
console.log(err.toString())
}
break
case 'string':
try {
const string = math.parse(expr).toString({ parenthesis: parenthesis })
console.log(string)
} catch (err) {
console.log(err.toString())
}
break
case 'tex':
try {
const tex = math.parse(expr).toTex({ parenthesis: parenthesis })
console.log(tex)
} catch (err) {
console.log(err.toString())
}
break
}
}
// get next input
if (rl.output.isTTY) {
rl.prompt()
}
})
rl.on('close', function () {
console.log()
process.exit(0)
})
}
/**
* Find the symbol name of an AssignmentNode. Recurses into the chain of
* objects to the root object.
* @param {AssignmentNode} node
* @return {string | null} Returns the name when found, else returns null.
*/
function findSymbolName (node) {
const { math } = getMath()
let n = node
while (n) {
if (math.isSymbolNode(n)) {
return n.name
}
n = n.object
}
return null
}
/**
* Output application version number.
* Version number is read version from package.json.
*/
function outputVersion () {
fs.readFile(path.join(__dirname, '/../package.json'), function (err, data) {
if (err) {
console.log(err.toString())
} else {
const pkg = JSON.parse(data)
const version = pkg && pkg.version ? pkg.version : 'unknown'
console.log(version)
}
process.exit(0)
})
}
/**
* Output a help message
*/
function outputHelp () {
console.log('math.js')
console.log('https://mathjs.org')
console.log()
console.log('Math.js is an extensive math library for JavaScript and Node.js. It features ')
console.log('real and complex numbers, units, matrices, a large set of mathematical')
console.log('functions, and a flexible expression parser.')
console.log()
console.log('Usage:')
console.log(' mathjs [scriptfile(s)|expression] {OPTIONS}')
console.log()
console.log('Options:')
console.log(' --version, -v Show application version')
console.log(' --help, -h Show this message')
console.log(' --tex Generate LaTeX instead of evaluating')
console.log(' --string Generate string instead of evaluating')
console.log(' --parenthesis= Set the parenthesis option to')
console.log(' either of "keep", "auto" and "all"')
console.log()
console.log('Example usage:')
console.log(' mathjs Open a command prompt')
console.log(' mathjs 1+2 Evaluate expression')
console.log(' mathjs script.txt Run a script file')
console.log(' mathjs script.txt script2.txt Run two script files')
console.log(' mathjs script.txt > results.txt Run a script file, output to file')
console.log(' cat script.txt | mathjs Run input stream')
console.log(' cat script.txt | mathjs > results.txt Run input stream, output to file')
console.log()
process.exit(0)
}
/**
* Process input and output, based on the command line arguments
*/
const scripts = [] // queue of scripts that need to be processed
let mode = 'evaluate' // one of 'evaluate', 'tex' or 'string'
let parenthesis = 'keep'
let version = false
let help = false
process.argv.forEach(function (arg, index) {
if (index < 2) {
return
}
switch (arg) {
case '-v':
case '--version':
version = true
break
case '-h':
case '--help':
help = true
break
case '--tex':
mode = 'tex'
break
case '--string':
mode = 'string'
break
case '--parenthesis=keep':
parenthesis = 'keep'
break
case '--parenthesis=auto':
parenthesis = 'auto'
break
case '--parenthesis=all':
parenthesis = 'all'
break
// TODO: implement configuration via command line arguments
default:
scripts.push(arg)
}
})
if (version) {
outputVersion()
} else if (help) {
outputHelp()
} else if (scripts.length === 0) {
// run a stream, can be user input or pipe input
runStream(process.stdin, process.stdout, mode, parenthesis)
} else {
fs.stat(scripts[0], function (err) {
if (err) {
const { evaluate } = getMath()
console.log(evaluate(scripts.join(' ')).toString())
} else {
// work through the queue of scripts
scripts.forEach(function (arg) {
// run a script file
runStream(fs.createReadStream(arg), process.stdout, mode, parenthesis)
})
}
})
}
// helper function to safely check whether an object as a property
// copy from the function in object.js which is ES6
function hasOwnProperty (object, property) {
return object && Object.hasOwnProperty.call(object, property)
}

3
24_10_22_faktorialis/node_modules/mathjs/bin/package.json generated vendored Normal file
View File

@@ -0,0 +1,3 @@
{
"type": "commonjs"
}

10
24_10_22_faktorialis/node_modules/mathjs/bin/repl.js generated vendored Normal file
View File

@@ -0,0 +1,10 @@
#!/usr/bin/env node
/*
* This simply preloads mathjs and drops you into a REPL to
* help interactive debugging.
**/
global.math = require('../lib/browser/math.js')
const repl = require('repl')
repl.start({ useGlobal: true })

3
24_10_22_faktorialis/node_modules/mathjs/lib/browser/math.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

49
24_10_22_faktorialis/node_modules/mathjs/lib/browser/math.js.LICENSE.txt generated vendored Normal file
View File

@@ -0,0 +1,49 @@
/*!
* decimal.js v10.4.3
* An arbitrary-precision Decimal type for JavaScript.
* https://github.com/MikeMcl/decimal.js
* Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
* MIT Licence
*/
/**
* @license Complex.js v2.1.1 12/05/2020
*
* Copyright (c) 2020, Robert Eisele (robert@xarg.org)
* Dual licensed under the MIT or GPL Version 2 licenses.
**/
/**
* @license Fraction.js v4.3.7 31/08/2023
* https://www.xarg.org/2014/03/rational-numbers-in-javascript/
*
* Copyright (c) 2023, Robert Eisele (robert@raw.org)
* Dual licensed under the MIT or GPL Version 2 licenses.
**/
/**
* math.js
* https://github.com/josdejong/mathjs
*
* Math.js is an extensive math library for JavaScript and Node.js,
* It features real and complex numbers, units, matrices, a large set of
* mathematical functions, and a flexible expression parser.
*
* @version 13.2.0
* @date 2024-10-02
*
* @license
* Copyright (C) 2013-2024 Jos de Jong <wjosdejong@gmail.com>
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy
* of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations under
* the License.
*/

1
24_10_22_faktorialis/node_modules/mathjs/lib/browser/math.js.map generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

3
24_10_22_faktorialis/node_modules/mathjs/lib/browser/package.json generated vendored Normal file
View File

@@ -0,0 +1,3 @@
{
"type": "commonjs"
}

130
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/constants.js generated vendored Normal file
View File

@@ -0,0 +1,130 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createVersion = exports.createUppercasePi = exports.createUppercaseE = exports.createTrue = exports.createTau = exports.createSQRT2 = exports.createSQRT1_2 = exports.createPi = exports.createPhi = exports.createNull = exports.createNaN = exports.createLOG2E = exports.createLOG10E = exports.createLN2 = exports.createLN10 = exports.createInfinity = exports.createI = exports.createFalse = exports.createE = void 0;
var _factory = require("./utils/factory.js");
var _version = require("./version.js");
var _constants = require("./utils/bignumber/constants.js");
var _index = require("./plain/number/index.js");
const createTrue = exports.createTrue = /* #__PURE__ */(0, _factory.factory)('true', [], () => true);
const createFalse = exports.createFalse = /* #__PURE__ */(0, _factory.factory)('false', [], () => false);
const createNull = exports.createNull = /* #__PURE__ */(0, _factory.factory)('null', [], () => null);
const createInfinity = exports.createInfinity = /* #__PURE__ */recreateFactory('Infinity', ['config', '?BigNumber'], _ref => {
let {
config,
BigNumber
} = _ref;
return config.number === 'BigNumber' ? new BigNumber(Infinity) : Infinity;
});
const createNaN = exports.createNaN = /* #__PURE__ */recreateFactory('NaN', ['config', '?BigNumber'], _ref2 => {
let {
config,
BigNumber
} = _ref2;
return config.number === 'BigNumber' ? new BigNumber(NaN) : NaN;
});
const createPi = exports.createPi = /* #__PURE__ */recreateFactory('pi', ['config', '?BigNumber'], _ref3 => {
let {
config,
BigNumber
} = _ref3;
return config.number === 'BigNumber' ? (0, _constants.createBigNumberPi)(BigNumber) : _index.pi;
});
const createTau = exports.createTau = /* #__PURE__ */recreateFactory('tau', ['config', '?BigNumber'], _ref4 => {
let {
config,
BigNumber
} = _ref4;
return config.number === 'BigNumber' ? (0, _constants.createBigNumberTau)(BigNumber) : _index.tau;
});
const createE = exports.createE = /* #__PURE__ */recreateFactory('e', ['config', '?BigNumber'], _ref5 => {
let {
config,
BigNumber
} = _ref5;
return config.number === 'BigNumber' ? (0, _constants.createBigNumberE)(BigNumber) : _index.e;
});
// golden ratio, (1+sqrt(5))/2
const createPhi = exports.createPhi = /* #__PURE__ */recreateFactory('phi', ['config', '?BigNumber'], _ref6 => {
let {
config,
BigNumber
} = _ref6;
return config.number === 'BigNumber' ? (0, _constants.createBigNumberPhi)(BigNumber) : _index.phi;
});
const createLN2 = exports.createLN2 = /* #__PURE__ */recreateFactory('LN2', ['config', '?BigNumber'], _ref7 => {
let {
config,
BigNumber
} = _ref7;
return config.number === 'BigNumber' ? new BigNumber(2).ln() : Math.LN2;
});
const createLN10 = exports.createLN10 = /* #__PURE__ */recreateFactory('LN10', ['config', '?BigNumber'], _ref8 => {
let {
config,
BigNumber
} = _ref8;
return config.number === 'BigNumber' ? new BigNumber(10).ln() : Math.LN10;
});
const createLOG2E = exports.createLOG2E = /* #__PURE__ */recreateFactory('LOG2E', ['config', '?BigNumber'], _ref9 => {
let {
config,
BigNumber
} = _ref9;
return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(2).ln()) : Math.LOG2E;
});
const createLOG10E = exports.createLOG10E = /* #__PURE__ */recreateFactory('LOG10E', ['config', '?BigNumber'], _ref10 => {
let {
config,
BigNumber
} = _ref10;
return config.number === 'BigNumber' ? new BigNumber(1).div(new BigNumber(10).ln()) : Math.LOG10E;
});
const createSQRT1_2 = exports.createSQRT1_2 = /* #__PURE__ */recreateFactory(
// eslint-disable-line camelcase
'SQRT1_2', ['config', '?BigNumber'], _ref11 => {
let {
config,
BigNumber
} = _ref11;
return config.number === 'BigNumber' ? new BigNumber('0.5').sqrt() : Math.SQRT1_2;
});
const createSQRT2 = exports.createSQRT2 = /* #__PURE__ */recreateFactory('SQRT2', ['config', '?BigNumber'], _ref12 => {
let {
config,
BigNumber
} = _ref12;
return config.number === 'BigNumber' ? new BigNumber(2).sqrt() : Math.SQRT2;
});
const createI = exports.createI = /* #__PURE__ */recreateFactory('i', ['Complex'], _ref13 => {
let {
Complex
} = _ref13;
return Complex.I;
});
// for backward compatibility with v5
const createUppercasePi = exports.createUppercasePi = /* #__PURE__ */(0, _factory.factory)('PI', ['pi'], _ref14 => {
let {
pi
} = _ref14;
return pi;
});
const createUppercaseE = exports.createUppercaseE = /* #__PURE__ */(0, _factory.factory)('E', ['e'], _ref15 => {
let {
e
} = _ref15;
return e;
});
const createVersion = exports.createVersion = /* #__PURE__ */(0, _factory.factory)('version', [], () => _version.version);
// helper function to create a factory with a flag recreateOnConfigChange
// idea: allow passing optional properties to be attached to the factory function as 4th argument?
function recreateFactory(name, dependencies, create) {
return (0, _factory.factory)(name, dependencies, create, {
recreateOnConfigChange: true
});
}

31
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/core/config.js generated vendored Normal file
View File

@@ -0,0 +1,31 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.DEFAULT_CONFIG = void 0;
const DEFAULT_CONFIG = exports.DEFAULT_CONFIG = {
// minimum relative difference between two compared values,
// used by all comparison functions
relTol: 1e-12,
// minimum absolute difference between two compared values,
// used by all comparison functions
absTol: 1e-15,
// type of default matrix output. Choose 'matrix' (default) or 'array'
matrix: 'Matrix',
// type of default number output. Choose 'number' (default) 'BigNumber', 'bigint', or 'Fraction'
number: 'number',
// type of fallback used for config { number: 'bigint' } when a value cannot be represented
// in the configured numeric type. Choose 'number' (default) or 'BigNumber'.
numberFallback: 'number',
// number of significant digits in BigNumbers
precision: 64,
// predictable output type of functions. When true, output type depends only
// on the input types. When false (default), output type can vary depending
// on input values. For example `math.sqrt(-4)` returns `complex('2i')` when
// predictable is false, and returns `NaN` when true.
predictable: false,
// random seed for seeded pseudo random number generation
// null = randomly seed
randomSeed: null
};

213
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/core/create.js generated vendored Normal file
View File

@@ -0,0 +1,213 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.create = create;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _typedFunction = _interopRequireDefault(require("typed-function"));
var _ArgumentsError = require("../error/ArgumentsError.js");
var _DimensionError = require("../error/DimensionError.js");
var _IndexError = require("../error/IndexError.js");
var _factory = require("../utils/factory.js");
var _is = require("../utils/is.js");
var _object = require("../utils/object.js");
var emitter = _interopRequireWildcard(require("./../utils/emitter.js"));
var _config = require("./config.js");
var _config2 = require("./function/config.js");
var _import = require("./function/import.js");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/**
* Create a mathjs instance from given factory functions and optionally config
*
* Usage:
*
* const mathjs1 = create({ createAdd, createMultiply, ...})
* const config = { number: 'BigNumber' }
* const mathjs2 = create(all, config)
*
* @param {Object} [factories] An object with factory functions
* The object can contain nested objects,
* all nested objects will be flattened.
* @param {Object} [config] Available options:
* {number} relTol
* Minimum relative difference between two
* compared values, used by all comparison functions.
* {number} absTol
* Minimum absolute difference between two
* compared values, used by all comparison functions.
* {string} matrix
* A string 'Matrix' (default) or 'Array'.
* {string} number
* A string 'number' (default), 'BigNumber', or 'Fraction'
* {number} precision
* The number of significant digits for BigNumbers.
* Not applicable for Numbers.
* {boolean} predictable
* Predictable output type of functions. When true,
* output type depends only on the input types. When
* false (default), output type can vary depending
* on input values. For example `math.sqrt(-4)`
* returns `complex('2i')` when predictable is false, and
* returns `NaN` when true.
* {string} randomSeed
* Random seed for seeded pseudo random number generator.
* Set to null to randomly seed.
* @returns {Object} Returns a bare-bone math.js instance containing
* functions:
* - `import` to add new functions
* - `config` to change configuration
* - `on`, `off`, `once`, `emit` for events
*/
function create(factories, config) {
const configInternal = (0, _extends2.default)({}, _config.DEFAULT_CONFIG, config);
// simple test for ES5 support
if (typeof Object.create !== 'function') {
throw new Error('ES5 not supported by this JavaScript engine. ' + 'Please load the es5-shim and es5-sham library for compatibility.');
}
// create the mathjs instance
const math = emitter.mixin({
// only here for backward compatibility for legacy factory functions
isNumber: _is.isNumber,
isComplex: _is.isComplex,
isBigNumber: _is.isBigNumber,
isBigInt: _is.isBigInt,
isFraction: _is.isFraction,
isUnit: _is.isUnit,
isString: _is.isString,
isArray: _is.isArray,
isMatrix: _is.isMatrix,
isCollection: _is.isCollection,
isDenseMatrix: _is.isDenseMatrix,
isSparseMatrix: _is.isSparseMatrix,
isRange: _is.isRange,
isIndex: _is.isIndex,
isBoolean: _is.isBoolean,
isResultSet: _is.isResultSet,
isHelp: _is.isHelp,
isFunction: _is.isFunction,
isDate: _is.isDate,
isRegExp: _is.isRegExp,
isObject: _is.isObject,
isMap: _is.isMap,
isPartitionedMap: _is.isPartitionedMap,
isObjectWrappingMap: _is.isObjectWrappingMap,
isNull: _is.isNull,
isUndefined: _is.isUndefined,
isAccessorNode: _is.isAccessorNode,
isArrayNode: _is.isArrayNode,
isAssignmentNode: _is.isAssignmentNode,
isBlockNode: _is.isBlockNode,
isConditionalNode: _is.isConditionalNode,
isConstantNode: _is.isConstantNode,
isFunctionAssignmentNode: _is.isFunctionAssignmentNode,
isFunctionNode: _is.isFunctionNode,
isIndexNode: _is.isIndexNode,
isNode: _is.isNode,
isObjectNode: _is.isObjectNode,
isOperatorNode: _is.isOperatorNode,
isParenthesisNode: _is.isParenthesisNode,
isRangeNode: _is.isRangeNode,
isRelationalNode: _is.isRelationalNode,
isSymbolNode: _is.isSymbolNode,
isChain: _is.isChain
});
// load config function and apply provided config
math.config = (0, _config2.configFactory)(configInternal, math.emit);
math.expression = {
transform: {},
mathWithTransform: {
config: math.config
}
};
// cached factories and instances used by function load
const legacyFactories = [];
const legacyInstances = [];
/**
* Load a function or data type from a factory.
* If the function or data type already exists, the existing instance is
* returned.
* @param {Function} factory
* @returns {*}
*/
function load(factory) {
if ((0, _factory.isFactory)(factory)) {
return factory(math);
}
const firstProperty = factory[Object.keys(factory)[0]];
if ((0, _factory.isFactory)(firstProperty)) {
return firstProperty(math);
}
if (!(0, _object.isLegacyFactory)(factory)) {
console.warn('Factory object with properties `type`, `name`, and `factory` expected', factory);
throw new Error('Factory object with properties `type`, `name`, and `factory` expected');
}
const index = legacyFactories.indexOf(factory);
let instance;
if (index === -1) {
// doesn't yet exist
if (factory.math === true) {
// pass with math namespace
instance = factory.factory(math.type, configInternal, load, math.typed, math);
} else {
instance = factory.factory(math.type, configInternal, load, math.typed);
}
// append to the cache
legacyFactories.push(factory);
legacyInstances.push(instance);
} else {
// already existing function, return the cached instance
instance = legacyInstances[index];
}
return instance;
}
const importedFactories = {};
// load the import function
function lazyTyped() {
for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
args[_key] = arguments[_key];
}
return math.typed.apply(math.typed, args);
}
lazyTyped.isTypedFunction = _typedFunction.default.isTypedFunction;
const internalImport = (0, _import.importFactory)(lazyTyped, load, math, importedFactories);
math.import = internalImport;
// listen for changes in config, import all functions again when changed
// TODO: move this listener into the import function?
math.on('config', () => {
Object.values(importedFactories).forEach(factory => {
if (factory && factory.meta && factory.meta.recreateOnConfigChange) {
// FIXME: only re-create when the current instance is the same as was initially created
// FIXME: delete the functions/constants before importing them again?
internalImport(factory, {
override: true
});
}
});
});
// the create function exposed on the mathjs instance is bound to
// the factory functions passed before
math.create = create.bind(null, factories);
// export factory function
math.factory = _factory.factory;
// import the factory functions like createAdd as an array instead of object,
// else they will get a different naming (`createAdd` instead of `add`).
math.import(Object.values((0, _object.deepFlatten)(factories)));
math.ArgumentsError = _ArgumentsError.ArgumentsError;
math.DimensionError = _DimensionError.DimensionError;
math.IndexError = _IndexError.IndexError;
return math;
}

115
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/core/function/config.js generated vendored Normal file
View File

@@ -0,0 +1,115 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.NUMBER_OPTIONS = exports.MATRIX_OPTIONS = void 0;
exports.configFactory = configFactory;
var _object = require("../../utils/object.js");
var _config2 = require("../config.js");
const MATRIX_OPTIONS = exports.MATRIX_OPTIONS = ['Matrix', 'Array']; // valid values for option matrix
const NUMBER_OPTIONS = exports.NUMBER_OPTIONS = ['number', 'BigNumber', 'Fraction']; // valid values for option number
function configFactory(config, emit) {
/**
* Set configuration options for math.js, and get current options.
* Will emit a 'config' event, with arguments (curr, prev, changes).
*
* This function is only available on a mathjs instance created using `create`.
*
* Syntax:
*
* math.config(config: Object): Object
*
* Examples:
*
*
* import { create, all } from 'mathjs'
*
* // create a mathjs instance
* const math = create(all)
*
* math.config().number // outputs 'number'
* math.evaluate('0.4') // outputs number 0.4
* math.config({number: 'Fraction'})
* math.evaluate('0.4') // outputs Fraction 2/5
*
* @param {Object} [options] Available options:
* {number} relTol
* Minimum relative difference between two
* compared values, used by all comparison functions.
* {number} absTol
* Minimum absolute difference between two
* compared values, used by all comparison functions.
* {string} matrix
* A string 'Matrix' (default) or 'Array'.
* {string} number
* A string 'number' (default), 'BigNumber', 'bigint', or 'Fraction'
* {number} precision
* The number of significant digits for BigNumbers.
* Not applicable for Numbers.
* {string} parenthesis
* How to display parentheses in LaTeX and string
* output.
* {string} randomSeed
* Random seed for seeded pseudo random number generator.
* Set to null to randomly seed.
* @return {Object} Returns the current configuration
*/
function _config(options) {
if (options) {
if (options.epsilon !== undefined) {
// this if is only for backwards compatibility, it can be removed in the future.
console.warn('Warning: The configuration option "epsilon" is deprecated. Use "relTol" and "absTol" instead.');
const optionsFix = (0, _object.clone)(options);
optionsFix.relTol = options.epsilon;
optionsFix.absTol = options.epsilon * 1e-3;
delete optionsFix.epsilon;
return _config(optionsFix);
}
const prev = (0, _object.clone)(config);
// validate some of the options
validateOption(options, 'matrix', MATRIX_OPTIONS);
validateOption(options, 'number', NUMBER_OPTIONS);
// merge options
(0, _object.deepExtend)(config, options);
const curr = (0, _object.clone)(config);
const changes = (0, _object.clone)(options);
// emit 'config' event
emit('config', curr, prev, changes);
return curr;
} else {
return (0, _object.clone)(config);
}
}
// attach the valid options to the function so they can be extended
_config.MATRIX_OPTIONS = MATRIX_OPTIONS;
_config.NUMBER_OPTIONS = NUMBER_OPTIONS;
// attach the config properties as readonly properties to the config function
Object.keys(_config2.DEFAULT_CONFIG).forEach(key => {
Object.defineProperty(_config, key, {
get: () => config[key],
enumerable: true,
configurable: true
});
});
return _config;
}
/**
* Validate an option
* @param {Object} options Object with options
* @param {string} name Name of the option to validate
* @param {Array.<string>} values Array with valid values for this option
*/
function validateOption(options, name, values) {
if (options[name] !== undefined && !values.includes(options[name])) {
// unknown value
console.warn('Warning: Unknown value "' + options[name] + '" for configuration option "' + name + '". ' + 'Available options: ' + values.map(value => JSON.stringify(value)).join(', ') + '.');
}
}

331
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/core/function/import.js generated vendored Normal file
View File

@@ -0,0 +1,331 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.importFactory = importFactory;
var _is = require("../../utils/is.js");
var _factory = require("../../utils/factory.js");
var _object = require("../../utils/object.js");
var _ArgumentsError = require("../../error/ArgumentsError.js");
function importFactory(typed, load, math, importedFactories) {
/**
* Import functions from an object or a module.
*
* This function is only available on a mathjs instance created using `create`.
*
* Syntax:
*
* math.import(functions)
* math.import(functions, options)
*
* Where:
*
* - `functions: Object`
* An object with functions or factories to be imported.
* - `options: Object` An object with import options. Available options:
* - `override: boolean`
* If true, existing functions will be overwritten. False by default.
* - `silent: boolean`
* If true, the function will not throw errors on duplicates or invalid
* types. False by default.
* - `wrap: boolean`
* If true, the functions will be wrapped in a wrapper function
* which converts data types like Matrix to primitive data types like Array.
* The wrapper is needed when extending math.js with libraries which do not
* support these data type. False by default.
*
* Examples:
*
* import { create, all } from 'mathjs'
* import * as numbers from 'numbers'
*
* // create a mathjs instance
* const math = create(all)
*
* // define new functions and variables
* math.import({
* myvalue: 42,
* hello: function (name) {
* return 'hello, ' + name + '!'
* }
* })
*
* // use the imported function and variable
* math.myvalue * 2 // 84
* math.hello('user') // 'hello, user!'
*
* // import the npm module 'numbers'
* // (must be installed first with `npm install numbers`)
* math.import(numbers, {wrap: true})
*
* math.fibonacci(7) // returns 13
*
* @param {Object | Array} functions Object with functions to be imported.
* @param {Object} [options] Import options.
*/
function mathImport(functions, options) {
const num = arguments.length;
if (num !== 1 && num !== 2) {
throw new _ArgumentsError.ArgumentsError('import', num, 1, 2);
}
if (!options) {
options = {};
}
function flattenImports(flatValues, value, name) {
if (Array.isArray(value)) {
value.forEach(item => flattenImports(flatValues, item));
} else if (typeof value === 'object') {
for (const name in value) {
if ((0, _object.hasOwnProperty)(value, name)) {
flattenImports(flatValues, value[name], name);
}
}
} else if ((0, _factory.isFactory)(value) || name !== undefined) {
const flatName = (0, _factory.isFactory)(value) ? isTransformFunctionFactory(value) ? value.fn + '.transform' // TODO: this is ugly
: value.fn : name;
// we allow importing the same function twice if it points to the same implementation
if ((0, _object.hasOwnProperty)(flatValues, flatName) && flatValues[flatName] !== value && !options.silent) {
throw new Error('Cannot import "' + flatName + '" twice');
}
flatValues[flatName] = value;
} else {
if (!options.silent) {
throw new TypeError('Factory, Object, or Array expected');
}
}
}
const flatValues = {};
flattenImports(flatValues, functions);
for (const name in flatValues) {
if ((0, _object.hasOwnProperty)(flatValues, name)) {
// console.log('import', name)
const value = flatValues[name];
if ((0, _factory.isFactory)(value)) {
// we ignore name here and enforce the name of the factory
// maybe at some point we do want to allow overriding it
// in that case we can implement an option overrideFactoryNames: true
_importFactory(value, options);
} else if (isSupportedType(value)) {
_import(name, value, options);
} else {
if (!options.silent) {
throw new TypeError('Factory, Object, or Array expected');
}
}
}
}
}
/**
* Add a property to the math namespace
* @param {string} name
* @param {*} value
* @param {Object} options See import for a description of the options
* @private
*/
function _import(name, value, options) {
// TODO: refactor this function, it's to complicated and contains duplicate code
if (options.wrap && typeof value === 'function') {
// create a wrapper around the function
value = _wrap(value);
}
// turn a plain function with a typed-function signature into a typed-function
if (hasTypedFunctionSignature(value)) {
value = typed(name, {
[value.signature]: value
});
}
if (typed.isTypedFunction(math[name]) && typed.isTypedFunction(value)) {
if (options.override) {
// give the typed function the right name
value = typed(name, value.signatures);
} else {
// merge the existing and typed function
value = typed(math[name], value);
}
math[name] = value;
delete importedFactories[name];
_importTransform(name, value);
math.emit('import', name, function resolver() {
return value;
});
return;
}
if (math[name] === undefined || options.override) {
math[name] = value;
delete importedFactories[name];
_importTransform(name, value);
math.emit('import', name, function resolver() {
return value;
});
return;
}
if (!options.silent) {
throw new Error('Cannot import "' + name + '": already exists');
}
}
function _importTransform(name, value) {
if (value && typeof value.transform === 'function') {
math.expression.transform[name] = value.transform;
if (allowedInExpressions(name)) {
math.expression.mathWithTransform[name] = value.transform;
}
} else {
// remove existing transform
delete math.expression.transform[name];
if (allowedInExpressions(name)) {
math.expression.mathWithTransform[name] = value;
}
}
}
function _deleteTransform(name) {
delete math.expression.transform[name];
if (allowedInExpressions(name)) {
math.expression.mathWithTransform[name] = math[name];
} else {
delete math.expression.mathWithTransform[name];
}
}
/**
* Create a wrapper a round an function which converts the arguments
* to their primitive values (like convert a Matrix to Array)
* @param {Function} fn
* @return {Function} Returns the wrapped function
* @private
*/
function _wrap(fn) {
const wrapper = function wrapper() {
const args = [];
for (let i = 0, len = arguments.length; i < len; i++) {
const arg = arguments[i];
args[i] = arg && arg.valueOf();
}
return fn.apply(math, args);
};
if (fn.transform) {
wrapper.transform = fn.transform;
}
return wrapper;
}
/**
* Import an instance of a factory into math.js
* @param {function(scope: object)} factory
* @param {Object} options See import for a description of the options
* @param {string} [name=factory.name] Optional custom name
* @private
*/
function _importFactory(factory, options) {
let name = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : factory.fn;
if (name.includes('.')) {
throw new Error('Factory name should not contain a nested path. ' + 'Name: ' + JSON.stringify(name));
}
const namespace = isTransformFunctionFactory(factory) ? math.expression.transform : math;
const existingTransform = name in math.expression.transform;
const existing = (0, _object.hasOwnProperty)(namespace, name) ? namespace[name] : undefined;
const resolver = function () {
// collect all dependencies, handle finding both functions and classes and other special cases
const dependencies = {};
factory.dependencies.map(_factory.stripOptionalNotation).forEach(dependency => {
if (dependency.includes('.')) {
throw new Error('Factory dependency should not contain a nested path. ' + 'Name: ' + JSON.stringify(dependency));
}
if (dependency === 'math') {
dependencies.math = math;
} else if (dependency === 'mathWithTransform') {
dependencies.mathWithTransform = math.expression.mathWithTransform;
} else if (dependency === 'classes') {
// special case for json reviver
dependencies.classes = math;
} else {
dependencies[dependency] = math[dependency];
}
});
const instance = /* #__PURE__ */factory(dependencies);
if (instance && typeof instance.transform === 'function') {
throw new Error('Transforms cannot be attached to factory functions. ' + 'Please create a separate function for it with export const path = "expression.transform"');
}
if (existing === undefined || options.override) {
return instance;
}
if (typed.isTypedFunction(existing) && typed.isTypedFunction(instance)) {
// merge the existing and new typed function
return typed(existing, instance);
}
if (options.silent) {
// keep existing, ignore imported function
return existing;
} else {
throw new Error('Cannot import "' + name + '": already exists');
}
};
// TODO: add unit test with non-lazy factory
if (!factory.meta || factory.meta.lazy !== false) {
(0, _object.lazy)(namespace, name, resolver);
// FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
if (existing && existingTransform) {
_deleteTransform(name);
} else {
if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
(0, _object.lazy)(math.expression.mathWithTransform, name, () => namespace[name]);
}
}
} else {
namespace[name] = resolver();
// FIXME: remove the `if (existing &&` condition again. Can we make sure subset is loaded before subset.transform? (Name collision, and no dependencies between the two)
if (existing && existingTransform) {
_deleteTransform(name);
} else {
if (isTransformFunctionFactory(factory) || factoryAllowedInExpressions(factory)) {
(0, _object.lazy)(math.expression.mathWithTransform, name, () => namespace[name]);
}
}
}
// TODO: improve factories, store a list with imports instead which can be re-played
importedFactories[name] = factory;
math.emit('import', name, resolver);
}
/**
* Check whether given object is a type which can be imported
* @param {Function | number | string | boolean | null | Unit | Complex} object
* @return {boolean}
* @private
*/
function isSupportedType(object) {
return typeof object === 'function' || typeof object === 'number' || typeof object === 'string' || typeof object === 'boolean' || object === null || (0, _is.isUnit)(object) || (0, _is.isComplex)(object) || (0, _is.isBigNumber)(object) || (0, _is.isFraction)(object) || (0, _is.isMatrix)(object) || Array.isArray(object);
}
function hasTypedFunctionSignature(fn) {
return typeof fn === 'function' && typeof fn.signature === 'string';
}
function allowedInExpressions(name) {
return !(0, _object.hasOwnProperty)(unsafe, name);
}
function factoryAllowedInExpressions(factory) {
return !factory.fn.includes('.') &&
// FIXME: make checking on path redundant, check on meta data instead
!(0, _object.hasOwnProperty)(unsafe, factory.fn) && (!factory.meta || !factory.meta.isClass);
}
function isTransformFunctionFactory(factory) {
return factory !== undefined && factory.meta !== undefined && factory.meta.isTransformFunction === true || false;
}
// namespaces and functions not available in the parser for safety reasons
const unsafe = {
expression: true,
type: true,
docs: true,
error: true,
json: true,
chain: true // chain method not supported. Note that there is a unit chain too.
};
return mathImport;
}

461
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/core/function/typed.js generated vendored Normal file
View File

File diff suppressed because one or more lines are too long

11
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/defaultInstance.js generated vendored Normal file
View File

@@ -0,0 +1,11 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var all = _interopRequireWildcard(require("./factoriesAny.js"));
var _create = require("./core/create.js");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
var _default = exports.default = (0, _create.create)(all);

12
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/allFactoriesAny.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.all = void 0;
var allFactories = _interopRequireWildcard(require("../factoriesAny.js"));
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
// creating all factories here in a separate file is needed to get tree-shaking working
const all = exports.all = allFactories;

12
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/allFactoriesNumber.js generated vendored Normal file
View File

@@ -0,0 +1,12 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.all = void 0;
var allFactories = _interopRequireWildcard(require("../factoriesNumber.js"));
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
// creating all factories here in a separate file is needed to get tree-shaking working
const all = exports.all = allFactories;

22
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/configReadonly.js generated vendored Normal file
View File

@@ -0,0 +1,22 @@
"use strict";
var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.config = void 0;
var _extends2 = _interopRequireDefault(require("@babel/runtime/helpers/extends"));
var _config = require("../core/config.js");
var _config2 = require("../core/function/config.js");
// create a read-only version of config
const config = function (options) {
if (options) {
throw new Error('The global config is readonly. \n' + 'Please create a mathjs instance if you want to change the default configuration. \n' + 'Example:\n' + '\n' + ' import { create, all } from \'mathjs\';\n' + ' const mathjs = create(all);\n' + ' mathjs.config({ number: \'BigNumber\' });\n');
}
return Object.freeze(_config.DEFAULT_CONFIG);
};
exports.config = config;
(0, _extends2.default)(config, _config.DEFAULT_CONFIG, {
MATRIX_OPTIONS: _config2.MATRIX_OPTIONS,
NUMBER_OPTIONS: _config2.NUMBER_OPTIONS
});

2546
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny.generated.js generated vendored Normal file
View File

File diff suppressed because it is too large Load Diff

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAbs.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.absDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const absDependencies = exports.absDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAbs: _factoriesAny.createAbs
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAccessorNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AccessorNodeDependencies = void 0;
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _dependenciesSubsetGenerated = require("./dependenciesSubset.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const AccessorNodeDependencies = exports.AccessorNodeDependencies = {
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
subsetDependencies: _dependenciesSubsetGenerated.subsetDependencies,
createAccessorNode: _factoriesAny.createAccessorNode
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcos.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acosDependencies = void 0;
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acosDependencies = exports.acosDependencies = {
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcos: _factoriesAny.createAcos
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcosh.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acoshDependencies = void 0;
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acoshDependencies = exports.acoshDependencies = {
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcosh: _factoriesAny.createAcosh
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcot.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acotDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acotDependencies = exports.acotDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcot: _factoriesAny.createAcot
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcoth.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acothDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acothDependencies = exports.acothDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcoth: _factoriesAny.createAcoth
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcsc.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acscDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acscDependencies = exports.acscDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcsc: _factoriesAny.createAcsc
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAcsch.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.acschDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const acschDependencies = exports.acschDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAcsch: _factoriesAny.createAcsch
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAdd.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.addDependencies = void 0;
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesSparseMatrixClassGenerated = require("./dependenciesSparseMatrixClass.generated.js");
var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const addDependencies = exports.addDependencies = {
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
SparseMatrixDependencies: _dependenciesSparseMatrixClassGenerated.SparseMatrixDependencies,
addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAdd: _factoriesAny.createAdd
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAddScalar.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.addScalarDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const addScalarDependencies = exports.addScalarDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAddScalar: _factoriesAny.createAddScalar
};

27
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAnd.generated.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.andDependencies = void 0;
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const andDependencies = exports.andDependencies = {
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
notDependencies: _dependenciesNotGenerated.notDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
createAnd: _factoriesAny.createAnd
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAndTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.andTransformDependencies = void 0;
var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const andTransformDependencies = exports.andTransformDependencies = {
addDependencies: _dependenciesAddGenerated.addDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
notDependencies: _dependenciesNotGenerated.notDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
createAndTransform: _factoriesAny.createAndTransform
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesApply.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.applyDependencies = void 0;
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const applyDependencies = exports.applyDependencies = {
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createApply: _factoriesAny.createApply
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesApplyTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.applyTransformDependencies = void 0;
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const applyTransformDependencies = exports.applyTransformDependencies = {
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createApplyTransform: _factoriesAny.createApplyTransform
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesArg.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.argDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const argDependencies = exports.argDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createArg: _factoriesAny.createArg
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesArrayNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ArrayNodeDependencies = void 0;
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ArrayNodeDependencies = exports.ArrayNodeDependencies = {
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
createArrayNode: _factoriesAny.createArrayNode
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsec.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.asecDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const asecDependencies = exports.asecDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAsec: _factoriesAny.createAsec
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsech.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.asechDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const asechDependencies = exports.asechDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAsech: _factoriesAny.createAsech
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsin.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.asinDependencies = void 0;
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const asinDependencies = exports.asinDependencies = {
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAsin: _factoriesAny.createAsin
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAsinh.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.asinhDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const asinhDependencies = exports.asinhDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAsinh: _factoriesAny.createAsinh
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAssignmentNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.AssignmentNodeDependencies = void 0;
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _dependenciesSubsetGenerated = require("./dependenciesSubset.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const AssignmentNodeDependencies = exports.AssignmentNodeDependencies = {
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
subsetDependencies: _dependenciesSubsetGenerated.subsetDependencies,
createAssignmentNode: _factoriesAny.createAssignmentNode
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtan.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.atanDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const atanDependencies = exports.atanDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAtan: _factoriesAny.createAtan
};

27
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtan2.generated.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.atan2Dependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const atan2Dependencies = exports.atan2Dependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAtan2: _factoriesAny.createAtan2
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtanh.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.atanhDependencies = void 0;
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const atanhDependencies = exports.atanhDependencies = {
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createAtanh: _factoriesAny.createAtanh
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAtomicMass.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.atomicMassDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const atomicMassDependencies = exports.atomicMassDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createAtomicMass: _factoriesAny.createAtomicMass
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesAvogadro.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.avogadroDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const avogadroDependencies = exports.avogadroDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createAvogadro: _factoriesAny.createAvogadro
};

25
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBellNumbers.generated.js generated vendored Normal file
View File

@@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bellNumbersDependencies = void 0;
var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
var _dependenciesStirlingS2Generated = require("./dependenciesStirlingS2.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bellNumbersDependencies = exports.bellNumbersDependencies = {
addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
stirlingS2Dependencies: _dependenciesStirlingS2Generated.stirlingS2Dependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBellNumbers: _factoriesAny.createBellNumbers
};

15
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBigNumberClass.generated.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.BigNumberDependencies = void 0;
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const BigNumberDependencies = exports.BigNumberDependencies = {
createBigNumberClass: _factoriesAny.createBigNumberClass
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBigint.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bigintDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bigintDependencies = exports.bigintDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBigint: _factoriesAny.createBigint
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBignumber.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bignumberDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bignumberDependencies = exports.bignumberDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBignumber: _factoriesAny.createBignumber
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBin.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.binDependencies = void 0;
var _dependenciesFormatGenerated = require("./dependenciesFormat.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const binDependencies = exports.binDependencies = {
formatDependencies: _dependenciesFormatGenerated.formatDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBin: _factoriesAny.createBin
};

23
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitAnd.generated.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitAndDependencies = void 0;
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitAndDependencies = exports.bitAndDependencies = {
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBitAnd: _factoriesAny.createBitAnd
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitAndTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitAndTransformDependencies = void 0;
var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesNotGenerated = require("./dependenciesNot.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitAndTransformDependencies = exports.bitAndTransformDependencies = {
addDependencies: _dependenciesAddGenerated.addDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
notDependencies: _dependenciesNotGenerated.notDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
createBitAndTransform: _factoriesAny.createBitAndTransform
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitNot.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitNotDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitNotDependencies = exports.bitNotDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBitNot: _factoriesAny.createBitNot
};

25
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitOr.generated.js generated vendored Normal file
View File

@@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitOrDependencies = void 0;
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitOrDependencies = exports.bitOrDependencies = {
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBitOr: _factoriesAny.createBitOr
};

25
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitOrTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,25 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitOrTransformDependencies = void 0;
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitOrTransformDependencies = exports.bitOrTransformDependencies = {
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBitOrTransform: _factoriesAny.createBitOrTransform
};

23
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBitXor.generated.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bitXorDependencies = void 0;
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bitXorDependencies = exports.bitXorDependencies = {
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBitXor: _factoriesAny.createBitXor
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBlockNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.BlockNodeDependencies = void 0;
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _dependenciesResultSetGenerated = require("./dependenciesResultSet.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const BlockNodeDependencies = exports.BlockNodeDependencies = {
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
ResultSetDependencies: _dependenciesResultSetGenerated.ResultSetDependencies,
createBlockNode: _factoriesAny.createBlockNode
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBohrMagneton.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bohrMagnetonDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bohrMagnetonDependencies = exports.bohrMagnetonDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createBohrMagneton: _factoriesAny.createBohrMagneton
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBohrRadius.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.bohrRadiusDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const bohrRadiusDependencies = exports.bohrRadiusDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createBohrRadius: _factoriesAny.createBohrRadius
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBoltzmann.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.boltzmannDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const boltzmannDependencies = exports.boltzmannDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createBoltzmann: _factoriesAny.createBoltzmann
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesBoolean.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.booleanDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const booleanDependencies = exports.booleanDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createBoolean: _factoriesAny.createBoolean
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCatalan.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.catalanDependencies = void 0;
var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
var _dependenciesCombinationsGenerated = require("./dependenciesCombinations.generated.js");
var _dependenciesDivideScalarGenerated = require("./dependenciesDivideScalar.generated.js");
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
var _dependenciesMultiplyScalarGenerated = require("./dependenciesMultiplyScalar.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const catalanDependencies = exports.catalanDependencies = {
addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
combinationsDependencies: _dependenciesCombinationsGenerated.combinationsDependencies,
divideScalarDependencies: _dependenciesDivideScalarGenerated.divideScalarDependencies,
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
multiplyScalarDependencies: _dependenciesMultiplyScalarGenerated.multiplyScalarDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCatalan: _factoriesAny.createCatalan
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCbrt.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cbrtDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesFractionClassGenerated = require("./dependenciesFractionClass.generated.js");
var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _dependenciesUnaryMinusGenerated = require("./dependenciesUnaryMinus.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cbrtDependencies = exports.cbrtDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
FractionDependencies: _dependenciesFractionClassGenerated.FractionDependencies,
isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
unaryMinusDependencies: _dependenciesUnaryMinusGenerated.unaryMinusDependencies,
createCbrt: _factoriesAny.createCbrt
};

27
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCeil.generated.js generated vendored Normal file
View File

@@ -0,0 +1,27 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ceilDependencies = void 0;
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesRoundGenerated = require("./dependenciesRound.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _dependenciesZerosGenerated = require("./dependenciesZeros.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ceilDependencies = exports.ceilDependencies = {
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
roundDependencies: _dependenciesRoundGenerated.roundDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
zerosDependencies: _dependenciesZerosGenerated.zerosDependencies,
createCeil: _factoriesAny.createCeil
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesChain.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.chainDependencies = void 0;
var _dependenciesChainClassGenerated = require("./dependenciesChainClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const chainDependencies = exports.chainDependencies = {
ChainDependencies: _dependenciesChainClassGenerated.ChainDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createChain: _factoriesAny.createChain
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesChainClass.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ChainDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ChainDependencies = exports.ChainDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createChainClass: _factoriesAny.createChainClass
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesClassicalElectronRadius.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.classicalElectronRadiusDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const classicalElectronRadiusDependencies = exports.classicalElectronRadiusDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createClassicalElectronRadius: _factoriesAny.createClassicalElectronRadius
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesClone.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cloneDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cloneDependencies = exports.cloneDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createClone: _factoriesAny.createClone
};

23
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesColumn.generated.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.columnDependencies = void 0;
var _dependenciesIndexClassGenerated = require("./dependenciesIndexClass.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesRangeGenerated = require("./dependenciesRange.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const columnDependencies = exports.columnDependencies = {
IndexDependencies: _dependenciesIndexClassGenerated.IndexDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
rangeDependencies: _dependenciesRangeGenerated.rangeDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createColumn: _factoriesAny.createColumn
};

23
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesColumnTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.columnTransformDependencies = void 0;
var _dependenciesIndexClassGenerated = require("./dependenciesIndexClass.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesRangeGenerated = require("./dependenciesRange.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const columnTransformDependencies = exports.columnTransformDependencies = {
IndexDependencies: _dependenciesIndexClassGenerated.IndexDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
rangeDependencies: _dependenciesRangeGenerated.rangeDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createColumnTransform: _factoriesAny.createColumnTransform
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCombinations.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.combinationsDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const combinationsDependencies = exports.combinationsDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCombinations: _factoriesAny.createCombinations
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCombinationsWithRep.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.combinationsWithRepDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const combinationsWithRepDependencies = exports.combinationsWithRepDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCombinationsWithRep: _factoriesAny.createCombinationsWithRep
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompare.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.compareDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesDenseMatrixClassGenerated = require("./dependenciesDenseMatrixClass.generated.js");
var _dependenciesFractionClassGenerated = require("./dependenciesFractionClass.generated.js");
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesEqualScalarGenerated = require("./dependenciesEqualScalar.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const compareDependencies = exports.compareDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
DenseMatrixDependencies: _dependenciesDenseMatrixClassGenerated.DenseMatrixDependencies,
FractionDependencies: _dependenciesFractionClassGenerated.FractionDependencies,
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
equalScalarDependencies: _dependenciesEqualScalarGenerated.equalScalarDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCompare: _factoriesAny.createCompare
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompareNatural.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.compareNaturalDependencies = void 0;
var _dependenciesCompareGenerated = require("./dependenciesCompare.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const compareNaturalDependencies = exports.compareNaturalDependencies = {
compareDependencies: _dependenciesCompareGenerated.compareDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCompareNatural: _factoriesAny.createCompareNatural
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompareText.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.compareTextDependencies = void 0;
var _dependenciesConcatGenerated = require("./dependenciesConcat.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const compareTextDependencies = exports.compareTextDependencies = {
concatDependencies: _dependenciesConcatGenerated.concatDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCompareText: _factoriesAny.createCompareText
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCompile.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.compileDependencies = void 0;
var _dependenciesParseGenerated = require("./dependenciesParse.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const compileDependencies = exports.compileDependencies = {
parseDependencies: _dependenciesParseGenerated.parseDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCompile: _factoriesAny.createCompile
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComplex.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.complexDependencies = void 0;
var _dependenciesComplexClassGenerated = require("./dependenciesComplexClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const complexDependencies = exports.complexDependencies = {
ComplexDependencies: _dependenciesComplexClassGenerated.ComplexDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createComplex: _factoriesAny.createComplex
};

15
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComplexClass.generated.js generated vendored Normal file
View File

@@ -0,0 +1,15 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ComplexDependencies = void 0;
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ComplexDependencies = exports.ComplexDependencies = {
createComplexClass: _factoriesAny.createComplexClass
};

29
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesComposition.generated.js generated vendored Normal file
View File

@@ -0,0 +1,29 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.compositionDependencies = void 0;
var _dependenciesAddScalarGenerated = require("./dependenciesAddScalar.generated.js");
var _dependenciesCombinationsGenerated = require("./dependenciesCombinations.generated.js");
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesIsNegativeGenerated = require("./dependenciesIsNegative.generated.js");
var _dependenciesIsPositiveGenerated = require("./dependenciesIsPositive.generated.js");
var _dependenciesLargerGenerated = require("./dependenciesLarger.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const compositionDependencies = exports.compositionDependencies = {
addScalarDependencies: _dependenciesAddScalarGenerated.addScalarDependencies,
combinationsDependencies: _dependenciesCombinationsGenerated.combinationsDependencies,
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
isNegativeDependencies: _dependenciesIsNegativeGenerated.isNegativeDependencies,
isPositiveDependencies: _dependenciesIsPositiveGenerated.isPositiveDependencies,
largerDependencies: _dependenciesLargerGenerated.largerDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createComposition: _factoriesAny.createComposition
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConcat.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.concatDependencies = void 0;
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const concatDependencies = exports.concatDependencies = {
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createConcat: _factoriesAny.createConcat
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConcatTransform.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.concatTransformDependencies = void 0;
var _dependenciesIsIntegerGenerated = require("./dependenciesIsInteger.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const concatTransformDependencies = exports.concatTransformDependencies = {
isIntegerDependencies: _dependenciesIsIntegerGenerated.isIntegerDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createConcatTransform: _factoriesAny.createConcatTransform
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConditionalNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ConditionalNodeDependencies = void 0;
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ConditionalNodeDependencies = exports.ConditionalNodeDependencies = {
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
createConditionalNode: _factoriesAny.createConditionalNode
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConductanceQuantum.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.conductanceQuantumDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const conductanceQuantumDependencies = exports.conductanceQuantumDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createConductanceQuantum: _factoriesAny.createConductanceQuantum
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConj.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.conjDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const conjDependencies = exports.conjDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createConj: _factoriesAny.createConj
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesConstantNode.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.ConstantNodeDependencies = void 0;
var _dependenciesNodeGenerated = require("./dependenciesNode.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const ConstantNodeDependencies = exports.ConstantNodeDependencies = {
NodeDependencies: _dependenciesNodeGenerated.NodeDependencies,
createConstantNode: _factoriesAny.createConstantNode
};

35
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCorr.generated.js generated vendored Normal file
View File

@@ -0,0 +1,35 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.corrDependencies = void 0;
var _dependenciesAddGenerated = require("./dependenciesAdd.generated.js");
var _dependenciesDivideGenerated = require("./dependenciesDivide.generated.js");
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesMeanGenerated = require("./dependenciesMean.generated.js");
var _dependenciesMultiplyGenerated = require("./dependenciesMultiply.generated.js");
var _dependenciesPowGenerated = require("./dependenciesPow.generated.js");
var _dependenciesSqrtGenerated = require("./dependenciesSqrt.generated.js");
var _dependenciesSubtractGenerated = require("./dependenciesSubtract.generated.js");
var _dependenciesSumGenerated = require("./dependenciesSum.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const corrDependencies = exports.corrDependencies = {
addDependencies: _dependenciesAddGenerated.addDependencies,
divideDependencies: _dependenciesDivideGenerated.divideDependencies,
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
meanDependencies: _dependenciesMeanGenerated.meanDependencies,
multiplyDependencies: _dependenciesMultiplyGenerated.multiplyDependencies,
powDependencies: _dependenciesPowGenerated.powDependencies,
sqrtDependencies: _dependenciesSqrtGenerated.sqrtDependencies,
subtractDependencies: _dependenciesSubtractGenerated.subtractDependencies,
sumDependencies: _dependenciesSumGenerated.sumDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCorr: _factoriesAny.createCorr
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCos.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cosDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cosDependencies = exports.cosDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCos: _factoriesAny.createCos
};

17
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCosh.generated.js generated vendored Normal file
View File

@@ -0,0 +1,17 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.coshDependencies = void 0;
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const coshDependencies = exports.coshDependencies = {
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCosh: _factoriesAny.createCosh
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCot.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cotDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cotDependencies = exports.cotDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCot: _factoriesAny.createCot
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCoth.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cothDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cothDependencies = exports.cothDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCoth: _factoriesAny.createCoth
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCoulomb.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.coulombDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const coulombDependencies = exports.coulombDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
createCoulomb: _factoriesAny.createCoulomb
};

21
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCount.generated.js generated vendored Normal file
View File

@@ -0,0 +1,21 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.countDependencies = void 0;
var _dependenciesProdGenerated = require("./dependenciesProd.generated.js");
var _dependenciesSizeGenerated = require("./dependenciesSize.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const countDependencies = exports.countDependencies = {
prodDependencies: _dependenciesProdGenerated.prodDependencies,
sizeDependencies: _dependenciesSizeGenerated.sizeDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCount: _factoriesAny.createCount
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCreateUnit.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.createUnitDependencies = void 0;
var _dependenciesUnitClassGenerated = require("./dependenciesUnitClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const createUnitDependencies = exports.createUnitDependencies = {
UnitDependencies: _dependenciesUnitClassGenerated.UnitDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCreateUnit: _factoriesAny.createCreateUnit
};

23
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCross.generated.js generated vendored Normal file
View File

@@ -0,0 +1,23 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.crossDependencies = void 0;
var _dependenciesMatrixGenerated = require("./dependenciesMatrix.generated.js");
var _dependenciesMultiplyGenerated = require("./dependenciesMultiply.generated.js");
var _dependenciesSubtractGenerated = require("./dependenciesSubtract.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const crossDependencies = exports.crossDependencies = {
matrixDependencies: _dependenciesMatrixGenerated.matrixDependencies,
multiplyDependencies: _dependenciesMultiplyGenerated.multiplyDependencies,
subtractDependencies: _dependenciesSubtractGenerated.subtractDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCross: _factoriesAny.createCross
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCsc.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cscDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cscDependencies = exports.cscDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCsc: _factoriesAny.createCsc
};

19
24_10_22_faktorialis/node_modules/mathjs/lib/cjs/entry/dependenciesAny/dependenciesCsch.generated.js generated vendored Normal file
View File

@@ -0,0 +1,19 @@
"use strict";
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.cschDependencies = void 0;
var _dependenciesBigNumberClassGenerated = require("./dependenciesBigNumberClass.generated.js");
var _dependenciesTypedGenerated = require("./dependenciesTyped.generated.js");
var _factoriesAny = require("../../factoriesAny.js");
/**
* THIS FILE IS AUTO-GENERATED
* DON'T MAKE CHANGES HERE
*/
const cschDependencies = exports.cschDependencies = {
BigNumberDependencies: _dependenciesBigNumberClassGenerated.BigNumberDependencies,
typedDependencies: _dependenciesTypedGenerated.typedDependencies,
createCsch: _factoriesAny.createCsch
};

Some files were not shown because too many files have changed in this diff Show More