@lumjs/encode 2.5.0 → 2.6.0

package/CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.6.0] - 2026-02-24
+
+
 ## [2.5.0] - 2026-02-20
 ### Added
 - A bunch of extra exports that are _module-sets_.
@@ -106,7 +109,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - Initial release.
 
-[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v2.5.0...HEAD
+[Unreleased]: https://github.com/supernovus/lum.encode.js/compare/v2.6.0...HEAD
+[2.6.0]: https://github.com/supernovus/lum.encode.js/compare/v2.5.0...v2.6.0
 [2.5.0]: https://github.com/supernovus/lum.encode.js/compare/v2.4.1...v2.5.0
 [2.4.1]: https://github.com/supernovus/lum.encode.js/compare/v2.4.0...v2.4.1
 [2.4.0]: https://github.com/supernovus/lum.encode.js/compare/v2.3.2...v2.4.0

package/jsdoc.js

@@ -0,0 +1,6 @@
+"use strict";
+
+const docRules = require('@lumjs/build/jsdoc-rules');
+const ourRules = docRules.rootReadme.clone(); 
+
+module.exports = ourRules;

package/lib/hash.js

@@ -55,7 +55,7 @@ const DATA_ENCODERS =
  * 
  * @exports module:@lumjs/encode/hash
  */
-module.exports = class
+module.exports = class Hashifier
 {
   /**
    * Build a new Hashifier

package/lum.build.js

@@ -0,0 +1,24 @@
+module.exports = function(rb)
+{
+  rb.project
+  .add('index')
+  .types('./types/auto')
+  .add('base32')
+  .add('base64')
+  .add('base91')
+  .add('hash')
+  .add('hmac')
+  .add('hotp')
+  .add('polyfill')
+  .add('signature')
+  .add('totp')
+  .add('util')
+  .src('./lib/sets')
+  .types('./types/sets')
+  .add('all')
+  .add('base')
+  .add('digest')
+  .add('otp')
+  .add('sign')
+  .save();
+}

package/package.json

@@ -1,45 +1,88 @@
 {
   "name": "@lumjs/encode",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "main": "lib/index.js",
-  "exports":
-  {
+  "exports": {
     ".": "./lib/index.js",
-    "./all": "./lib/sets/all.js",
-    "./base": "./lib/sets/base.js",
-    "./base32": "./lib/base32.js",
-    "./base64": "./lib/base64.js",
-    "./base91": "./lib/base91.js",
-    "./digest": "./lib/sets/digest.js",
-    "./hash": "./lib/hash.js",
-    "./hmac": "./lib/hmac.js",
-    "./hotp": "./lib/hotp.js",
-    "./otp": "./lib/sets/otp.js",
-    "./pem": "./lib/pem.js",
-    "./polyfill": "./lib/polyfill.js",
-    "./sign": "./lib/sets/sign.js",
-    "./signature": "./lib/signature.js",
-    "./totp": "./lib/totp.js",
-    "./util": "./lib/util.js",
+    "./base32": {
+      "types": "./types/auto/base32.d.ts",
+      "default": "./lib/base32.js"
+    },
+    "./base64": {
+      "types": "./types/auto/base64.d.ts",
+      "default": "./lib/base64.js"
+    },
+    "./base91": {
+      "types": "./types/auto/base91.d.ts",
+      "default": "./lib/base91.js"
+    },
+    "./hash": {
+      "types": "./types/auto/hash.d.ts",
+      "default": "./lib/hash.js"
+    },
+    "./hmac": {
+      "types": "./types/auto/hmac.d.ts",
+      "default": "./lib/hmac.js"
+    },
+    "./hotp": {
+      "types": "./types/auto/hotp.d.ts",
+      "default": "./lib/hotp.js"
+    },
+    "./polyfill": {
+      "types": "./types/auto/polyfill.d.ts",
+      "default": "./lib/polyfill.js"
+    },
+    "./signature": {
+      "types": "./types/auto/signature.d.ts",
+      "default": "./lib/signature.js"
+    },
+    "./totp": {
+      "types": "./types/auto/totp.d.ts",
+      "default": "./lib/totp.js"
+    },
+    "./util": {
+      "types": "./types/auto/util.d.ts",
+      "default": "./lib/util.js"
+    },
+    "./all": {
+      "types": "./types/sets/all.d.ts",
+      "default": "./lib/sets/all.js"
+    },
+    "./base": {
+      "types": "./types/sets/base.d.ts",
+      "default": "./lib/sets/base.js"
+    },
+    "./digest": {
+      "types": "./types/sets/digest.d.ts",
+      "default": "./lib/sets/digest.js"
+    },
+    "./otp": {
+      "types": "./types/sets/otp.d.ts",
+      "default": "./lib/sets/otp.js"
+    },
+    "./sign": {
+      "types": "./types/sets/sign.d.ts",
+      "default": "./lib/sets/sign.js"
+    },
     "./package.json": "./package.json"
   },
   "license": "MIT",
-  "repository":
-  {
+  "repository": {
     "type": "git",
     "url": "https://github.com/supernovus/lum.encode.js.git"
   },
-  "dependencies": 
-  {
+  "dependencies": {
     "@lumjs/core": "^1.28.0"
   },
-  "devDependencies":
-  {
+  "devDependencies": {
+    "@lumjs/build": "^1.2.0",
     "@lumjs/tests": "^2.0.0"
   },
-  "scripts":
-  {
-    "test": "node ./node_modules/@lumjs/tests/bin/lumtest.js",
-    "build-docs": "jsdoc -c ./jsdoc.json"
+  "scripts": {
+    "build": "npm run build-types && npm run build-meta && npm run build-docs",
+    "build-docs": "jsdoc -c ./jsdoc.js",
+    "build-meta": "lum-build",
+    "build-types": "npx -p typescript tsc",
+    "test": "node ./node_modules/@lumjs/tests/bin/lumtest.js"
   }
-}
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  // I would use ["lib/**/*"] except I have no idea how to get typescript
+  // to recognise 'sets' aliases, so I'm building those .d.ts files by hand.
+  "include": ["lib/*.js"],
+  "compilerOptions": {
+    "allowJs": true,
+    "declaration": true,
+    "emitDeclarationOnly": true,
+    "outDir": "types/auto",
+    "declarationMap": true
+  }
+}

package/types/auto/base32.d.ts

@@ -0,0 +1,72 @@
+export namespace Base32Types {
+    export default Base32Types.rfc4648;
+}
+/**
+ * Encode a value into a Base32 string.
+ *
+ * @param {(ArrayBuffer|TypedArray|string)} data - Data to be encoded.
+ *
+ * If this is a string it will be converted into a Uint8Array using a
+ * TextEncoder instance.
+ *
+ * @param {(object|string|boolean)} [opts] Options.
+ *
+ * If this is a boolean it will be used as `opts.pad`.
+ *
+ * If this is a string or one of the `Base32Types` properties,
+ * it will be used as `opts.type`.
+ *
+ * @param {(string|Array)} [opts.type] Base32 variant to use.
+ *
+ * If this is a string it must be the name (uppercase or lowercase)
+ * of one of the properties in the `Base32Types` object.
+ *
+ * If it is an Array it is expected that it is one of the properties
+ * from the Base32Types, or a compatible type def where the first
+ * item in the array is a string consisting of exactly 32 unique characters.
+ *
+ * @param {boolean} [opts.pad=true] Add `=` padding characters?
+ *
+ * Base32 (like Base64) uses `=` as a padding character to ensure the length
+ * of the encoded strings are divisible by 8. As that is a part of
+ * the standard specification, this option defaults to true.
+ *
+ * If you explicitly set this to false the string won't have any padding
+ * added to it, regardless of its length.
+ *
+ * @returns {string}
+ * @alias module:@lumjs/encode/base32.encode
+ */
+export function base32Encode(buf: any, opts?: (object | string | boolean)): string;
+/**
+ * Decode a Base32-encoded string.
+ * @param {string} str - Base32 string.
+ * @param {(object|string)} [opts] Options.
+ *
+ * If this is a boolean it will be used as `opts.string`.
+ *
+ * If this is a string or one of the `Base32Types` properties,
+ * it will be used as `opts.type`.
+ *
+ * @param {(string|Array)} [opts.type] Base32 variant to use.
+ *
+ * If this is a string it must be the name (uppercase or lowercase)
+ * of one of the properties in the `Base32Types` object.
+ *
+ * If it is an Array it is expected that it is one of the properties
+ * from the Base32Types, or a compatible type def where the first
+ * item in the array is a string consisting of exactly 32 unique characters.
+ *
+ * @param {boolean} [opts.string=false] Return a UTF-8 string?
+ *
+ * If this is true then we will assume the original encoded value was a UTF-8
+ * string, and will decode it as such using a TextDecoder instance.
+ *
+ * If this is false (the default) we will return a Uint8Array.
+ *
+ * @returns {(Uint8Array|string)}
+ * @alias module:@lumjs/encode/base32.decode
+ */
+export function base32Decode(str: string, opts?: (object | string)): (Uint8Array | string);
+export { Base32Types as TYPES, base32Encode as encode, base32Decode as decode };
+//# sourceMappingURL=base32.d.ts.map

package/types/auto/base32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base32.d.ts","sourceRoot":"","sources":["../../lib/base32.js"],"names":[],"mappings":";;;AA0JA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,8CA5BW,CAAC,MAAM,GAAC,MAAM,GAAC,OAAO,CAAC,GAyBrB,MAAM,CAiClB;AAvHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,kCA3BW,MAAM,SACN,CAAC,MAAM,GAAC,MAAM,CAAC,GAuBb,CAAC,UAAU,GAAC,MAAM,CAAC,CAyB/B"}

package/types/auto/base64.d.ts

@@ -0,0 +1,258 @@
+/**
+ * Base64 functions.
+ *
+ * Several functions based on code from MDN guides:
+ * https://developer.mozilla.org/en-US/docs/Glossary/Base64
+ *
+ * @module @lumjs/encode/base64
+ */
+/**
+ * Make a Base64 string URL-safe.
+ *
+ * Converts `+` to `-` and `/` to `_`.
+ * By default it also strips `=` padding characters.
+ *
+ * @param {string} string - A Base64-encoded string
+ * @param {object} [options] Options
+ * @param {boolean} [options.useTildes=false] Use tildes?
+ *
+ * Replaces `=` with `~` characters instead of stripping them.
+ * This option is for backwards-compatibility with old code only,
+ * and there's no reason to use it these days.
+ *
+ * @returns {string}
+ */
+export function urlize(string: string, options?: {
+    useTildes?: boolean;
+}): string;
+/**
+ * Undoes the effects of `urlize()`
+ *
+ * Doesn't matter if the string has actually been passed to `urlize()`,
+ * nor if the obsolete `options.useTildes` option was used when encoding.
+ *
+ * @param {string} string
+ * @returns {string}
+ */
+export function deurlize(string: string): string;
+/**
+ * Convert a Base64-encoded string into a Uint8Array.
+ *
+ * This is a low-level function with minimal options.
+ * See `decodeText()` for a more full-featured function.
+ *
+ * @param {string} base64 - Base64 encoded-string.
+ * @param {object} [options] Options.
+ * @param {boolean} [options.native=true] Use fromBase64() if it exists?
+ *
+ * When enabled, this checks to see if `Uint8Array.fromBase64()` exists,
+ * and if it does, will use it, passing the options to it.
+ *
+ * If this is disabled, the original toBytes algorithm will be used.
+ *
+ * This option is enabled by default, the only reason I could think of to
+ * disable it is if you are using this function as a polyfill.
+ *
+ * @returns {Uint8Array}
+ */
+export function toBytes(base64: string, options?: {
+    native?: boolean;
+}): Uint8Array;
+/**
+ * Convert a Uint8Array into Base64-encoded string.
+ *
+ * This is a low-level function with no options.
+ * See `encodeText()` for a more full-featured function.
+ *
+ * @param {Uint8Array} bytes - Byte array to convert.
+ * @param {object} [options] Options.
+ * @param {boolean} [options.native=true] Use toBase64() if it exists?
+ *
+ * When enabled, this checks to see if `bytes.toBase64()` exists,
+ * and if it does, will use it, passing the options to it.
+ *
+ * If this is disabled, the original fromBytes algorithm will be used.
+ *
+ * This option is enabled by default, the only reason I could think of to
+ * disable it is if you are using this function as a polyfill.
+ *
+ * @returns {string}
+ */
+export function fromBytes(bytes: Uint8Array, options?: {
+    native?: boolean;
+}): string;
+/**
+ * Encode a string to Base64.
+ *
+ * This adds a bunch of extra features on top of `fromBytes()`,
+ * including optionally passing the output through `urlize()`.
+ *
+ * @param {(string|Uint8Array)} data - Data to be encoded.
+ *
+ * If this is a String we'll use a `TextEncoder` instance to
+ * convert it into a Uint8Array before passing it to fromBytes().
+ *
+ * If this is a Uint8Array, we can skip the TextEncoder part.
+ *
+ * @param {(object|boolean)} [options] Options.
+ *
+ * - If boolean, used as `options.url`.
+ * - Passed to urlize() if `options.url` is true.
+ * - Always passed to fromBytes().
+ *
+ * @param {boolean} [options.url=false] Urlize the output?
+ * If true, converts `+`, `/`, and `=` to URL-friendly alternatives.
+ *
+ * @returns {string} A Base64-encoded string
+ */
+export function encodeText(data: (string | Uint8Array), options?: (object | boolean)): string;
+/**
+ * Decode a Base64 string into a Unicode string.
+ *
+ * Uses `toBytes()` and the `TextDecoder` API.
+ * Will pass input through `deurlize()` by default.
+ *
+ * @param {string} base64 - A Base64 string to decode
+ * @param {(object|boolean)} [options] Options
+ *
+ * - If `boolean`, used as `options.url`
+ * - Passed to `new TextDecoder()`
+ * - Passed to `decoder.decode()`
+ *
+ * @param {boolean} [options.string=true] Decode as a string?
+ * @param {boolean} [options.url=true] Deurlize the base64 string?
+ *
+ * Unless this is explicitly set as `false`, the `base64`
+ * string will be passed to `deurlize()` before being
+ * processed further.
+ *
+ * @returns {(string|Uint8Array)}
+ * Returned type depends on `opts.string`.
+ */
+export function decodeText(base64: string, options?: (object | boolean)): (string | Uint8Array);
+/**
+ * Encode binary data into a Base64-encoded Data URL.
+ *
+ * @param {(File|Blob|Array|TypedArray|ArrayBuffer)} data - Data to encode
+ *
+ * If this is not a `Blob` or `File`, it will be converted into one.
+ *
+ * @param {object} [options] Options
+ *
+ * @param {object} [options.blob] Options for Blob instances.
+ *
+ * If specified, this will be passed to the `Blob()` constructor.
+ *
+ * Only used if `data` is not already a `Blob` or `File` instance,
+ * and `options.file` was not specified or set to `false`.
+ *
+ * @param {(object|boolean)} [options.file] Options for File instances.
+ *
+ * If this is any non-false value, and `data` is not already a `Blob`,
+ * then we will convert `data` into a `File` instance instead of a `Blob`.
+ *
+ * If this is an `object`, it will be passed to the `File()` constructor.
+ *
+ * @param {string} [options.file.name] Filename for the `File` instance.
+ *
+ * This is likely never needed, but is kept for completion sake.
+ *
+ * @returns {Promise<string>} Resolves to the Data URL
+ */
+export function toDataUrl(data: (File | Blob | any[] | TypedArray | ArrayBuffer), options?: {
+    blob?: object;
+    file?: (object | boolean);
+}): Promise<string>;
+/**
+ * Decode a Data URL into arbitrary binary data.
+ *
+ * @param {string} dataUrl - A valid Data URL
+ * @param {object} [options] Options
+ * @param {boolean} [options.response=false] Return `Response`
+ * @param {boolean} [options.buffer=false] Return `ArrayBuffer`
+ *
+ * @returns {Promise<(Uint8Array|ArrayBuffer|Response)>} Promise of data
+ *
+ * By default this resolves to a `Uint8Array` instance.
+ *
+ * See `options.response` and `options.buffer` for alternative values that
+ * this may resolve to if requested.
+ *
+ */
+export function fromDataUrl(dataUrl: string, options?: {
+    response?: boolean;
+    buffer?: boolean;
+}): Promise<(Uint8Array | ArrayBuffer | Response)>;
+/**
+ * A wrapper around `toDataUrl()` that strips the Data URL header,
+ * leaving just the Base64 string, and can emit URL-safe strings.
+ *
+ * @param {mixed} data - See `toDataUrl()` for valid values
+ * @param {object} [options] Options
+ *
+ * - Passed to `toDataUrl()`
+ * - Passed to `urlize()` if `options.url` is `true`
+ *
+ * @param {boolean} [options.url=false] Use `urlize()` on encoded string?
+ *
+ * @returns {Promise<string>} Resolves to a Base64 string
+ */
+export function encodeData(data: mixed, options?: {
+    url?: boolean;
+}): Promise<string>;
+/**
+ * A wrapper around `fromDataUrl()` that adds a Data URL header
+ * if necessary, and can handle URL-safe Base64 strings.
+ *
+ * @param {*} base64
+ * @param {*} options
+ *
+ * - Passed to `fromDataUrl()`
+ * - Passed to `deurlize()` if `options.url` is NOT set to `false`
+ *
+ * @param {boolean} [options.url=true] Use `deurlize()` on decoded string?
+ *
+ * @returns {Promise} See `fromDataUrl()` for more details
+ */
+export function decodeData(base64: any, options?: any): Promise<any>;
+/**
+ * Encode data into a base64 string
+ *
+ * Uses `encodeText()` unless the `data` or `options` have specific
+ * values that indicate `encodeData()` should be used instead.
+ *
+ * @param {*} data - Data to encode
+ *
+ * If this is anything other than a `string`, `encodeData()` will be used.
+ *
+ * @param {object} [options] Options
+ *
+ * If either `options.blob` or `options.file` are specified,
+ * `encodeData()` will be used.
+ *
+ * @returns {(string|Promise<string>)}
+ * See `encodeText()` and `encodeData()` for details.
+ */
+export function encode(data: any, options?: object): (string | Promise<string>);
+/**
+ * Decode a base64 string into data
+ *
+ * Uses `decodeText()` unless the `base64` or `options` have specific
+ * values that indicate `decodeData()` should be used.
+ *
+ * @param {string} base64 - Base64-encoded string (or a Data URL).
+ *
+ * If this begins with a Data URL header, `decodeData()` will be used.
+ *
+ * @param {object} [options] Options
+ *
+ * If either `options.response` or `options.buffer` are true,
+ * `decodeData()` will be used.
+ *
+ * @returns {mixed} See `decodeText()` and `decodeData()` for details;
+ * will always be a `Promise` if `decodeData()` was used.
+ */
+export function decode(base64: string, options?: object): mixed;
+declare const UI8_FB64: boolean;
+export { UI8_FB64 as NATIVE_BASE64 };
+//# sourceMappingURL=base64.d.ts.map

package/types/auto/base64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64.d.ts","sourceRoot":"","sources":["../../lib/base64.js"],"names":[],"mappings":"AAaA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,+BAVW,MAAM,YAEd;IAA0B,SAAS,GAA3B,OAAO;CAMf,GAAU,MAAM,CAQlB;AAED;;;;;;;;GAQG;AACH,iCAHW,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gCAdW,MAAM,YAEd;IAA0B,MAAM,GAAxB,OAAO;CAUf,GAAU,UAAU,CAWtB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,iCAdW,UAAU,YAElB;IAA0B,MAAM,GAAxB,OAAO;CAUf,GAAU,MAAM,CAalB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,iCAlBW,CAAC,MAAM,GAAC,UAAU,CAAC,YAOnB,CAAC,MAAM,GAAC,OAAO,CAAC,GASd,MAAM,CA8BlB;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,mCAjBW,MAAM,YACN,CAAC,MAAM,GAAC,OAAO,CAAC,GAad,CAAC,MAAM,GAAC,UAAU,CAAC,CAmC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,gCA1BW,CAAC,IAAI,GAAC,IAAI,WAAO,UAAU,GAAC,WAAW,CAAC,YAMhD;IAAyB,IAAI,GAArB,MAAM;IAOqB,IAAI,GAA/B,CAAC,MAAM,GAAC,OAAO,CAAC;CAOxB,GAIU,OAAO,CAAC,MAAM,CAAC,CA6C3B;AAED;;;;;;;;;;;;;;;GAeG;AACH,qCAbW,MAAM,YAEd;IAA0B,QAAQ,GAA1B,OAAO;IACW,MAAM,GAAxB,OAAO;CAEf,GAAU,OAAO,CAAC,CAAC,UAAU,GAAC,WAAW,GAAC,QAAQ,CAAC,CAAC,CAetD;AAED;;;;;;;;;;;;;GAaG;AACH,iCAVW,KAAK,YAMb;IAA0B,GAAG,GAArB,OAAO;CAEf,GAAU,OAAO,CAAC,MAAM,CAAC,CAM3B;AAED;;;;;;;;;;;;;GAaG;AACH,mCAVW,GAAC,YACD,GAAC,gBAsBX;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,6BAZW,GAAC,YAID,MAAM,GAKJ,CAAC,MAAM,GAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAapC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,+BAZW,MAAM,YAIN,MAAM,GAKJ,KAAK,CAajB;AAnbD,gCAAgE"}

package/types/auto/base91.d.ts

@@ -0,0 +1,3 @@
+export function encode(data: any): string;
+export function decode(data: string, opts?: (object | boolean)): mixed;
+//# sourceMappingURL=base91.d.ts.map

package/types/auto/base91.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base91.d.ts","sourceRoot":"","sources":["../../lib/base91.js"],"names":[],"mappings":"AA6BiB,6BAPN,GAAC,GAKC,MAAM,CA8ElB;AAsBgB,6BAjBN,MAAM,SAIN,CAAC,MAAM,GAAC,OAAO,CAAC,GAQd,KAAK,CAiEjB"}

package/types/auto/hash.d.ts

@@ -0,0 +1,216 @@
+export = Hashifier;
+declare class Hashifier {
+    static "new"(opts?: {}): import("./hash");
+    /**
+     * Build a new Hashifier
+     *
+     * @param {(object|string)} [options] Options
+     *
+     * If this is a `string`, it's assumed to be the `options.algo` option.
+     *
+     * @param {string} [options.algo="SHA-256"] Digest (hash) algorithm
+     *
+     * By default we use `SHA-256` for backwards compatibility with my
+     * older libraries and apps. You can set it to any *digest algorithm*
+     * supported by the `SubtleCrypto` API.
+     *
+     * We look up the algorithm with
+     * [getAlgorithm()]{@link module:@lumjs/encode/hash#getAlgorithm},
+     * and so support hyphenless aliases and case-insensitive ids.
+     *
+     * For more information on supported digest algorithms, see:
+     * https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
+     *
+     * @param {object} [options.base64] Default options for `base64()`
+     *
+     * If specified, this will become the default options for the
+     * [base64()]{@link module:@lumjs/encode/hash#base64} method.
+     *
+     * @param {object} [options.base91] Default options for `base91()`
+     *
+     * If specified, this will become the default options for the
+     * [base91()]{@link module:@lumjs/encode/hash#base91} method.
+     *
+     * @param {(string|function|object)} [options.addUsing="base64"]
+     * Encoder for `add()` to use when non-string values are passed.
+     *
+     * If this is a `string`, it may be either `"base64"` or `"base91"`.
+     *
+     * If it is a `function`, it will be sent the data value and must
+     * return an encoded string representation of that value.
+     *
+     * If this is an `object`, it must have a method called `encode()`
+     * that works the same way as if you'd passed a `function`.
+     *
+     * @param {(string|function)} [options.joinWith=""]
+     * What `hash()` will use to join progressive data values.
+     *
+     * If this is a `string` the array of data values will be joined
+     * using the `array.join()` method.
+     *
+     * If it is a `function`, it will be sent the array of values,
+     * and must return an encoded representation of those values
+     * having been joined together in some fashion.
+     *
+     * The default value is an empty string, which means the data
+     * values are simply concatenated together with no separator.
+     *
+     * @param {number} [options.timeout=10000] Timeout for async encoding
+     *
+     * This is how long `hash()` will wait for async encoding to finish
+     * before throwing an error indicating something went wrong.
+     *
+     * Value is in milliseconds.
+     *
+     * @param {number} [options.tryEvery=100] Interval to test async encoding
+     *
+     * If async encoding is ongoing, this is the interval `hash()` will
+     * test to see if encoding has finished.
+     *
+     * Value is in milliseconds.
+     *
+     * @throws {Error} If `options.algo` was an invalid algorithm.
+     *
+     */
+    constructor(options?: (object | string));
+    options: any;
+    current: {
+        queue: number;
+        hash: any[];
+        encoder: any;
+        joiner: any;
+    };
+    algo: module;
+    defaults: {
+        base32: any;
+        base64: any;
+        base91: any;
+    };
+    timeout: any;
+    tryEvery: any;
+    /**
+     * Lookup a hashing algorithm and return details about it
+     *
+     * @param {string} id - The name of the algorithm.
+     *
+     * It's case-insensitive (will be forced to uppercase),
+     * and you may omit the hyphen in the algorithm name.
+     * Thus `sha256` is the same as `SHA-256`.
+     *
+     * @returns {?module:@lumjs/encode/hash~Algo}
+     * Will be an Algo info object if the `id` was valid,
+     * or `null` otherwise.
+     */
+    getAlgorithm(id: string): module | null;
+    /**
+     * Get a cryptographic *hash*.
+     *
+     * If you pass `input`, it will be hashed *immediately* and returned.
+     *
+     * Otherwise, if there is a current *progressive hash* in the process of
+     * being built, it will be *finalized* and returned.
+     *
+     * @param {(string|object)} [input] Input to hash immediately
+     *
+     * @return {Promise<ArrayBuffer>} See `SubtleCrypto.digest()` for details.
+     *
+     * @throws {TypeError} If the `options.joinWith` value is invalid,
+     * and no `input` was passed.
+     *
+     */
+    hash(input?: (string | object)): Promise<ArrayBuffer>;
+    /**
+     * Get hash as a Hex string.
+     *
+     * @param {(string|object|null)} [input]
+     * See [hash()]{@link module:@lumjs/encode/hash#hash} for details.
+     *
+     * @returns {string}
+     */
+    hex(input?: (string | object | null)): string;
+    /**
+     * Get hash as a Base32-encoded string.
+     *
+     * @param {(string|object|null)} [input]
+     * See [hash()]{@link module:@lumjs/encode/hash#hash}
+     *
+     * @param {object} [options] Options to pass to base32.encode().
+     *
+     * @returns {string}
+     */
+    base32(input?: (string | object | null), opts?: any): string;
+    /**
+     * Get hash as a Base64-encoded string.
+     *
+     * @param {(string|object|null)} [input]
+     * See [hash()]{@link module:@lumjs/encode/hash#hash} for details.
+     *
+     * @param {object} [options] Options for Base64 encoding
+     *
+     * @param {boolean} [options.url=false] Use URL-safe variant?
+     *
+     * @returns {string}
+     */
+    base64(input?: (string | object | null), opts?: any): string;
+    /**
+     * Get hash as a Base91-encoded string.
+     *
+     * @param {(string|object|null)} [input]
+     * See [hash()]{@link module:@lumjs/encode/hash#hash}
+     * @param {object} [opts] Options for how to encode the hash.
+     *
+     * @param {(boolean|object)} [opts.nba=false] Use `numByteArray()` ?
+     *
+     * This options is deprecated and will be removed in v3.0.
+     *
+     * If this is `true` the *hash string* will be passed to `numByteArray()`
+     * with the *default options* and the output from that will be passed to
+     * `base91.encode()`.
+     *
+     * If this is an `object`, then the same logic as `true` applies, except this
+     * will be used as the *explicit options* for the `numByteArray()` method.
+     *
+     * If this is `false` the `ArrayBffer` will be converted into a `Uint8Array`,
+     * and that will be passed to `base91.encode()`.
+     *
+     * @returns {string}
+     */
+    base91(input?: (string | object | null), opts?: {
+        nba?: (boolean | object);
+    }): string;
+    /**
+     * Add input to a progressive hash.
+     *
+     * @param {(string|object)} input - A value to add to the hash.
+     *
+     * If it is an `object` then it will be processed with the `addUsing`
+     * handler. See the constructor for details on supported formats.
+     *
+     * String values are simply added _as-is_.
+     *
+     * @return {object} `this`
+     */
+    add(input: (string | object), opts?: {}): object;
+    reset(): this;
+}
+declare namespace Hashifier {
+    export { module };
+}
+/**
+ * :@lumjs/encode/hash~Algo
+ */
+type module = {
+    /**
+     * - The formal id/name of the algorithm
+     */
+    id: string;
+    /**
+     * - The output length (in bits)
+     */
+    length: number;
+    /**
+     * - The block size (in bits)
+     */
+    block: number;
+};
+//# sourceMappingURL=hash.d.ts.map

package/types/auto/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../lib/hash.js"],"names":[],"mappings":";AAyDiB;IA8Xf,0CAGC;IA/XD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsEG;IACH,sBApEW,CAAC,MAAM,GAAC,MAAM,CAAC,EAyGzB;IA9BC,aAAsB;IAEtB;;;;;MAMC;IAED,aAGW;IAOX;;;;MAKC;IAED,aAA6C;IAC7C,cAA8C;IAIhD;;;;;;;;;;;;OAYG;IACH,iBAVW,MAAM,GAMH,MAAM,OAAA,CAoBnB;IAED;;;;;;;;;;;;;;;OAeG;IACH,aARW,CAAC,MAAM,GAAC,MAAM,CAAC,GAEd,OAAO,CAAC,WAAW,CAAC,CAkE/B;IAED;;;;;;;OAOG;IACH,YALW,CAAC,MAAM,GAAC,MAAM,GAAC,IAAI,CAAC,GAGlB,MAAM,CAOlB;IAED;;;;;;;;;OASG;IACH,eAPW,CAAC,MAAM,GAAC,MAAM,GAAC,IAAI,CAAC,eAKlB,MAAM,CAMlB;IAED;;;;;;;;;;;OAWG;IACH,eATW,CAAC,MAAM,GAAC,MAAM,GAAC,IAAI,CAAC,eAOlB,MAAM,CAOlB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,eApBW,CAAC,MAAM,GAAC,MAAM,GAAC,IAAI,CAAC,SAI5B;QAAgC,GAAG,GAA3B,CAAC,OAAO,GAAC,MAAM,CAAC;KAcxB,GAAU,MAAM,CAclB;IAED;;;;;;;;;;;OAWG;IACH,WATW,CAAC,MAAM,GAAC,MAAM,CAAC,cAOd,MAAM,CAyDjB;IAED,cAGC;CAOF;;;;;;;;;;;QAjZa,MAAM;;;;YACN,MAAM;;;;WACN,MAAM"}

package/types/auto/hmac.d.ts

@@ -0,0 +1,35 @@
+export = HmacEncoder;
+/**
+ * The main class to perform HMAC signing.
+ * @exports module:@lumjs/encode/hmac
+ */
+declare class HmacEncoder {
+    /**
+     * Create an encoder.
+     *
+     * @param {(string|TypedArray|ArrayBuffer)} keyValue - The secret key value.
+     * Will be used to generate the crypto key.
+     * @param {object} [options] Options
+     * @param {string} [options.algorithm="SHA-256"] Digest algorithm for HMAC.
+     */
+    constructor(keyValue: (string | TypedArray | ArrayBuffer), options?: {
+        algorithm?: string;
+    });
+    te: TextEncoder;
+    keyBytes: ArrayBufferView<ArrayBuffer>;
+    options: any;
+    /**
+     * Get the crypto key for this encoder instance.
+     * @returns {Promise<CryptoKey>}
+     */
+    getKey(): Promise<CryptoKey>;
+    /**
+     * Sign a message (any kind of data).
+     * @param {(string|TypedArray|ArrayBuffer)} message - Message to be signed.
+     * @returns {Promise<module:@lumjs/encode/signature>}
+     */
+    sign(message: (string | TypedArray | ArrayBuffer)): Promise<{
+        exports: typeof HmacEncoder;
+    }>;
+}
+//# sourceMappingURL=hmac.d.ts.map

package/types/auto/hmac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../lib/hmac.js"],"names":[],"mappings":";AAaA;;;GAGG;AACH;IACE;;;;;;;OAOG;IACH,sBALW,CAAC,MAAM,GAAC,UAAU,GAAC,WAAW,CAAC,YAGvC;QAAyB,SAAS,GAA1B,MAAM;KAChB,EAOA;IALC,gBAA2B;IAC3B,uCAE4B;IAC5B,aAAmD;IAGrD;;;OAGG;IACH,UAFa,OAAO,CAAC,SAAS,CAAC,CAkB9B;IAED;;;;OAIG;IACH,cAHW,CAAC,MAAM,GAAC,UAAU,GAAC,WAAW,CAAC,GAC7B,OAAO;;MAAO,CAe1B;CAEF"}

package/types/auto/hotp.d.ts

@@ -0,0 +1,42 @@
+export = HOTP;
+/**
+ * HMAC-based One-Time-Passwords.
+ *
+ * TODO: this needs documentation!
+ *
+ * @exports module:@lumjs/encode/hotp
+ */
+declare class HOTP {
+    constructor(options: any);
+    setOptions(options: any): this;
+    options: any;
+    getOptions(...args: any[]): any;
+    get defaultKey(): any;
+    get defaultOptions(): {
+        algorithm: string;
+        checkSize: number;
+        counter: number;
+        debug: number;
+        window: number;
+    }[];
+    generate(key: any, opts: any, fromVerify?: boolean): Promise<{
+        code: string;
+        opts: any;
+        toString(): string;
+    }>;
+    verify(token: any, key: any, opts: any): Promise<{
+        ok: boolean;
+    }>;
+    DEBUG: Readonly<{
+        LOG: 1;
+        INFO: 2;
+    }>;
+}
+declare namespace HOTP {
+    export { DEBUG };
+}
+declare const DEBUG: Readonly<{
+    LOG: 1;
+    INFO: 2;
+}>;
+//# sourceMappingURL=hotp.d.ts.map

package/types/auto/hotp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hotp.d.ts","sourceRoot":"","sources":["../../lib/hotp.js"],"names":[],"mappings":";AA2BA;;;;;;GAMG;AACH;IACE,0BAEC;IAED,+BAQC;IAHG,aAAsD;IAK1D,gCAEC;IAED,sBAEC;IAED;;;;;;QAEC;IAED;;;;OA6CC;IAED;;OAiCC;IAIH;;;OAAoB;CAHnB;;;;AAzID;;;GAGG"}

package/types/auto/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/types/auto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../lib/index.js"],"names":[],"mappings":""}

package/types/auto/pem.d.ts

@@ -0,0 +1,62 @@
+export = PEM;
+/**
+ * A class for parsing and decoding PEM documents.
+ *
+ * PEM is a format commonly used for encryption keys.
+ * See: https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail
+ *
+ * @alias {module:@lumjs/encode/pem}
+ */
+declare class PEM {
+    /**
+     * Parse a string into a PEM object instance.
+     *
+     * This is almost identical to the main class constructor,
+     * except this version will simply return null if the argument
+     * could not be parsed as a valid PEM string.
+     *
+     * @param {string} pemText - PEM format string to be parsed.
+     * @returns {?module:@lumjs/encode/pem} A PEM instance;
+     * or null if the pemText could not be parsed.
+     */
+    static parse(pemText: string): {
+        exports: typeof PEM;
+    } | null;
+    /**
+     * Parse a string into a PEM object instance.
+     *
+     * This method is strict and will throw an error on failure.
+     * For a more lenient way to parse PEM documents, see the
+     * {@link module:@lumjs/encode/pem.parse parse()} method.
+     *
+     * @param {string} pem - PEM format string to be parsed.
+     * @throws {TypeError} If the `pem` argument is an invalid value.
+     * @throws {SyntaxErrror} If the `pem` string was not able to be parsed.
+     */
+    constructor(pem: string);
+    /**
+     * Decode the base64 content.
+     *
+     * @param {(boolean|function)} [typeClass=false] Return a TypedArray?
+     *
+     * This may be set to the constructor function of any TypedArray class.
+     * It may also be set to `true` as an alias for `Uint8Array`.
+     *
+     * If it is set to `false` (the default), then the binary string output
+     * from the `atob()` global function will be used as the return value.
+     *
+     * If this is set to Uint8Array (either explicitly or by using `true`),
+     * and a method named `Uint8Array.fromBase64` exists, then this will use
+     * that to parse the base64 content rather than using the
+     * {@link module:@lumjs/encode/util.str2ta str2ta()} function.
+     *
+     * @returns {(string|TypedArray|Error)}
+     *
+     * If an error is thrown by any functions being used to decode the base64
+     * content, that error will be the return value.
+     *
+     * Otherwise the `typeClass` argument will determine the returned type.
+     */
+    decode(typeClass?: (boolean | Function)): (string | TypedArray | Error);
+}
+//# sourceMappingURL=pem.d.ts.map

package/types/auto/pem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pem.d.ts","sourceRoot":"","sources":["../../lib/pem.js"],"names":[],"mappings":";AAaA;;;;;;;GAOG;AACH;IAwFE;;;;;;;;;;OAUG;IACH,sBAJW,MAAM,GACJ;;YAAO,CAMnB;IApGD;;;;;;;;;;OAUG;IACH,iBAJW,MAAM,EAqBhB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,mBApBW,CAAC,OAAO,WAAS,CAAC,GAahB,CAAC,MAAM,GAAC,UAAU,GAAC,KAAK,CAAC,CAsCrC;CAkBF"}

package/types/auto/polyfill.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Polyfill Ruleset
+ */
+export type PolyfillRuleset = {
+    /**
+     * - The target to polyfill.
+     *
+     * Class constructors are functions, class prototypes are objects.
+     * Each Ruleset may only have one target, so if you need to polyfill
+     * both static and instance methods you'll need to use an array with
+     * a Ruleset for the constructor, and a Ruleset for the prototype.
+     */
+    into: (object | Function);
+    /**
+     * - An object containing the polyfill methods.
+     *
+     * Any method in this object that doesn't exist in the `for` target,
+     * will be added to it. As these are expected to be methods respecting
+     * the `this` context variable they should NOT be arrow (`=>`) closures.
+     */
+    fill: object;
+};
+export namespace NON {
+    let native: boolean;
+}
+/**
+ * Polyfills for Uint8Array.
+ *
+ * This is an array of two ruleset objects:
+ *
+ * - Uint8Array
+ *   - fromBase64()
+ *   - fromHex()
+ * - Uint8Array.prototype
+ *   - toBase64()
+ *   - toHex()
+ *
+ * @alias module:@lumjs/encode/polyfill.UI8
+ * @type {PolyfillRuleset[]}
+ */
+export const UI8: PolyfillRuleset[];
+export function isPolyfill(v: any): any;
+/**
+ * Process one or more polyfill definitions.
+ * @param {(PolyfillRuleset|PolyfillRuleset[])} rules - Rulesets to apply.
+ *
+ * You can pass a single Ruleset object, or an array of associated Rulesets.
+ *
+ * @returns {Map}
+ *
+ * @example
+ *
+ * For these examples I'll be applying the `UI8` polyfills.
+ *
+ * **Usage if using *ESModules***:
+ *
+ * ```js
+ * import { polyfill, UI8 } from '@lumjs/encode/polyfill';
+ * polyfill(UI8);
+ * ```
+ *
+ * **OR if using *CommonJS***:
+ *
+ * ```js
+ * const { polyfill, UI8 } = require('@lumjs/encode/polyfill');
+ * polyfill(UI8);
+ * ```
+ *
+ * @alias module:@lumjs/encode/polyfill.polyfill
+ */
+export function polyfill(rules: (PolyfillRuleset | PolyfillRuleset[])): Map;
+//# sourceMappingURL=polyfill.d.ts.map

package/types/auto/polyfill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polyfill.d.ts","sourceRoot":"","sources":["../../lib/polyfill.js"],"names":[],"mappings":";;;;;;;;;;;;UAyHU,CAAC,MAAM,WAAS,CAAC;;;;;;;;UAOjB,MAAM;;;;;AAnHhB;;;;;;;;;;;;;;GAcG;AACH,kBAFU,eAAe,EAAE,CAyBzB;AAEF,wCAGC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gCA1BW,CAAC,eAAe,GAAC,eAAe,EAAE,CAAC,GAIjC,GAAG,CAiDf"}

package/types/auto/signature.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A small wrapepr class representing a crypto signature.
+ * @alias module:@lumjs/encode/signature
+ */
+declare class Signature {
+    /**
+     * Build a Signature instance.
+     * @param {ArrayBuffer} buffer - The signature data.
+     */
+    constructor(buffer: ArrayBuffer);
+    buffer: ArrayBuffer;
+    /**
+     * Get the signature as a Uint8Array.
+     */
+    get uint8Array(): Uint8Array<ArrayBuffer>;
+    /**
+     * Get the signature as an array of bytes.
+     */
+    get byteArray(): any;
+    /**
+     * Get the signature as a Hex string.
+     */
+    get hex(): any;
+}
+//# sourceMappingURL=signature.d.ts.map

package/types/auto/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../lib/signature.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH;IACE;;;OAGG;IACH,oBAFW,WAAW,EAIrB;IADC,oBAAoB;IAGtB;;OAEG;IACH,0CAEC;IAED;;OAEG;IACH,qBAEC;IAED;;OAEG;IACH,eAEC;CACF"}

package/types/auto/totp.d.ts

@@ -0,0 +1,22 @@
+export = TOTP;
+/**
+ * Time-based One-Time-Passwords.
+ *
+ * TODO: this needs documentation!
+ *
+ * @exports module:@lumjs/encode/totp
+ */
+declare class TOTP extends HOTP {
+    get defaultOptions(): ({
+        algorithm: string;
+        checkSize: number;
+        counter: number;
+        debug: number;
+        window: number;
+    } | {
+        step: number;
+    })[];
+    getExpiry(opts: any): any;
+}
+import HOTP = require("./hotp");
+//# sourceMappingURL=totp.d.ts.map

package/types/auto/totp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"totp.d.ts","sourceRoot":"","sources":["../../lib/totp.js"],"names":[],"mappings":";AAKA;;;;;;GAMG;AACH;IACE;;;;;;;;SAEC;IAED,0BAEC;CAUF"}

