@lumjs/encode 2.4.1 → 2.6.0

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"}