@jscv-solutions/node-crypto 0.0.0-stage → 1.0.0-rc.2

package/dist/cjs/shared/deprecation.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Deprecation signalling shared by every namespace.
+ *
+ * A deprecated algorithm is marked with the JSDoc `@deprecated` tag at
+ * its declaration site and calls `emitDeprecationWarning` on first use.
+ * Warnings go through `process.emitWarning` (never `console.warn`) so
+ * they honor `--no-warnings` and `--disable-warning`, and each stable
+ * warning code is emitted at most once per process. The algorithm name
+ * is public and safe to include in the message.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deprecationCodeFor = deprecationCodeFor;
+exports.emitDeprecationWarning = emitDeprecationWarning;
+const emittedCodes = new Set();
+/**
+ * Derives the stable process-warning code for a deprecated algorithm.
+ *
+ * @param algorithm - Lowercase kebab-case algorithm identifier.
+ * @returns The stable warning code for the algorithm.
+ */
+function deprecationCodeFor(algorithm) {
+    const token = algorithm.toUpperCase().replace(/-/g, '_');
+    return `NODE_CRYPTO_DEPRECATED_${token}`;
+}
+/**
+ * Emits the deprecation warning for an algorithm, once per process.
+ *
+ * @param algorithm - Lowercase kebab-case algorithm identifier.
+ */
+function emitDeprecationWarning(algorithm) {
+    const code = deprecationCodeFor(algorithm);
+    if (emittedCodes.has(code)) {
+        return;
+    }
+    emittedCodes.add(code);
+    process.emitWarning(`The '${algorithm}' algorithm is deprecated and will be removed in a future major release.`, { code, type: 'DeprecationWarning' });
+}

package/dist/cjs/shared/encodings.d.ts

@@ -0,0 +1,30 @@
+import type { Encoding } from './typings/encodings.js';
+/**
+ * Encodes bytes as text with the requested encoding.
+ *
+ * @param data - Bytes to encode.
+ * @param encoding - Target text encoding.
+ * @returns The encoded text (`base64url` output is unpadded).
+ */
+export declare function encodeBytes(data: Uint8Array, encoding: Encoding): string;
+/**
+ * Decodes text back into bytes, strictly validating the input.
+ *
+ * @param text - Encoded text to decode.
+ * @param encoding - Text encoding the input claims to use.
+ * @returns The decoded bytes.
+ * @throws {InvalidEncodingError} WHEN the text breaks the encoding rules.
+ */
+export declare function decodeText(text: string, encoding: Encoding): Buffer;
+/**
+ * Checks text against the alphabet and shape rules of an encoding.
+ *
+ * `base64` follows the padded canonical form. `base64url` accepts the
+ * unpadded form the encoder emits (whose length is never one past a
+ * multiple of four) as well as correctly padded input.
+ *
+ * @param text - Candidate encoded text.
+ * @param encoding - Encoding whose rules apply.
+ * @returns Whether the text is well formed for the encoding.
+ */
+export declare function isWellFormed(text: string, encoding: Encoding): boolean;

