mathjs 10.4.1 → 10.4.2

package/examples/node_modules/@webpack-cli/serve/lib/index.js

@@ -1,83 +1,126 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const startDevServer_1 = __importDefault(require("./startDevServer"));
+const WEBPACK_PACKAGE = process.env.WEBPACK_PACKAGE || "webpack";
+const WEBPACK_DEV_SERVER_PACKAGE = process.env.WEBPACK_DEV_SERVER_PACKAGE || "webpack-dev-server";
 class ServeCommand {
+    // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
     async apply(cli) {
-        const { logger } = cli;
+        const loadDevServerOptions = () => {
+            // TODO simplify this after drop webpack v4 and webpack-dev-server v3
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const devServer = require(WEBPACK_DEV_SERVER_PACKAGE);
+            const isNewDevServerCLIAPI = typeof devServer.schema !== "undefined";
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let options = {};
+            if (isNewDevServerCLIAPI) {
+                if (cli.webpack.cli && typeof cli.webpack.cli.getArguments === "function") {
+                    options = cli.webpack.cli.getArguments(devServer.schema);
+                }
+                else {
+                    options = devServer.cli.getArguments();
+                }
+            }
+            else {
+                options = require(`${WEBPACK_DEV_SERVER_PACKAGE}/bin/cli-flags`);
+            }
+            // Old options format
+            // { devServer: [{...}, {}...] }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            if (options.devServer) {
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                return options.devServer;
+            }
+            // New options format
+            // { flag1: {}, flag2: {} }
+            return Object.keys(options).map((key) => {
+                options[key].name = key;
+                return options[key];
+            });
+        };
         await cli.makeCommand({
-            name: 'serve [entries...]',
-            alias: 's',
-            description: 'Run the webpack dev server.',
-            usage: '[entries...] [options]',
-            pkg: '@webpack-cli/serve',
-            dependencies: ['webpack-dev-server'],
-        }, () => {
+            name: "serve [entries...]",
+            alias: ["server", "s"],
+            description: "Run the webpack dev server.",
+            usage: "[entries...] [options]",
+            pkg: "@webpack-cli/serve",
+            dependencies: [WEBPACK_PACKAGE, WEBPACK_DEV_SERVER_PACKAGE],
+        }, async () => {
             let devServerFlags = [];
+            cli.webpack = await cli.loadWebpack();
             try {
-                // eslint-disable-next-line
-                devServerFlags = require('webpack-dev-server/bin/cli-flags').devServer;
+                devServerFlags = loadDevServerOptions();
             }
             catch (error) {
-                logger.error(`You need to install 'webpack-dev-server' for running 'webpack serve'.\n${error}`);
+                cli.logger.error(`You need to install 'webpack-dev-server' for running 'webpack serve'.\n${error}`);
                 process.exit(2);
             }
-            const builtInOptions = cli.getBuiltInOptions().filter((option) => option.name !== 'watch');
+            const builtInOptions = cli.getBuiltInOptions().filter(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (option) => option.name !== "watch");
             return [...builtInOptions, ...devServerFlags];
-        }, async (entries, options) => {
+        }, 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        async (entries, options) => {
             const builtInOptions = cli.getBuiltInOptions();
             let devServerFlags = [];
             try {
-                // eslint-disable-next-line
-                devServerFlags = require('webpack-dev-server/bin/cli-flags').devServer;
+                devServerFlags = loadDevServerOptions();
             }
             catch (error) {
                 // Nothing, to prevent future updates
             }
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const webpackOptions = {};
+            const webpackCLIOptions = {};
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const devServerOptions = {};
+            const devServerCLIOptions = {};
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const processors = [];
             for (const optionName in options) {
-                const kebabedOption = cli.utils.toKebabCase(optionName);
+                const kebabedOption = cli.toKebabCase(optionName);
                 // `webpack-dev-server` has own logic for the `--hot` option
-                const isBuiltInOption = kebabedOption !== 'hot' && builtInOptions.find((builtInOption) => builtInOption.name === kebabedOption);
+                const isBuiltInOption = kebabedOption !== "hot" &&
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    builtInOptions.find((builtInOption) => builtInOption.name === kebabedOption);
                 if (isBuiltInOption) {
-                    webpackOptions[optionName] = options[optionName];
+                    webpackCLIOptions[optionName] = options[optionName];
                 }
                 else {
-                    const needToProcess = devServerFlags.find((devServerOption) => devServerOption.name === kebabedOption && devServerOption.processor);
+                    const needToProcess = devServerFlags.find(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (devServerOption) => devServerOption.name === kebabedOption && devServerOption.processor);
                     if (needToProcess) {
                         processors.push(needToProcess.processor);
                     }
-                    devServerOptions[optionName] = options[optionName];
+                    devServerCLIOptions[optionName] = options[optionName];
                 }
             }
             for (const processor of processors) {
-                processor(devServerOptions);
+                processor(devServerCLIOptions);
             }
             if (entries.length > 0) {
-                webpackOptions.entry = [...entries, ...(webpackOptions.entry || [])];
+                webpackCLIOptions.entry = [...entries, ...(webpackCLIOptions.entry || [])];
             }
-            webpackOptions.argv = Object.assign(Object.assign({}, options), { env: Object.assign({ WEBPACK_SERVE: true }, options.env) });
-            const compiler = await cli.createCompiler(webpackOptions);
+            webpackCLIOptions.argv = Object.assign(Object.assign({}, options), { env: Object.assign({ WEBPACK_SERVE: true }, options.env) });
+            const compiler = await cli.createCompiler(webpackCLIOptions);
             if (!compiler) {
                 return;
             }
-            let servers;
-            if (cli.needWatchStdin(compiler) || devServerOptions.stdin) {
+            const servers = [];
+            if (cli.needWatchStdin(compiler) || devServerCLIOptions.stdin) {
                 // TODO remove in the next major release
                 // Compatibility with old `stdin` option for `webpack-dev-server`
                 // Should be removed for the next major release on both sides
-                if (devServerOptions.stdin) {
-                    delete devServerOptions.stdin;
+                if (devServerCLIOptions.stdin) {
+                    delete devServerCLIOptions.stdin;
                 }
-                process.stdin.on('end', () => {
+                process.stdin.on("end", () => {
                     Promise.all(servers.map((server) => {
+                        if (typeof server.stop === "function") {
+                            return server.stop();
+                        }
+                        // TODO remove in the next major release
                         return new Promise((resolve) => {
                             server.close(() => {
                                 resolve();
@@ -89,17 +132,147 @@ class ServeCommand {
                 });
                 process.stdin.resume();
             }
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const DevServer = require(WEBPACK_DEV_SERVER_PACKAGE);
+            const isNewDevServerCLIAPI = typeof DevServer.schema !== "undefined";
+            let devServerVersion;
             try {
-                servers = await startDevServer_1.default(compiler, devServerOptions, options, logger);
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                devServerVersion = require(`${WEBPACK_DEV_SERVER_PACKAGE}/package.json`).version;
             }
-            catch (error) {
-                if (cli.isValidationError(error)) {
-                    logger.error(error.message);
+            catch (err) {
+                cli.logger.error(`You need to install 'webpack-dev-server' for running 'webpack serve'.\n${err}`);
+                process.exit(2);
+            }
+            const compilers = typeof compiler.compilers !== "undefined" ? compiler.compilers : [compiler];
+            const possibleCompilers = compilers.filter((compiler) => compiler.options.devServer);
+            const compilersForDevServer = possibleCompilers.length > 0 ? possibleCompilers : [compilers[0]];
+            const isDevServer4 = devServerVersion.startsWith("4");
+            const usedPorts = [];
+            for (const compilerForDevServer of compilersForDevServer) {
+                let devServerOptions;
+                if (isNewDevServerCLIAPI) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const args = devServerFlags.reduce((accumulator, flag) => {
+                        accumulator[flag.name] = flag;
+                        return accumulator;
+                    }, {});
+                    const values = Object.keys(devServerCLIOptions).reduce(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    (accumulator, name) => {
+                        const kebabName = cli.toKebabCase(name);
+                        if (args[kebabName]) {
+                            accumulator[kebabName] = options[name];
+                        }
+                        return accumulator;
+                    }, {});
+                    const result = Object.assign({}, (compilerForDevServer.options.devServer || {}));
+                    const problems = (cli.webpack.cli && typeof cli.webpack.cli.processArguments === "function"
+                        ? cli.webpack.cli
+                        : DevServer.cli).processArguments(args, result, values);
+                    if (problems) {
+                        const groupBy = (xs, key) => {
+                            return xs.reduce((rv, x) => {
+                                (rv[x[key]] = rv[x[key]] || []).push(x);
+                                return rv;
+                            }, {});
+                        };
+                        const problemsByPath = groupBy(problems, "path");
+                        for (const path in problemsByPath) {
+                            const problems = problemsByPath[path];
+                            problems.forEach((problem) => {
+                                cli.logger.error(`${cli.capitalizeFirstLetter(problem.type.replace(/-/g, " "))}${problem.value ? ` '${problem.value}'` : ""} for the '--${problem.argument}' option${problem.index ? ` by index '${problem.index}'` : ""}`);
+                                if (problem.expected) {
+                                    cli.logger.error(`Expected: '${problem.expected}'`);
+                                }
+                            });
+                        }
+                        process.exit(2);
+                    }
+                    devServerOptions = result;
                 }
                 else {
-                    logger.error(error);
+                    // TODO remove in the next major release
+                    const mergeOptions = (devServerOptions, devServerCliOptions) => {
+                        // CLI options should take precedence over devServer options,
+                        // and CLI options should have no default values included
+                        const options = Object.assign(Object.assign({}, devServerOptions), devServerCliOptions);
+                        if (devServerOptions.client && devServerCliOptions.client) {
+                            // the user could set some client options in their devServer config,
+                            // then also specify client options on the CLI
+                            options.client = Object.assign(Object.assign({}, devServerOptions.client), devServerCliOptions.client);
+                        }
+                        return options;
+                    };
+                    devServerOptions = mergeOptions(compilerForDevServer.options.devServer || {}, devServerCLIOptions);
+                }
+                // TODO remove in the next major release
+                if (!isDevServer4) {
+                    const getPublicPathOption = () => {
+                        const normalizePublicPath = (publicPath) => typeof publicPath === "undefined" || publicPath === "auto" ? "/" : publicPath;
+                        if (options.outputPublicPath) {
+                            return normalizePublicPath(compilerForDevServer.options.output.publicPath);
+                        }
+                        if (devServerOptions.publicPath) {
+                            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                            // @ts-ignore
+                            return normalizePublicPath(devServerOptions.publicPath);
+                        }
+                        return normalizePublicPath(compilerForDevServer.options.output.publicPath);
+                    };
+                    const getStatsOption = () => {
+                        if (options.stats) {
+                            return options.stats;
+                        }
+                        if (devServerOptions.stats) {
+                            return devServerOptions.stats;
+                        }
+                        return compilerForDevServer.options.stats;
+                    };
+                    devServerOptions.host = devServerOptions.host || "localhost";
+                    devServerOptions.port =
+                        typeof devServerOptions.port !== "undefined" ? devServerOptions.port : 8080;
+                    devServerOptions.stats = getStatsOption();
+                    devServerOptions.publicPath = getPublicPathOption();
+                }
+                if (devServerOptions.port) {
+                    const portNumber = Number(devServerOptions.port);
+                    if (usedPorts.find((port) => portNumber === port)) {
+                        throw new Error("Unique ports must be specified for each devServer option in your webpack configuration. Alternatively, run only 1 devServer config using the --config-name flag to specify your desired config.");
+                    }
+                    usedPorts.push(portNumber);
+                }
+                try {
+                    let server;
+                    // TODO: remove after dropping webpack-dev-server@v3
+                    if (isDevServer4) {
+                        server = new DevServer(devServerOptions, compiler);
+                    }
+                    else {
+                        server = new DevServer(compiler, devServerOptions);
+                    }
+                    if (typeof server.start === "function") {
+                        await server.start();
+                    }
+                    else {
+                        // TODO remove in the next major release
+                        server.listen(devServerOptions.port, devServerOptions.host, (error) => {
+                            if (error) {
+                                throw error;
+                            }
+                        });
+                    }
+                    servers.push(server);
+                }
+                catch (error) {
+                    if (cli.isValidationError(error)) {
+                        cli.logger.error(error.message);
+                    }
+                    else {
+                        cli.logger.error(error);
+                    }
+                    process.exit(2);
                 }
-                process.exit(2);
             }
         });
     }

package/examples/node_modules/@webpack-cli/serve/lib/types.d.ts

@@ -1,43 +1,86 @@
 export declare type devServerOptionsType = {
-    bonjour?: boolean;
-    client?: devServerClientOptions;
+    allowedHosts?: string[] | allowedHostsEnum;
+    bonjour?: boolean | Record<string, any>;
+    client?: false | devServerClientOptions;
     compress?: boolean;
     dev?: Record<string, any>;
+    devMiddleware?: Record<string, any>;
     firewall?: boolean | string[];
-    headers?: object;
-    historyApiFallback?: boolean | object;
-    host?: string | null;
-    hot?: boolean | string;
+    headers?: Record<string, unknown> | ((request: any, response: any, middlewareContext: any) => Record<string, any>);
+    historyApiFallback?: boolean | Record<string, unknown>;
+    host?: string | null | hostEnum;
+    hot?: boolean | hotOptionEnum;
     http2?: boolean;
-    https?: boolean | object;
-    injectClient?: boolean | Function;
-    injectHot?: boolean | Function;
+    https?: boolean | Record<string, unknown>;
+    injectClient?: boolean | (() => void);
+    injectHot?: boolean | (() => void);
+    ipc?: string | true;
     liveReload?: boolean;
-    onAfterSetupMiddleware?: Function;
-    onBeforeSetupMiddleware?: Function;
-    onListening?: Function;
-    open?: string | boolean | object;
+    onAfterSetupMiddleware?: () => void;
+    onBeforeSetupMiddleware?: () => void;
+    onListening?: () => void;
+    open?: string | boolean | openOptionObject;
     openPage?: string | string[];
-    overlay?: boolean | object;
+    overlay?: boolean | Record<string, unknown>;
     port?: number | string | null;
     profile?: boolean;
     progress?: boolean;
-    proxy?: object | (object | Function)[];
+    proxy?: Record<string, unknown> | (Record<string, unknown> | (() => void))[];
     public?: string;
-    static?: boolean | string | object | (string | object)[];
-    transportMode?: object | string;
+    setupExitSignals?: boolean;
+    static?: boolean | string | Record<string, unknown> | (string | Record<string, unknown>)[];
+    transportMode?: Record<string, unknown> | string;
     useLocalIp?: boolean;
-    publicPath?: string | Function;
+    publicPath?: string | (() => void);
     stats?: string | boolean;
+    watchFiles?: string | Record<string, unknown>;
+    webSocketServer?: false | string | transportModeEnum | (() => any) | Record<string, unknown> | (Record<string, unknown> | (() => void))[];
 };
+declare enum hotOptionEnum {
+    only = "only"
+}
+declare enum hostEnum {
+    LocalIp = "local-ip",
+    LocalIpv4 = "local-ipv4",
+    LocalIpv6 = "local-ipv6"
+}
+declare enum allowedHostsEnum {
+    Auto = "auto",
+    All = "all"
+}
+declare enum transportModeEnum {
+    SockJS = "sockjs",
+    Ws = "ws"
+}
 declare type devServerClientOptions = {
     host?: string;
     path?: string;
     port?: string | number | null;
+    needClientEntry?: boolean | (() => void);
+    needHotEntry?: boolean | (() => void);
     logging?: devServerClientLogging;
+    overlay?: boolean | clientOverlay;
     progress?: boolean;
+    webSocketTransport?: string | transportModeEnum;
+    webSocketURL?: string | webSocketURLOptions;
+};
+declare type webSocketURLOptions = {
+    hostname?: string;
+    pathname?: string;
+    port?: string | number;
+    password?: string;
+    protocol?: string | "auto";
+    username?: string;
+};
+declare type openOptionObject = {
+    target?: string;
+    app?: string;
+};
+declare type clientOverlay = {
+    errors?: boolean;
+    warnings?: boolean;
 };
-export declare enum devServerClientLogging {
+declare enum devServerClientLogging {
     none = "none",
     error = "error",
     warn = "warn",

package/examples/node_modules/@webpack-cli/serve/lib/types.js

@@ -1,6 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.devServerClientLogging = void 0;
+var hotOptionEnum;
+(function (hotOptionEnum) {
+    hotOptionEnum["only"] = "only";
+})(hotOptionEnum || (hotOptionEnum = {}));
+var hostEnum;
+(function (hostEnum) {
+    hostEnum["LocalIp"] = "local-ip";
+    hostEnum["LocalIpv4"] = "local-ipv4";
+    hostEnum["LocalIpv6"] = "local-ipv6";
+})(hostEnum || (hostEnum = {}));
+var allowedHostsEnum;
+(function (allowedHostsEnum) {
+    allowedHostsEnum["Auto"] = "auto";
+    allowedHostsEnum["All"] = "all";
+})(allowedHostsEnum || (allowedHostsEnum = {}));
+var transportModeEnum;
+(function (transportModeEnum) {
+    transportModeEnum["SockJS"] = "sockjs";
+    transportModeEnum["Ws"] = "ws";
+})(transportModeEnum || (transportModeEnum = {}));
 var devServerClientLogging;
 (function (devServerClientLogging) {
     devServerClientLogging["none"] = "none";
@@ -9,4 +28,4 @@ var devServerClientLogging;
     devServerClientLogging["info"] = "info";
     devServerClientLogging["log"] = "log";
     devServerClientLogging["verbose"] = "verbose";
-})(devServerClientLogging = exports.devServerClientLogging || (exports.devServerClientLogging = {}));
+})(devServerClientLogging || (devServerClientLogging = {}));

package/examples/node_modules/@webpack-cli/serve/package.json

@@ -1,39 +1,22 @@
 {
-  "_from": "@webpack-cli/serve@^1.3.0",
-  "_id": "@webpack-cli/serve@1.3.0",
-  "_inBundle": false,
-  "_integrity": "sha512-k2p2VrONcYVX1wRRrf0f3X2VGltLWcv+JzXRBDmvCxGlCeESx4OXw91TsWeKOkp784uNoVQo313vxJFHXPPwfw==",
-  "_location": "/@webpack-cli/serve",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "range",
-    "registry": true,
-    "raw": "@webpack-cli/serve@^1.3.0",
-    "name": "@webpack-cli/serve",
-    "escapedName": "@webpack-cli%2fserve",
-    "scope": "@webpack-cli",
-    "rawSpec": "^1.3.0",
-    "saveSpec": null,
-    "fetchSpec": "^1.3.0"
+  "name": "@webpack-cli/serve",
+  "version": "1.6.1",
+  "description": "",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "keywords": [],
+  "publishConfig": {
+    "access": "public"
   },
-  "_requiredBy": [
-    "/webpack-cli"
-  ],
-  "_resolved": "https://registry.npmjs.org/@webpack-cli/serve/-/serve-1.3.0.tgz",
-  "_shasum": "2730c770f5f1f132767c63dcaaa4ec28f8c56a6c",
-  "_spec": "@webpack-cli/serve@^1.3.0",
-  "_where": "C:\\Users\\wjosd\\projects\\mathjs\\examples\\node_modules\\webpack-cli",
-  "bundleDependencies": false,
-  "deprecated": false,
-  "description": "[![NPM Downloads][downloads]][downloads-url]",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/webpack/webpack-cli.git"
+  },
+  "homepage": "https://github.com/webpack/webpack-cli/tree/master/packages/serve",
+  "license": "MIT",
   "files": [
     "lib"
   ],
-  "gitHead": "3bbda71e9637b7d20f3f49f9e080e27d8d8ae929",
-  "keywords": [],
-  "license": "MIT",
-  "main": "lib/index.js",
-  "name": "@webpack-cli/serve",
   "peerDependencies": {
     "webpack-cli": "4.x.x"
   },
@@ -42,9 +25,5 @@
       "optional": true
     }
   },
-  "publishConfig": {
-    "access": "public"
-  },
-  "types": "lib/index.d.ts",
-  "version": "1.3.0"
+  "gitHead": "fb50f766851f500ca12867a2aa9de81fa6e368f9"
 }

package/examples/node_modules/@xtuc/ieee754/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2008, Fair Oaks Labs, Inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+ * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

package/examples/node_modules/@xtuc/ieee754/README.md

@@ -0,0 +1,51 @@
+# ieee754 [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
+
+[travis-image]: https://img.shields.io/travis/feross/ieee754/master.svg
+[travis-url]: https://travis-ci.org/feross/ieee754
+[npm-image]: https://img.shields.io/npm/v/ieee754.svg
+[npm-url]: https://npmjs.org/package/ieee754
+[downloads-image]: https://img.shields.io/npm/dm/ieee754.svg
+[downloads-url]: https://npmjs.org/package/ieee754
+[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
+[standard-url]: https://standardjs.com
+
+[![saucelabs][saucelabs-image]][saucelabs-url]
+
+[saucelabs-image]: https://saucelabs.com/browser-matrix/ieee754.svg
+[saucelabs-url]: https://saucelabs.com/u/ieee754
+
+### Read/write IEEE754 floating point numbers from/to a Buffer or array-like object.
+
+## install
+
+```
+npm install ieee754
+```
+
+## methods
+
+`var ieee754 = require('ieee754')`
+
+The `ieee754` object has the following functions:
+
+```
+ieee754.read = function (buffer, offset, isLE, mLen, nBytes)
+ieee754.write = function (buffer, value, offset, isLE, mLen, nBytes)
+```
+
+The arguments mean the following:
+
+- buffer = the buffer
+- offset = offset into the buffer
+- value = value to set (only for `write`)
+- isLe = is little endian?
+- mLen = mantissa length
+- nBytes = number of bytes
+
+## what is ieee754?
+
+The IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point computation. [Read more](http://en.wikipedia.org/wiki/IEEE_floating_point).
+
+## license
+
+BSD 3 Clause. Copyright (c) 2008, Fair Oaks Labs, Inc.