@lumjs/encode 2.4.1 → 2.6.0

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