package/types/auto/util.d.ts

@@ -0,0 +1,26 @@
+export function ord(string: string): number;
+export function numByteArray(numStr: string, options?: (object | number), ...args: any[]): any[];
+export function wordArrayToUint8Array(wordArray: WordArray): Uint8Array;
+export function intToBytes(num: Integer): any[];
+export function hexToBytes(hex: string, uint8?: boolean, native?: boolean): (number[] | Uint8Array);
+export function bytesToHex(bytes: (Uint8Array | number[]), native?: boolean): string;
+/**
+ * Convert a binary string into a TypedArray.
+ *
+ * Inspired by the str2ab() example from:
+ * https://developer.chrome.com/blog/how-to-convert-arraybuffer-to-and-from-string
+ *
+ * The biggest difference being this version supports specifying the specific
+ * TypedArray class you want to use, and it returns the TypedArray by default
+ * rather than the ArrayBuffer.
+ *
+ * To get the ArrayBuffer just use: `str2ta(string).buffer;`
+ *
+ * @param {string} str - Binary string to convert.
+ * @param {function} [typeClass=Uint8Array] TypedArray class to use;
+ * MUST be a TypedArray class constructor. Default is `Uint8Array`.
+ * @returns {TypedArray} Will be an instance of `typeClass`.
+ * @throws {TypeError} If invalid arguments were passed.
+ */
+export function str2ta(str: string, typeClass?: Function): TypedArray;
+//# sourceMappingURL=util.d.ts.map