package/dist/cjs/shared/encodings.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodeBytes = encodeBytes;
+exports.decodeText = decodeText;
+exports.isWellFormed = isWellFormed;
+/**
+ * Binary-to-text encodings shared by every namespace.
+ *
+ * Supported encodings are `hex`, `base64` and `base64url`. Decoding is
+ * strict: input outside the encoding alphabet (or breaking its length
+ * and padding rules) throws an `InvalidEncodingError` instead of being
+ * silently truncated the way `Buffer.from` would on its own. Error
+ * messages never echo the offending input.
+ */
+const errors_ts_1 = require("./errors.js");
+const HEXPattern = /^[0-9a-fA-F]*$/;
+const base64Pattern = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
+const base64UrlPaddedPattern = /^(?:[A-Za-z0-9\-_]{4})*(?:[A-Za-z0-9\-_]{2}==|[A-Za-z0-9\-_]{3}=)?$/;
+const base64UrlUnpaddedPattern = /^[A-Za-z0-9\-_]*$/;
+/**
+ * Encodes bytes as text with the requested encoding.
+ *
+ * @param data - Bytes to encode.
+ * @param encoding - Target text encoding.
+ * @returns The encoded text (`base64url` output is unpadded).
+ */
+function encodeBytes(data, encoding) {
+    const buffer = Buffer.from(data);
+    const text = buffer.toString(encoding);
+    return text;
+}
+/**
+ * Decodes text back into bytes, strictly validating the input.
+ *
+ * @param text - Encoded text to decode.
+ * @param encoding - Text encoding the input claims to use.
+ * @returns The decoded bytes.
+ * @throws {InvalidEncodingError} WHEN the text breaks the encoding rules.
+ */
+function decodeText(text, encoding) {
+    if (!isWellFormed(text, encoding)) {
+        throw new errors_ts_1.InvalidEncodingError(`Invalid ${encoding} string: input breaks the ${encoding} rules.`);
+    }
+    const buffer = Buffer.from(text, encoding);
+    return buffer;
+}
+/**
+ * Checks text against the alphabet and shape rules of an encoding.
+ *
+ * `base64` follows the padded canonical form. `base64url` accepts the
+ * unpadded form the encoder emits (whose length is never one past a
+ * multiple of four) as well as correctly padded input.
+ *
+ * @param text - Candidate encoded text.
+ * @param encoding - Encoding whose rules apply.
+ * @returns Whether the text is well formed for the encoding.
+ */
+function isWellFormed(text, encoding) {
+    if (encoding === 'hex') {
+        return text.length % 2 === 0 && HEXPattern.test(text);
+    }
+    if (encoding === 'base64') {
+        return text.length % 4 === 0 && base64Pattern.test(text);
+    }
+    if (text.includes('=')) {
+        return text.length % 4 === 0 && base64UrlPaddedPattern.test(text);
+    }
+    return text.length % 4 !== 1 && base64UrlUnpaddedPattern.test(text);
+}