package/types/auto/util.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../lib/util.js"],"names":[],"mappings":"AAsBc,4BAHH,MAAM,GACJ,MAAM,CAiClB;AAyCsB,qCApCZ,MAAM,YACN,CAAC,MAAM,GAAC,MAAM,CAAC,yBAyFzB;AAQ+B,iDAHrB,SAAS,GACP,UAAU,CAwBtB;AAWoB,gCAHV,OAAO,SAYjB;AAkBoB,gCAVV,MAAM,UACN,OAAO,WACP,OAAO,GAML,CAAC,MAAM,EAAE,GAAC,UAAU,CAAC,CAcjC;AAcoB,kCATV,CAAC,UAAU,GAAC,MAAM,EAAE,CAAC,WACrB,OAAO,GAML,MAAM,CAWlB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,4BANW,MAAM,yBAGJ,UAAU,CAoBtB"}

package/types/sets/_inc.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Make lowercase aliases for every key in an object.
+ * @param {object} obj - Target object.
+ * @returns {object} `obj`
+ */
+export function makeSet(obj: object): object;

package/types/sets/all.d.ts

@@ -0,0 +1,2 @@
+export * from './digest.js';
+export * from './otp.js';

package/types/sets/base.d.ts

@@ -0,0 +1,6 @@
+import Base32 from '../auto/base32.js';
+import Base64 from '../auto/base64.js';
+import Base91 from '../auto/base91.js';
+import * as Util from '../auto/util.js';
+
+export { Base32, Base64, Base91, Util }

package/types/sets/digest.d.ts

@@ -0,0 +1,4 @@
+import Hash from '../auto/hash.js';
+
+export * from './base.js';
+export { Hash }

package/types/sets/otp.d.ts

@@ -0,0 +1,5 @@
+import HOTP from '../auto/hotp.js';
+import TOTP from '../auto/totp.js';
+
+export * from './sign.js';
+export { HOTP, TOTP }

package/types/sets/sign.d.ts

@@ -0,0 +1,6 @@
+import HMAC from '../auto/hmac.js';
+import PEM from '../auto/pem.js';
+import Signature from '../auto/signature.js';
+import Util from '../auto/util.js';
+
+export { HMAC, PEM, Signature, Util }

package/jsdoc.json

@@ -1,33 +0,0 @@
-{
-  "tags": 
-  {
-    "allowUnknownTags": true
-  },
-  "source":
-  {
-    "include": ["./lib"]
-  },
-  "opts": 
-  {
-    "destination": "./docs/api",
-    "recurse": true
-  },
-  "plugins": 
-  [
-    "plugins/markdown"
-  ],
-  "templates": 
-  {
-    "cleverLinks": false,
-    "monospaceLinks": false,
-    "default": 
-    {
-      "outputSourceFiles": true
-    },
-    "path": "ink-docstrap",
-    "theme": "cerulean",
-    "navType": "vertical",
-    "linenums": true,
-    "dateFormat": "YYYY-MM-DD, hh:mm:ss"
-  }
-}