package/dist/cjs/shared/errors.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Error model shared by every namespace of the library.
+ *
+ * Every error thrown by the library is an instance of `NodeCryptoError`
+ * (or a subclass) and carries a stable string `code` that callers can
+ * switch on. Codes are part of the public contract: never rename or
+ * remove one without a major release.
+ *
+ * Message hygiene: constructors accept a message built by the throwing
+ * code. Callers MUST NOT interpolate secrets, passwords, keys or
+ * plaintext into messages. Algorithm identifiers and package names are
+ * public and safe to include.
+ */
+import type { ErrorCode } from './typings/errors.js';
+/**
+ * Base class for every error thrown by the library.
+ */
+export declare class NodeCryptoError extends Error {
+    /** Stable machine-readable failure identifier. */
+    readonly code: ErrorCode;
+    /**
+     * Creates a library error with a stable code.
+     *
+     * @param message - Human-readable description without secrets.
+     * @param code - Stable machine-readable failure identifier.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message: string, code: ErrorCode, options?: ErrorOptions);
+}
+/**
+ * A function received an argument of the wrong type or range.
+ */
+export declare class InvalidArgumentError extends NodeCryptoError {
+    /**
+     * Creates an invalid-argument error.
+     *
+     * @param message - Human-readable description without secrets.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * Encoded text contains characters outside its alphabet or breaks the
+ * encoding rules (for example odd-length hexadecimal).
+ */
+export declare class InvalidEncodingError extends NodeCryptoError {
+    /**
+     * Creates an invalid-encoding error.
+     *
+     * @param message - Human-readable description without echoing the input.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * An optional peer dependency (for example `bcrypt`) is not installed,
+ * so the requested operation cannot run.
+ */
+export declare class MissingPeerDependencyError extends NodeCryptoError {
+    /**
+     * Creates a missing-peer-dependency error.
+     *
+     * @param message - Description naming the package and how to install it.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message: string, options?: ErrorOptions);
+}
+/**
+ * The caller passed an algorithm identifier the function does not support.
+ */
+export declare class UnsupportedAlgorithmError extends NodeCryptoError {
+    /**
+     * Creates an unsupported-algorithm error.
+     *
+     * @param message - Description naming the received identifier.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message: string, options?: ErrorOptions);
+}

package/dist/cjs/shared/errors.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedAlgorithmError = exports.MissingPeerDependencyError = exports.InvalidEncodingError = exports.InvalidArgumentError = exports.NodeCryptoError = void 0;
+/**
+ * Base class for every error thrown by the library.
+ */
+class NodeCryptoError extends Error {
+    /** Stable machine-readable failure identifier. */
+    code;
+    /**
+     * Creates a library error with a stable code.
+     *
+     * @param message - Human-readable description without secrets.
+     * @param code - Stable machine-readable failure identifier.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message, code, options) {
+        super(message, options);
+        this.name = 'NodeCryptoError';
+        this.code = code;
+    }
+}
+exports.NodeCryptoError = NodeCryptoError;
+/**
+ * A function received an argument of the wrong type or range.
+ */
+class InvalidArgumentError extends NodeCryptoError {
+    /**
+     * Creates an invalid-argument error.
+     *
+     * @param message - Human-readable description without secrets.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message, options) {
+        super(message, 'INVALID_ARGUMENT', options);
+        this.name = 'InvalidArgumentError';
+    }
+}
+exports.InvalidArgumentError = InvalidArgumentError;
+/**
+ * Encoded text contains characters outside its alphabet or breaks the
+ * encoding rules (for example odd-length hexadecimal).
+ */
+class InvalidEncodingError extends NodeCryptoError {
+    /**
+     * Creates an invalid-encoding error.
+     *
+     * @param message - Human-readable description without echoing the input.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message, options) {
+        super(message, 'INVALID_ENCODING', options);
+        this.name = 'InvalidEncodingError';
+    }
+}
+exports.InvalidEncodingError = InvalidEncodingError;
+/**
+ * An optional peer dependency (for example `bcrypt`) is not installed,
+ * so the requested operation cannot run.
+ */
+class MissingPeerDependencyError extends NodeCryptoError {
+    /**
+     * Creates a missing-peer-dependency error.
+     *
+     * @param message - Description naming the package and how to install it.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message, options) {
+        super(message, 'MISSING_PEER_DEPENDENCY', options);
+        this.name = 'MissingPeerDependencyError';
+    }
+}
+exports.MissingPeerDependencyError = MissingPeerDependencyError;
+/**
+ * The caller passed an algorithm identifier the function does not support.
+ */
+class UnsupportedAlgorithmError extends NodeCryptoError {
+    /**
+     * Creates an unsupported-algorithm error.
+     *
+     * @param message - Description naming the received identifier.
+     * @param options - Optional error options (for example `cause`).
+     */
+    constructor(message, options) {
+        super(message, 'UNSUPPORTED_ALGORITHM', options);
+        this.name = 'UnsupportedAlgorithmError';
+    }
+}
+exports.UnsupportedAlgorithmError = UnsupportedAlgorithmError;

package/dist/cjs/shared/inputs.d.ts

@@ -0,0 +1,9 @@
+import type { CryptoInput } from './typings/inputs.js';
+/**
+ * Normalizes accepted input into a fresh Buffer of bytes.
+ *
+ * @param input - String (UTF-8), Buffer or Uint8Array holding the data.
+ * @returns A Buffer copy of the input bytes.
+ * @throws {InvalidArgumentError} WHEN the input has an unexpected type.
+ */
+export declare function toBytes(input: CryptoInput): Buffer;

package/dist/cjs/shared/inputs.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toBytes = toBytes;
+/**
+ * Input handling shared by every namespace.
+ *
+ * Wherever a function accepts data it accepts `CryptoInput`: a UTF-8
+ * string, a Buffer or a Uint8Array. Normalization copies the bytes, so
+ * later mutation of a caller-provided view cannot affect the operation.
+ */
+const errors_ts_1 = require("./errors.js");
+/**
+ * Normalizes accepted input into a fresh Buffer of bytes.
+ *
+ * @param input - String (UTF-8), Buffer or Uint8Array holding the data.
+ * @returns A Buffer copy of the input bytes.
+ * @throws {InvalidArgumentError} WHEN the input has an unexpected type.
+ */
+function toBytes(input) {
+    if (typeof input === 'string') {
+        const buffer = Buffer.from(input, 'utf8');
+        return buffer;
+    }
+    if (input instanceof Uint8Array) {
+        const buffer = Buffer.from(input);
+        return buffer;
+    }
+    throw new errors_ts_1.InvalidArgumentError('Invalid input: expected a string, Buffer or Uint8Array.');
+}

package/dist/cjs/shared/peer-loading.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Loads a peer dependency asynchronously with dynamic `import`.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ * @throws {MissingPeerDependencyError} WHEN the peer cannot be resolved.
+ */
+export declare function loadPeer(specifier: string): Promise<unknown>;
+/**
+ * Loads a peer dependency synchronously with the per-format loader.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ * @throws {MissingPeerDependencyError} WHEN the peer cannot be resolved.
+ */
+export declare function loadPeerSync(specifier: string): unknown;

package/dist/cjs/shared/peer-loading.js

@@ -0,0 +1,129 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadPeer = loadPeer;
+exports.loadPeerSync = loadPeerSync;
+/**
+ * Lazy loading for optional peer dependencies (currently `bcrypt`).
+ *
+ * Peers load only when an operation needing them is first invoked, so
+ * callers without the peer installed can still use every other
+ * namespace. Async callers use dynamic `import`; sync callers use the
+ * per-format `#sync-require` loader (native `require` in CJS,
+ * `createRequire` anchored at the loader file in ESM). A peer that
+ * cannot be resolved throws a `MissingPeerDependencyError` naming the
+ * package to install; any other load failure propagates unchanged.
+ */
+const _sync_require_1 = require("#sync-require");
+const errors_ts_1 = require("./errors.js");
+/**
+ * Extracts the Node.js error code from an unknown load failure.
+ *
+ * @param error - Failure raised while loading the peer.
+ * @returns The error code when present, otherwise undefined.
+ */
+function errorCodeOf(error) {
+    if (typeof error !== 'object' || error === null) {
+        return undefined;
+    }
+    if (!('code' in error)) {
+        return undefined;
+    }
+    const code = error.code;
+    return typeof code === 'string' ? code : undefined;
+}
+/**
+ * Reports whether a load failure means the peer is not installed.
+ *
+ * @param error - Failure raised while loading the peer.
+ * @returns Whether the peer module could not be resolved.
+ */
+function isPeerMissing(error) {
+    const code = errorCodeOf(error);
+    return code === 'MODULE_NOT_FOUND' || code === 'ERR_MODULE_NOT_FOUND';
+}
+/**
+ * Builds the missing-peer error naming the package to install.
+ *
+ * @param specifier - Bare peer specifier that could not be resolved.
+ * @param error - Original resolution failure, kept as `cause`.
+ * @returns The missing-peer-dependency error.
+ */
+function missingPeerError(specifier, error) {
+    return new errors_ts_1.MissingPeerDependencyError(`Optional peer dependency '${specifier}' is not installed. Install '${specifier}' to use this feature.`, { cause: error });
+}
+/**
+ * Loads a peer dependency asynchronously with dynamic `import`.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ * @throws {MissingPeerDependencyError} WHEN the peer cannot be resolved.
+ */
+function loadPeer(specifier) {
+    const peer = Promise.resolve(`${__rewriteRelativeImportExtension(specifier)}`).then(s => __importStar(require(s))).catch((error) => {
+        if (isPeerMissing(error)) {
+            throw missingPeerError(specifier, error);
+        }
+        throw error;
+    });
+    return peer;
+}
+/**
+ * Loads a peer dependency synchronously with the per-format loader.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ * @throws {MissingPeerDependencyError} WHEN the peer cannot be resolved.
+ */
+function loadPeerSync(specifier) {
+    try {
+        const peer = (0, _sync_require_1.loadSyncPeer)(specifier);
+        return peer;
+    }
+    catch (error) {
+        if (isPeerMissing(error)) {
+            throw missingPeerError(specifier, error);
+        }
+        throw error;
+    }
+}

package/dist/cjs/shared/require-sync-cjs.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Synchronous peer loader for CommonJS callers.
+ *
+ * This file is compiled only in the CJS build and the typecheck program
+ * (see the `#sync-require` mapping and the per-build `exclude` lists).
+ * The module-scoped `require` resolves the peer relative to this file.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ */
+export declare function loadSyncPeer(specifier: string): unknown;

package/dist/cjs/shared/require-sync-cjs.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadSyncPeer = loadSyncPeer;
+/**
+ * Synchronous peer loader for CommonJS callers.
+ *
+ * This file is compiled only in the CJS build and the typecheck program
+ * (see the `#sync-require` mapping and the per-build `exclude` lists).
+ * The module-scoped `require` resolves the peer relative to this file.
+ *
+ * @param specifier - Bare peer specifier to load (for example `bcrypt`).
+ * @returns The loaded peer module.
+ */
+function loadSyncPeer(specifier) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports -- this per-format file ships only in the CJS build, where require is the correct loader
+    const peer = require(specifier);
+    return peer;
+}

package/dist/cjs/shared/typings/encodings.d.ts

@@ -0,0 +1,2 @@
+/** Text encodings the library reads and writes. */
+export type Encoding = 'hex' | 'base64' | 'base64url';

package/dist/cjs/shared/typings/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Stable string codes identifying every failure of the library. Codes
+ * are part of the public contract: never rename or remove one without
+ * a major release.
+ */
+export type ErrorCode =
+  | 'INVALID_ARGUMENT'
+  | 'INVALID_ENCODING'
+  | 'MISSING_PEER_DEPENDENCY'
+  | 'UNSUPPORTED_ALGORITHM';

package/dist/cjs/shared/typings/inputs.d.ts

@@ -0,0 +1,2 @@
+/** Data accepted wherever a function takes input bytes. */
+export type CryptoInput = string | Buffer | Uint8Array;

package/dist/esm/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "imports": {
+    "#sync-require": "./shared/require-sync-esm.js"
+  }
+}

package/dist/esm/packages/comparison/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/comparison/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'comparison';

package/dist/esm/packages/digest/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/digest/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'digest';

package/dist/esm/packages/encryption/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/encryption/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'encryption';

package/dist/esm/packages/key-derivation/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/key-derivation/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'key-derivation';

package/dist/esm/packages/message-authentication/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/message-authentication/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'message-authentication';

package/dist/esm/packages/password-hashing/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/password-hashing/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'password-hashing';

package/dist/esm/packages/random/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export declare const namespace: string;

package/dist/esm/packages/random/index.js

@@ -0,0 +1,5 @@
+/**
+ * Temporary scaffolding for the repository-tooling change.
+ * The real implementation lands in a later change.
+ */
+export const namespace = 'random';

package/dist/esm/shared/algorithms.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Asserts the received identifier is one of the supported identifiers.
+ *
+ * @param algorithm - Identifier passed by the caller.
+ * @param supported - Identifiers the calling function supports.
+ * @throws {UnsupportedAlgorithmError} WHEN the identifier is unsupported.
+ */
+export declare function assertSupportedAlgorithm(algorithm: string, supported: readonly string[]): void;